Utwórz linijkę binarną

22

Biorąc pod uwagę liczbę n , wygeneruj pierwsze n kolumn tego wzoru:

                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################ ...

Wysokość kolumny przy (1-indeksowanym) n jest liczbą końcowych 0bitów w reprezentacji binarnej n plus jeden. W rezultacie w dolnej warstwie jest wypełniona każda kolumna, druga warstwa co druga kolumna, trzecia warstwa co czwarta kolumna itp.

Zasady

  • Możesz wprowadzać i wyprowadzać dowolną standardową metodą.
  • Możesz założyć, że wejście jest liczbą całkowitą od 1 do 999 włącznie.
  • Dane wyjściowe mogą zawierać dowolną ilość białych znaków, o ile wzór jest nienaruszony.
  • Wzór musi być indeksowany 1 i mieć ten sam format, jak pokazano tutaj.
  • Możesz użyć dowolnego pojedynczego znaku spacji zamiast #, ale nie możesz zmienić znaku spacji.

Przypadki testowe

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

7
   #   
 # # # 
#######

32
                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################

Kilka większych przypadków testowych można znaleźć tutaj .

Punktacja

To jest , więc wygrywa najkrótszy kod w bajtach w każdym języku.

ETHprodukcje
źródło
2
Związane .
ETHproductions
Teraz mogę zmierzyć odległość w trybie binarnym! Och czekaj ...
Okx,
2
1. Czy linijka musi być pozioma? 2. Czy oznaczenia muszą być #?
Jonathan Allan,
1
@JathanathanAllan 1. Tak i 2. Nie, mogą być dowolnymi pojedynczymi znakami spacji. Dodałem to do zasad.
ETHproductions
Sekwencja w OEIS: A001511
To nie drzewo,

Odpowiedzi:

11

Python 2 , 54 bajty

i=n=input()
while i:i-=1;print((' '*~-2**i+'#')*n)[:n]

Wypróbuj online!

Drukuje z dużą ilością wiodących białych znaków. Każdy wiersz iodliczający od npowtarza wzór 2**i-1spacji, po których następuje #. Ten wzór powtarza się do szerokości linijki, która jest wejściem n. Odbywa się to przez pomnożenie ciągu wzorca ni pobranie pierwszych nznaków [:n].

Wzorzec można wykonać przez formatowanie łańcucha dla alternatywy o równej długości.

i=n=input()
while i:i-=1;print('%%%ds'%2**i%'#'*n)[:n]

Słodka metoda krojenia jest dłuższa.

n=input();s=~-2**n*' '+'#'
exec"s=s[1::2]*2;print s[:n];"*n
xnor
źródło
Czy ~ wynosi -1 czy +1?
Stan Strum,
Nieważne, to (-x) - 1
Stan Strum
10

Python 3 , 74 bajty

n=int(input())
a=1
while a<n:a*=2
while a:print(("%%%dd"%a%4*n)[:n]);a//=2

Wypróbuj online!

Leaky Nun
źródło
Wow, zajęło mi trochę czasu, aby dowiedzieć się, jak generowane są wiersze. Dobra robota.
ETHproductions
2
a=2**len(bin(n))dla 72 bajtów
ovs
2
Szybko trafi w błąd pamięci i wydrukuje kilka dodatkowych białych znaków (dozwolone) - ale możesz zrobić 54 używając Python 2 .
Jonathan Allan
9

V , 17 , 16 bajtów

é#Àñä}Är {ñÎÀlD

Wypróbuj online!

Hexdump:

00000000: e923 c0f1 e416 7dc4 7220 7bf1 cec0 6c44  .#....}.r {...lD

Dzięki @KritixiLithos za oszczędność jednego bajtu!

Algorytm ten jest strasznie nieefektywny, ale powinien teoretycznie działać dla każdego rozmiaru wejściowego.

Działa, generując pierwsze n iteracje następującego wzorca:

#

 #
##

   #
 # #
####

       #
   #   #
 # # # #
########

               #
       #       #
   #   #   #   #
 # # # # # # # #
################

                               #
               #               #
       #       #       #       #
   #   #   #   #   #   #   #   #
 # # # # # # # # # # # # # # # #
################################

A następnie odciąć wszystkie oprócz pierwszych n kolumn. W związku z tym powstanie mnóstwo wiodących białych znaków, ale OP powiedział:

Dane wyjściowe mogą zawierać dowolną ilość białych znaków, o ile wzór jest nienaruszony

Wyjaśnienie:

