Generieren Sie die ersten n Spalten dieses Musters, wenn Sie eine Zahl n haben :

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

Die Höhe der Spalte bei (1-indiziert) n ist die Anzahl der nachfolgenden 0Bits in der Binärdarstellung von n plus eins. Infolgedessen ist in der untersten Schicht jede Spalte ausgefüllt, in der zweiten Schicht jede zweite Spalte, in der dritten Schicht jede vierte Spalte usw.

Regeln

• Sie können mit jeder Standardmethode eingeben und ausgeben.
• Sie können davon ausgehen, dass die Eingabe eine ganze Zahl zwischen 1 und 999 einschließlich ist.
• Die Ausgabe kann beliebig viele Leerzeichen enthalten, solange das Muster intakt ist.
• Das Muster muss 1-indiziert sein und dasselbe Format haben wie hier gezeigt.
• Sie können anstelle von ein einzelnes Nicht-Leerzeichen verwenden, das Leerzeichen #jedoch nicht ändern.

Testfälle

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

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

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

Einige größere Testfälle finden Sie hier .

Wertung

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache.

Python 2 , 54 Bytes

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

Probieren Sie es online!

Druckt mit vielen führenden Leerzeichen. Jede Zeile, idie abwärts zählt, nwiederholt ein Muster von 2**i-1Leerzeichen, gefolgt von einem #. Dieses Muster wird bis zur Breite des Lineals wiederholt, das die Eingabe ist n. Dazu multiplizieren Sie die Musterzeichenfolge mit nund nehmen die ersten nZeichen mit[:n] .

Das Muster kann durch Formatieren von Zeichenfolgen für eine Alternative gleicher Länge erstellt werden.

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

Eine süße Aufschnittmethode ist länger.

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

Python 3 , 74 Bytes

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

Probieren Sie es online!

V , 17 , 16 Bytes

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

Probieren Sie es online!

Hexdump:

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

Vielen Dank an @KritixiLithos für das Speichern eines Bytes!

Dieser Algorithmus ist schrecklich ineffizient, sollte aber theoretisch für jede Größeneingabe funktionieren.

Es funktioniert, indem die ersten n Iterationen des folgenden Musters generiert werden :

#

 #
##

   #
 # #
####

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

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

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

Und dann alle bis auf die ersten n Spalten abhacken . Als solches wird dies eine Tonne führenden Leerraums erzeugen, aber das OP sagte:

Die Ausgabe kann beliebig viele Leerzeichen enthalten, solange das Muster intakt ist

Erläuterung:

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

JavaScript (ES6), 61-58 Byte

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

1 Byte dank @ETHProductions gespeichert, dann 2 weitere Bytes, als ich sah, dass ein beliebiges Zeichen verwendet werden könnte.

Eine rekursive Lösung.

Testfälle:

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

Animation:

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>

APL (Dyalog) , 21 Bytes

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

Probieren Sie es online!

