Dato un numero n , genera le prime n colonne di questo modello:

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

L'altezza della colonna in (1-indicizzato) n è il numero di 0bit finali nella rappresentazione binaria di n , più uno. Di conseguenza, il livello inferiore ha riempito ogni colonna, il secondo strato ogni seconda colonna, il terzo livello ogni quarta colonna, ecc.

Regole

È possibile immettere e produrre qualsiasi metodo standard.
Si può presumere che l'input sia un numero intero compreso tra 1 e 999, inclusi.
L'output può contenere qualsiasi quantità di spazio bianco, purché il modello sia intatto.
Il modello deve essere 1 indicizzato e nello stesso formato mostrato qui.
Puoi usare qualsiasi singolo carattere non bianco al posto di #, ma non puoi cambiare il carattere spazio.

Casi test

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

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

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

Alcuni casi di test più grandi possono essere trovati qui .

punteggio

Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua.

code-golf ascii-art

— ETHproductions
fonte

2

Correlato .

— ETHproductions,

Ora posso misurare la distanza in binario! Oh aspetta ...

— Okx,

2

1. Il righello deve essere orizzontale? 2. I segni devono essere #?

— Jonathan Allan,

1

@JonathanAllan 1. Sì e 2. No, possono essere un singolo carattere non spaziale. Ho aggiunto questo alle regole.

— ETHproductions

La sequenza di OEIS: A001511

— Non un albero,

11

Python 2 , 54 byte

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

Provalo online!

Stampa con molti spazi bianchi di punta. Ogni riga alla irovescia da nripete un modello di 2**i-1spazi seguito da a #. Questo modello viene ripetuto fino alla larghezza del righello, che è l'input n. Questo viene fatto moltiplicando la stringa del motivo per ne prendendo i primi ncaratteri con [:n].

Il modello può essere realizzato mediante la formattazione di stringa per un'alternativa di uguale lunghezza.

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

Un metodo di affettatura carino è più lungo.

n=input();s=~-2**n*' '+'#'
exec"s=s[1::2]*2;print s[:n];"*n

— XNOR
fonte

~ È -1 o +1?

— Stan Strum,

Non importa, è (-x) - 1

— Stan Strum

10

Python 3 , 74 byte

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

Provalo online!

— Perdente Suora
fonte

Caspita, mi ci è voluto un po 'per capire come vengono generate le righe. Molto bene.

— ETHproductions

2

a=2**len(bin(n))per 72 byte

— ovs

2

Colpirà rapidamente gli errori di memoria e stamperà un sacco di spazio bianco extra (consentito), ma puoi fare 54 usando Python 2 .

— Jonathan Allan,

9

V , 17 , 16 byte

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

Provalo online!

hexdump:

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

Grazie a @KritixiLithos per aver salvato un byte!

Questo algoritmo è orribilmente inefficiente, ma dovrebbe funzionare in teoria per input di qualsiasi dimensione.

Funziona generando le prime n iterazioni del seguente modello:

#

 #
##

   #
 # #
####

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

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

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

E poi tagliare tutto tranne le prime n colonne. Come tale, questo produrrà una tonnellata di spazi bianchi principali, ma l'OP ha detto:

L'output può contenere qualsiasi quantità di spazio bianco, purché il modello sia intatto

Spiegazione:

é#                      " 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
fonte

Non ne sono del tutto sicuro, ma penso che tu possa rimuovere il file |.

— Kritixi Lithos,

@KritixiLithos Aha! Col senno di poi, è così ovvio! Grazie per il consiglio. :)

— DJMcMayhem

5

JavaScript (ES6), 61 58 byte

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

Salvato 1 byte grazie a @ETHProductions, quindi altri 2 byte quando ho visto che qualsiasi personaggio poteva essere usato.

Una soluzione ricorsiva.

Casi test:

Mostra snippet di codice

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

console.log(f(32));
console.log(f(1));  
console.log(f(5));  
console.log(f(7));

Espandi frammento

Animazione:

Mostra snippet di codice

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

for(let i = 1 ; i < 64 ; i++) {
  setTimeout(_=>document.querySelector('pre').textContent=f(i), i*40);
}

<pre>

Espandi frammento

— Rick Hitchcock
fonte

1

Molto bene. È possibile modificare c/2|0in c>>1per salvare un byte.

— ETHproductions,