é#                      " Insert an '#'
  Àñ           ñ        " 'N' times:
    ä<C-v>}             "   Duplicate every line blockwise (duplicating horizontally instead of vertically)
           Ä            "   Duplicate the top line. This conveniently puts us on the first non-whitespace character (that is, '#')
            r           "   Replace this character with a space
              {         "   Move to the beginning of the buffer
                Î       " On every line:
                 Àl     "   Move 'N' characters to the right ('l' for right, makes sense, right?)
                   D    "   And delete everything after the cursor
DJMcMayhem
źródło
Nie jestem do końca pewien, ale myślę, że możesz to usunąć |.
Kritixi Lithos
@KritixiLithos Aha! Z perspektywy czasu to takie oczywiste! Dzięki za wskazówkę. :)
DJMcMayhem
5

JavaScript (ES6), 61 58 bajtów

f=(n,c=n,s='')=>c?f(n,c>>1,s+s+' ')+`
`+(s+1).repeat(c):''

Zaoszczędzono 1 bajt dzięki @ETHProductions, a następnie 2 kolejne bajty, gdy zobaczyłem, że można użyć dowolnego znaku.

Rozwiązanie rekurencyjne.

Przypadki testowe:

Animacja:

Rick Hitchcock
źródło
1
Dobra robota. Możesz zmienić c/2|0na, c>>1aby zapisać bajt.
ETHproductions
Fajnie, muszę odświeżyć moich bitowych operatorów.
Rick Hitchcock,
4

APL (Dyalog) , 21 bajtów

'# '[1+⊖0⍪∨⍀⊖2⊥⍣¯1⍳⎕]

Wypróbuj online!

'# '[… `] Indeksuje ciąg za pomocą

 uzyskać dane wejściowe

 że wielu í ntegers

2⊥⍣¯1 konwertuj na binarny, używając tyle cyfr, ile potrzeba (jedna liczba w każdej kolumnie )

 odwróć do góry nogami

∨⍀ skumulowana redukcja OR w pionie

0⍪ konkatenuj zera na górze

 odwróć do góry nogami (tj. ponownie do góry)

1+ dodaj jeden (dla indeksowania 1)

Adám
źródło
3

Galaretka , 11 10 bajtów

Rọ2‘4ẋz⁶ṚY

Wypróbuj online!

1 bajt zapisany po tym, jak OP dodał relaksację, że postać nie musi być #.

Leaky Nun
źródło
2

Oktawa, 45 bajtów

@(n)[[sort(cummin(de2bi(g=0:n)'));g|1]+32 '']

Wypróbuj w Octave Online!

Zamiast '#'wydruków '!'.

rahnema1
źródło
2

PHP , 139 bajtów

for($f=array_fill(0,$l=1+log($a=$argn,2)," ");$n++<$a;)for($h=1+strspn(strrev(decbin($n)),$i=0);$i<$h;)$f[$l-++$i][$n]=3;echo join("
",$f);

Wypróbuj online!

Jörg Hülsermann
źródło
2

Japt , 20 17 bajtów

Zaoszczędź 3 bajty dzięki produktom @Shaggy i @ETH

õ_¤q1 o Ä ço÷z w

Wypróbuj online!

Wyjaśnienie:

Wejście: 5

õ_¤q1 o Ä ço÷z w
õ           Ã       // Create a range [1...Input] [1,2,3,4,5]
 _                  // Map; At each item:
  ¤                 //   Convert to binary        ["1","10","11","100","101"]
   q1               //   Split on "1"             [["",""],["","0"],["","",""],["","00"],["","0",""]]
      o             //   Get the last item        ["","0","","00",""]
        Ä           //   Add 1                    [["1","01","1","001","1"]]
          ço        //   Fill with "o"            ["o","oo","o","ooo","o"]
             ·      // Join with new-lines        ["o\noo\no\nooo\no"]
              z     // Rotate 90 degrees          ["ooooo\n o o \n o   "]
                w   // Reverse                    ["   o \n o o \nooooo"]
Oliver
źródło
20 bajtów
Shaggy
@Shaggy Właściwie nawet nie potrzebujeszl
ETHproductions
@ETHproductions: tak, właśnie to rozgryzłem. 18 bajtów
Shaggy
17 bajtów
Shaggy
Fajna sztuczka z operatorami bitowe to zrobić n&-n, aby uchwycić tylko końcowy 1i wszystko spływu 0sw n. Nie jestem pewien, czy to pomoże, ale warto
spróbować
2

C, 84 74 bajty

f(i,l,m){putchar(32+3*!(i&m));i<l?f(i+1,l,m):m?putchar(10),f(1,l,m>>1):1;}

Nie golfowany:

void f(int counter, int length, int mask) {
    putchar((counter&mask) ? ' ' : '#');
    if(counter<length) {
        f(counter+1, length, mask);
    } else if(mask) {
        putchar('\n');
        f(1, length, mask>>1);
    }
}

Testuj z:

int main() {
    f(1, 32, 1023);
    putchar('\n');
    f(1, 1, 1023);
    putchar('\n');
    f(1, 999, 1023);
    putchar('\n');
}

Wyjaśnienie

Ponownie, rekurencja wymaga mniej znaków w C niż iteracja, więc dwie pętle są wyrażone jako dwie rekurencyjne wywołania.

Ponadto C jest doskonałym językiem do gry w sztuczki z wyrażeniami boolowskimi, pozwalając na decyzję, czy wyrazić puste miejsce czy #wyrazić 32+3*!(i&m). Spacja ma wartość ASCII wynoszącą 32, #jest to ASCII 35, więc otrzymujemy puste miejsce, jeśli którykolwiek z bitów w masce jest ustawiony i.

cmaster - przywróć monikę
źródło
Czy ty w ogóle potrzebujesz int i,l,m?
Zacharý
@ZacharyT Nie, okazuje się, że nie. Dzięki za zapisanie 10 bajtów :-)
cmaster - przywróć monikę
2

Pyth , 15 bajtów

j_.tm*Nhx_.Bd1S

Spróbuj!

wyjaśnienie

j_.tm*Nhx_.Bd1S
    m         SQ   # map over the numbers from 0 to the implicit input (lambda variable: d)
          .Bd      # Convert d to a binary string: (12 -> 1100)
         _         # reverse: (1100 -> 0011)
        x    1     # get the location of the first 1 ( 2 )
     *Nh           # make one more than that " quotation marks (""")
 _.t               # transpose the list of quotation mark strings and reverse it
j                  # join on newline
KarlKastor
źródło
@JasonS To język golfa oparty na Pythonie! Teraz połączyłem github Pytha . Myślałem, że spróbuj! wystarczy link do Egzekutora online.
KarlKastor
1

JavaScript (ES8), 71 bajtów

Funkcja padStart () została wprowadzona w ECMAScript 2017!

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+'#'.padStart(n).repeat(N/n)+s`)


