Étant donné un nombre n , générez les n premières colonnes de ce modèle:

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

La hauteur de la colonne à (indexé 1) n est le nombre de 0bits de fin dans n la représentation binaire de , plus un. Par conséquent, la couche inférieure contient toutes les colonnes, la deuxième couche toutes les deux colonnes, la troisième couche toutes les quatre colonnes, etc.

Règles

• Vous pouvez entrer et sortir par n'importe quelle méthode standard.
• Vous pouvez supposer que l'entrée est un entier compris entre 1 et 999 inclus.
• La sortie peut contenir n'importe quelle quantité d'espace, tant que le motif est intact.
• Le modèle doit être indexé 1 et dans le même format que celui illustré ici.
• Vous pouvez utiliser n'importe quel caractère non blanc à la place de #, mais vous ne pouvez pas changer le caractère espace.

Cas de test

1
#

2
 #
##

3
 # 
###

4
   #
 # #
####

5
   # 
 # # 
#####

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

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

Quelques cas de test plus importants peuvent être trouvés ici .

Notation

Ceci est un code-golf , de sorte que le code le plus court en octets dans chaque langue gagne.

Python 2 , 54 octets

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

Essayez-le en ligne!

Imprime avec beaucoup d'espaces blancs de premier plan. Chaque ligne idécomptant à partir de nrépète un motif d' 2**i-1espaces suivi d'un #. Ce motif est répété jusqu'à la largeur de la règle, qui est l'entrée n. Cela se fait en multipliant la chaîne de motif par net en prenant les premiers ncaractères avec[:n] .

Le modèle peut être créé par formatage de chaîne pour une alternative de longueur égale.

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

Une méthode de découpage mignonne est plus longue.

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

Python 3 , 74 octets

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

Essayez-le en ligne!

V , 17 , 16 octets

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

Essayez-le en ligne!

Hexdump:

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

Merci à @KritixiLithos d'avoir enregistré un octet!

Cet algorithme est horriblement inefficace, mais il devrait fonctionner en théorie pour n'importe quelle entrée de taille.

Il fonctionne en générant les n premières itérations du modèle suivant:

#

 #
##

   #
 # #
####

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

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

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

Et puis couper toutes les colonnes sauf les n premières . En tant que tel, cela produira une tonne d'espaces blancs de premier plan, mais le PO a déclaré:

La sortie peut contenir n'importe quelle quantité d'espace, tant que le motif est intact

Explication:

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

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

Sauvegardé 1 octet grâce à @ETHProductions, puis 2 octets supplémentaires quand j'ai vu que n'importe quel caractère pouvait être utilisé.

Une solution récursive.

Cas de test:

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 octets

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

Essayez-le en ligne!

'# '[… `] Indexez la chaîne avec

 ⎕ obtenir une entrée

 ⍳ que beaucoup i ntegers

 2⊥⍣¯1 convertir en binaire, en utilisant autant de chiffres que nécessaire (un nombre dans chaque colonne )

 ⊖ retourner la tête en bas

 ∨⍀ réduction OR cumulative verticale

 0⍪ concaténer des zéros sur le dessus

 ⊖ retourner à l'envers (c'est-à-dire reculer)

 1+ ajouter un (pour l'indexation basée sur 1)

Gelée , 11 10 octets

Rọ2‘4ẋz⁶ṚY

Essayez-le en ligne!

1 octet enregistré après l'OP a ajouté une relaxation que le caractère n'a pas à être #.

Octave, 45 octets

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

Essayez-le sur Octave Online!

Au lieu d' '#'impressions '!'.

PHP , 139 octets

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

Essayez-le en ligne!

Japt , 20 17 octets

3 octets enregistrés grâce à @Shaggy et @ETHproductions

õ_¤q1 o Ä ço÷z w

Essayez-le en ligne!

Explication:

Entrée: 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 octets

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

Non golfé:

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

Testez avec:

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

Explication

Encore une fois, la récursivité prend moins de caractères en C que l'itération, donc les deux boucles sont exprimées comme les deux invocations récursives.

De plus, C est un excellent langage pour jouer des tours avec des expressions booléennes, permettant de décider de mettre un blanc ou un #à exprimer par l'expression 32+3*!(i&m). Un espace a la valeur ASCII de 32, #c'est ASCII 35, donc nous obtenons un blanc si l'un des bits du masque est défini i.

Pyth , 15 octets

j_.tm*Nhx_.Bd1S

Essayez!

explication

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 octets

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

Essayez-le en ligne!

JavaScript (ES8), 71 octets

La fonction padStart () a été introduite dans ECMAScript 2017!

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 octets

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 octets

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

( WESRRMICGSE ): 237 octets

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

Bien. 'temps de splaining.

Tout d'abord, remplacez tout COUNTA(R1C:R[-1]C,R[1]C:R[1024]C)+1par simplement [i], pour entrée. le jeton compte le nombre de cellules, sans compter lui-même, qui contiennent une formule, puis en ajoute une, pour s’inclure. Étant donné que WESRRMICGSE fait glisser une formule en fonction de l'entrée que vous lui donnez, ce jeton entraîne toujours l'entrée.

on a:

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

C'est beaucoup plus lisible. Vous allez voir FLOOR(LOG([i],2),1)beaucoup le jeton, ce qui signifie simplement prendre la puissance la plus proche de 2, ce qui est inférieur au nombre input ( [i]). par exemple: 4->4, 5->4, 6->4, 7->4, 8->8 ...etc. Je vais le remplacer parGS[[i]]

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

mieux. en décomposant la clause if, nous testons si la ligne est inférieure ou égale à GS[[i]]+3, car la hauteur de toutes les règles est égale à GS [[i]] + 1, cela sélectionne les lignes qui sont égales à la hauteur de la règle. +1pour les lignes d'indexation 1, et +1encore pour le décalage WESRRMICGSE.

Le FALSErésultat donne une cellule vide (""), et un vrai résultat donneLEFT(REPT(REPT(" ",,FLOOR(POWER(2,LOG([i],2)-ROW()+2),1),1)-1) &"#",[i]),[i])

actuellement en cours d'édition, restez à l'écoute

Haskell , 64 62 octets

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

Essayez-le en ligne! Exemple d' utilisation: f 10.

k, 33 octets

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

Cela ne semble fonctionner que dans l'interprète d'AW .

La version oK (que vous pouvez essayer en ligne) semble avoir un bug, nécessitant un léger changement pour le faire fonctionner:

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

C #, 174 octets

Cette méthode a deux paramètres, une entrée pour la longueur de la règle et une sortie qui est la règle sous forme de chaîne.

Golfé:

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

Dentelé:

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

Essayez-le en ligne!

Fusain , 27 23 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Modifier: enregistré 4 octets en basculant sur JumpTo.

J, 38 octets

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

Pas génial. Lmk si le nombre d'octets est désactivé - je suis sur mon téléphone.

Java (OpenJDK 8) , 91 octets

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

Essayez-le en ligne!

Non golfé:

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 octets

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

Meh.

C (gcc) , 70 octets

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!