Bene, devo rispolverare i miei operatori bit a bit.

— Rick Hitchcock,

4

APL (Dyalog) , 21 byte

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

Provalo online!

'# '[... `] indicizza la stringa con

⎕ ottenere input

⍳ che molti i ntegers

2⊥⍣¯1 converti in binario, usando tutte le cifre necessarie (un numero in ogni colonna )

⊖ capovolgere

∨⍀ riduzione OR cumulativa verticale

0⍪ concatena gli zeri in cima

⊖ capovolgere (ovvero tornare indietro)

1+ aggiungi uno (per l'indicizzazione basata su 1)

— Adamo
fonte

3

Gelatina , 11 10 byte

Rọ2‘4ẋz⁶ṚY

Provalo online!

1 byte salvato dopo l'OP ha aggiunto un rilassamento che il personaggio non deve essere #.

— Perdente Suora
fonte

2

Ottava, 45 byte

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

Provalo su Octave Online!

Invece di '#'stampe '!'.

— rahnema1
fonte

2

PHP , 139 byte

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);

Provalo online!

— Jörg Hülsermann
fonte

2

Japt , 20 17 byte

Salvato 3 byte grazie a @Shaggy e @ETHproductions

õ_¤q1 o Ä çoÃ·z w

Provalo online!

Spiegazione:

Ingresso: 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
fonte

20 byte

— Shaggy,

@Shaggy In realtà, non hai nemmeno bisogno dil

— ETHproductions

@ETHproductions: sì, l'ho appena capito. 18 byte

— Shaggy,

17 byte

— Shaggy,

Un trucco fresco con operatori bit per bit è quello di fare n&-nper catturare solo la finale 1e tutti i trailing 0s in n. Non sono sicuro se questo aiuterà, ma vale la pena

— provare

2

C, 84 74 byte

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;}

Ungolfed:

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);
    }
}

Prova con:

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

Spiegazione

Ancora una volta, la ricorsione prende meno caratteri in C rispetto all'iterazione, quindi i due loop sono espressi come le due invocazioni ricorsive.

Inoltre, C è un ottimo linguaggio per giocare brutti scherzi con espressioni booleane, consentendo di decidere se mettere un vuoto o #a essere espresso dall'espressione 32+3*!(i&m). Uno spazio ha il valore ASCII di 32, #è ASCII 35, quindi otteniamo uno spazio se è impostato uno qualsiasi dei bit nella maschera i.

— cmaster - ripristina monica
fonte

Ne hai bisogno int i,l,m?

— Zacharý,

@ZacharyT No, risulta che non l'ho fatto. Grazie per aver salvato quei 10 byte :-)

— cmaster - ripristina monica il

2

Pyth , 15 byte

j_.tm*Nhx_.Bd1S

Provalo!

spiegazione

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
fonte

@JasonS È un linguaggio da golf basato su Python! Ora ho collegato Github di Pyth . Ho pensato di provarlo! il collegamento all'esecutore online sarebbe sufficiente.

— KarlKastor,

2

Python 2 , 47 byte

f=lambda n:n and' '.join(f(n/2))+'\n'+n*'#'or''

Provalo online!

— Anders Kaseorg
fonte

1

JavaScript (ES8), 71 byte

La funzione padStart () è stata introdotta in ECMAScript 2017!

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

Mostra snippet di codice

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

console.log(f(+prompt()))

Espandi frammento

JavaScript (ES6), 77 byte

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

Mostra snippet di codice

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

console.log(f(+prompt()))

Espandi frammento

— darrylyeo
fonte

1

@RickHitchcock Risolto.

— darrylyeo,

1

Mathematica, 69 byte

Rotate[Grid["#"~Table~#&/@(IntegerExponent[2*#,2]&/@Range[#])],Pi/2]&

— J42161217
fonte

1

( WESRRMICGSE ): 237 byte

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),"")

Tutto apposto. 'tempo di splaining.

Prima di tutto, sostituisci COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1semplicemente tutto con [i], per input. il token conta il numero di celle, escluso se stesso, che contengono una formula, quindi ne aggiunge una per includersi. Poiché WESRRMICGSE trascina una formula in base all'input fornito, questo token genera sempre l'input.

noi abbiamo:

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

Questo è molto più leggibile. Vedrai molto il FLOOR(LOG([i],2),1)token, il che significa semplicemente prendere la potenza più vicina di 2 che è inferiore al [i]numero input ( ). ad es 4->4, 5->4, 6->4, 7->4, 8->8 ...etc. : . Lo sostituirò conGS[[i]]

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

meglio. abbattendo la clausola if, stiamo testando se la riga è inferiore o uguale a GS[[i]]+3, poiché l'altezza di tutti i righelli è uguale a GS [[i]] + 1, questo seleziona le righe uguali all'altezza del righello. +1per le righe a 1 indicizzazione e di +1nuovo per l'offset di WESRRMICGSE.

Il FALSErisultato produce una cella vuota ("") e un risultato vero produceLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

attualmente ancora in modifica, rimanete sintonizzati

— tuskiomi
fonte

1

Haskell , 64 62 byte

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

Provalo online! Esempio di utilizzo: f 10.

— Laikoni
fonte

1

k, 33 byte

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

Questo sembra funzionare solo nell'interprete di AW .

La versione oK (che puoi provare online) sembra avere un bug, che richiede una leggera modifica per farlo funzionare:

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

— zgrep
fonte

1

C #, 174 byte

Questo metodo ha due parametri, un input per la lunghezza del righello e un output che è il righello come stringa.

golfed:

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]?'#':' ');}

rientrato:

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.
            ;                                     //
}

Provalo online!

— Hand-e-alimentari
fonte

La conversione in un Func<int, string>salvataggi di alcuni byte?

— TheLethalCoder

1

Carbone , 27 23 byte

↶Ｆ…·¹Ｎ«Ｊι⁰#Ｗ¬﹪ι²«Ａ÷ι²ι#

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: salvato 4 byte passando a JumpTo.

— Neil
fonte

È ancora assoluto, proprio ora si chiama JumpTo(scusa)

— ASCII-solo il

@ Solo ASCII Ah, il wiki potrebbe fare con un aggiornamento. (O suppongo di poterlo fare se mi vuoi dare il permesso di modifica ...)

— Neil,

@ Solo ASCII Eh, avrei dovuto ricordare che da codegolf.stackexchange.com/a/119904 ...

— Neil,

Hai un account GitHub?

— ASCII il

@ Solo ASCII ne ho due ... Non riesco a decidere quale sia più appropriato ...

— Neil,

1

J, 38 byte

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

Non buono. Se il conteggio dei byte è disattivato, sono sul mio telefono.

— ravizzone
fonte

A me sembrano 38, a meno che 3all'inizio non sia inserito ...

— ETHproductions

@ETHproductions grazie, la vergogna che passa da una definizione tacita non ha salvato alcun byte ...

— cole

1

28 byte con0|.@|:'#'#"0~1#.2~:/\i.#:@,]

— miglia

0

Java (OpenJDK 8) , 91 byte

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;}

Provalo online!

Ungolfed:

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
fonte

0

CJam, 34 byte

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

Meh.

— Esolanging Fruit
fonte

0

C (gcc) , 70 byte

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

Provalo online!

— Giacomo Garabello
fonte

Suggerisci n+~xinvece din^x+1

— ceilingcat

0

Perl 5 , 60 + 1 (-n) = 61 byte

$n=0|1+(log)/log 2;say(($"x(2**$n-1),X)x($_/2**$n))while$n--

Provalo online!

— Xcali
fonte

Crea un righello binario

Regole

Casi test

punteggio

Python 2 , 54 byte

Python 3 , 74 byte

V , 17 , 16 byte

JavaScript (ES6), 61 58 byte

APL (Dyalog) , 21 byte

Gelatina , 11 10 byte

Ottava, 45 byte

PHP , 139 byte

Japt , 20 17 byte

Spiegazione:

C, 84 74 byte

Ungolfed:

Prova con:

Spiegazione

Pyth , 15 byte

spiegazione

Python 2 , 47 byte

JavaScript (ES8), 71 byte

JavaScript (ES6), 77 byte

Mathematica, 69 byte

( WESRRMICGSE ): 237 byte

Haskell , 64 62 byte

k, 33 byte

C #, 174 byte

Provalo online!

Carbone , 27 23 byte

J, 38 byte

Java (OpenJDK 8) , 91 byte

CJam, 34 byte

C (gcc) , 70 byte

Perl 5 , 60 + 1 (-n) = 61 byte