JavaScript (ES6), 77 bajtów

N=>eval(`for(s='',n=1;n<=N;n*=2)s='\\n'+(' '.repeat(n-1)+'#').repeat(N/n)+s`)

darrylyeo
źródło
1
@ RickHitchcock Naprawiono.
darrylyeo
1

Mathematica, 69 bajtów

Rotate[Grid["#"~Table~#&/@(IntegerExponent[2*#,2]&/@Range[#])],Pi/2]&
J42161217
źródło
1

( WESRRMICGSE ): 237 bajtów

IF(ROW()<=FLOOR(LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2),1)+2,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG(COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1,2)-ROW()+2),1)-1) &"#",COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1),"")

W porządku. „splaining time.

Po pierwsze, zamień każdy COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1po prostu [i]na dane wejściowe. token zlicza liczbę komórek, nie licząc siebie, zawierających formułę, a następnie dodaje jedną, aby uwzględnić siebie. Ponieważ WESRRMICGSE przeciąga formułę zgodnie z podanymi danymi wejściowymi, ten token zawsze daje dane wejściowe.

mamy:

IF(ROW()<=FLOOR(LOG([i],2),1)+3,LEFT(REPT(REPT(" ",FLOOR(POWER(2,LOG([i],2)-ROW()+2),1)-1) &"#",[i]),[i]),"")

Jest to o wiele bardziej czytelne. Często zobaczysz FLOOR(LOG([i],2),1)token, co oznacza po prostu pobranie najbliższej potęgi 2, która jest mniejsza niż liczba input ( [i]). np 4->4, 5->4, 6->4, 7->4, 8->8 ...etc. : Zastąpię toGS[[i]]

IF(ROW()<=GS[[i]]+3,LEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i]),"")

lepszy. rozkładając klauzulę if, testujemy, czy rząd jest mniejszy lub równy GS[[i]]+3, ponieważ wysokość wszystkich linijek jest równa GS [[i]] + 1, to wybiera wiersze, które są równe wysokości linijka. +1dla 1-indeksujących wierszy i +1ponownie dla przesunięcia WESRRMICGSE.

FALSEWynik uzyskuje pustej komórki ( „”) oraz rzeczywiste wydajności wynikówLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

obecnie wciąż edytuję, bądźcie czujni

tuskiomi
źródło
1

Haskell , 64 62 bajtów