'# '[… `] Indexiere den String mit

 ⎕ Eingabe abrufen

 ⍳ dass viele i ntegers

 2⊥⍣¯1 konvertiere nach binär, benutze so viele Ziffern wie nötig (eine Zahl in jeder Spalte )

 ⊖ umdrehen

 ∨⍀ vertikale kumulative oder Reduktion

 0⍪ verketten Nullen an der Spitze

 ⊖ auf den Kopf stellen (dh wieder auf den Kopf stellen)

 1+ add one (für 1-basierte Indizierung)

Jelly , 11 bis 10 Bytes

Rọ2‘4ẋz⁶ṚY

Probieren Sie es online!

1 Byte, das nach dem OP gespeichert wurde, fügte eine Entspannung hinzu, die der Charakter nicht sein muss #.

Oktave, 45 Bytes

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

Probieren Sie es auf Octave Online aus!

Anstelle von '#'Drucken '!'.

PHP , 139 Bytes

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

Probieren Sie es online!

Japt , 20 17 Bytes

3 Bytes gespart dank @Shaggy und @ETHproductions

õ_¤q1 o Ä ço÷z w

Probieren Sie es online!

Erläuterung:

Eingabe: 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"]

C 84 74 Bytes

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

Testen Sie mit:

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

Erläuterung

Erneut benötigt die Rekursion in C weniger Zeichen als die Iteration, sodass die beiden Schleifen als die beiden rekursiven Aufrufe ausgedrückt werden.

Außerdem ist C eine großartige Sprache zum Spielen von Stichen mit Booleschen Ausdrücken, mit denen entschieden werden kann, ob ein Leerzeichen oder ein #durch den Ausdruck ausgedrückt werden soll 32+3*!(i&m). Ein Leerzeichen hat den ASCII-Wert 32, das #ist ASCII 35, daher wird ein Leerzeichen angezeigt, wenn eines der Bits in der Maske gesetzt ist i.

Pyth , 15 Bytes

j_.tm*Nhx_.Bd1S

Versuch es!

Erläuterung

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

Python 2 , 47 Bytes

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

Probieren Sie es online!

JavaScript (ES8), 71 Byte

Die Funktion padStart () wurde in ECMAScript 2017 eingeführt!

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

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

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

JavaScript (ES6), 77 Byte

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

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

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

Mathematica, 69 Bytes

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

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

In Ordung. Zeit zu erklären.

Ersetzen Sie zunächst jedes COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1durch einfaches[i] für die Eingabe. Das Token zählt die Anzahl der Zellen, die eine Formel enthalten, ohne sich selbst einzuschließen, und fügt dann eine hinzu, um sich selbst einzuschließen. Da WESRRMICGSE eine Formel entsprechend der von Ihnen eingegebenen Eingabe zieht, führt dieses Token immer zur Eingabe.

wir haben:

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

Das ist viel besser lesbar. Sie werden das FLOOR(LOG([i],2),1)Token häufig sehen, was einfach bedeutet, dass Sie die nächste Potenz von 2 nehmen, die kleiner ist als die [i]Zahl von input ( ). zB: 4->4, 5->4, 6->4, 7->4, 8->8 ...etc. Ich werde das durch ersetzenGS[[i]]

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

besser. Wenn wir die if-Klausel auflösen, testen wir, ob die Zeile kleiner oder gleich ist GS[[i]]+3, da die Höhe aller Lineale der GS [[i]] + 1 entspricht. Dadurch werden die Zeilen ausgewählt, die der Höhe der entsprechen Herrscher. +1für Zeilen mit einer Indizierung und +1erneut für den WESRRMICGSE-Offset.

Das FALSEErgebnis ergibt eine leere Zelle ("") und ein echtes Ergebnis ergibtLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

derzeit noch in Bearbeitung, bleiben Sie dran

Haskell , 64 62 Bytes

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

Probieren Sie es online! Beispiel Nutzung: f 10.

k, 33 Bytes

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

Dies scheint nur in AWs Interpreter zu funktionieren .

Die oK-Version (die Sie online testen können) scheint einen Fehler zu haben, für den eine geringfügige Änderung erforderlich ist:

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

C #, 174 Bytes

Diese Methode hat zwei Parameter, eine Eingabe für die Länge des Lineals und eine Ausgabe, die das Lineal als Zeichenfolge darstellt.

Golf gespielt:

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

Eingerückt:

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

Probieren Sie es online!

Kohle , 27 23 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: 4 Bytes durch Umschalten auf gespeichert JumpTo.

J, 38 Bytes

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

Nicht gut. Lmk wenn die Byteanzahl aus ist - ich bin auf meinem Handy.

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

Probieren Sie es 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)
}

CJam, 34 Bytes

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

Meh.

C (gcc) , 70 Bytes

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

Probieren Sie es online!

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

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

Probieren Sie es online!