l m=([2..2^m]>>" ")++'#':l m
f n=unlines$take n.l<$>[n,n-1..0]

Wypróbuj online! Przykładowe zastosowania: f 10.

Laikoni
źródło
1

k, 33 bajtów

`0:|" #"{(1+!x){~y!x}/:(x>)(2*)\1}

Wydaje się, że działa to tylko w tłumaczu AW .

Przykład jego pracy w tłumaczu AW.

Wersja OK (którą możesz wypróbować online) wydaje się zawierać błąd, który wymaga niewielkiej zmiany, aby działała:

`0:|" #"{(1+!x){~y!x}/:{x>y}[x](2*)\1}
zgrep
źródło
1

C #, 174 bajtów

Ta metoda ma dwa parametry, dane wejściowe dla długości linijki i dane wyjściowe, które są linijką jako ciągiem znaków.

Gra w golfa:

void R(int n,out string s){var l=new int[++n];int i,x=n,y=0;for(s="";x-->1;)for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y);for(y++;y-->0;s+='\n')for(x=0;++x<n;s+=y<l[x]?'#':' ');}

Zębaty:

void R(int n,out string s){                       // Return the result in an out parameter.
    var l=new int[++n];                           // Use a 1-based array.
    int i,x=n,y=0;                                //
    for(s="";x-->1;)                              // For each number x on the ruler
        for(i=0;0==(l[x]=(x>>i++&1)*i);y=y<i?i:y) // ... find lowest set bit of x, counting the maximum value.
            ;                                     //
    for(y++;y-->0;s+='\n')                        // Count down each line.
        for(x=0;++x<n;s+=y<l[x]?'#':' ')          // Output # for numbers that are tall enough.
            ;                                     //
}

Wypróbuj online!

Hand-E-Food
źródło
Czy konwersja Func<int, string>pozwoliłaby Ci zaoszczędzić trochę bajtów?
TheLethalCoder
1

Węgiel drzewny , 27 23 bajtów

↶F…·¹N«Jι⁰#W¬﹪鲫A÷ι²ι#

Wypróbuj online! Link jest do pełnej wersji kodu. Edycja: Zapisano 4 bajty, przełączając na JumpTo.

Neil
źródło
Nadal jest absolutny, teraz nazywa się JumpTo(przepraszam)
tylko ASCII,
@ Ah, tylko ASCII Ah, wiki może zrobić z aktualizacją. (Lub zakładam, że mógłbym to zrobić, gdybyś chciał dać mi pozwolenie na edycję ...)
Neil,
@ Huh, tylko ASCII, powinienem pamiętać o tym z codegolf.stackexchange.com/a/119904 ...
Neil
Czy masz konto GitHub?
Tylko ASCII,
@ Tylko ASCII Mam dwa ... Nie mogę zdecydować, który z nich jest bardziej odpowiedni ...
Neil
1

J, 38 bajtów

3 :'|.|:''#''#~,.(1+|.i.1:)@#:"0>:i.y'

Nie najlepiej. Lmk, jeśli liczba bajtów jest wyłączona - rozmawiam przez telefon.

kapusta
źródło
Dla mnie wygląda na 38, chyba że 3na początku jest wejście ...
ETHproductions
@ETHproductions dzięki, przełączanie wstydu z milczącej definicji nie zapisało żadnych bajtów ...
cole
1
28 bajtów z0|.@|:'#'#"0~1#.2~:/\i.#:@,]
milami
0

Java (OpenJDK 8) , 91 bajtów

n->{int i=10,j;String s="";for(;i-->0;s+="\n")for(j=0;j++<n;)s+=j>>i<<i<j?' ':35;return s;}

Wypróbuj online!

Nie golfowany:

n->{
    int i=10,j; // Since we are allowed extra whitespace, set columns always to 10
    String s = "";
    for(;i-->0;s+="\n")      // Every iteration add a newline, i=9..0
        for(j=0;j++<n;)      // j=1..n+1
            s+= j>>i<<i<j    // if j has less than i trailing 0s in binary form
                ?' '         // add a space else
                :35          // # (java handles ternary return types weirdly)
}
PunPun1000
źródło
0

CJam, 34 bajty

ri{2bW%0+0#)}%_'#f*\:e>f{Se]}zW%N*

Meh

Esolanging Fruit
źródło
0

C (gcc) , 70 bajtów

f(x,l,n){for(l=512;l/=2;)for(n=0;n++<=x;)putchar(n^x+1?n%l?32:35:10);}

Wypróbuj online!

Giacomo Garabello
źródło
Zaproponuj n+~xzamiastn^x+1
ceilingcat