É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.

code-golf ascii-art

— ETHproductions
source

2

Connexes .

— ETHproductions

Maintenant, je peux mesurer la distance en binaire! Oh attendez ...

— Okx

2

1. La règle doit-elle être horizontale? 2. Les marquages doivent-ils être #?

— Jonathan Allan

1

@JonathanAllan 1. Oui, et 2. Non, il peut s'agir de n'importe quel caractère non spatial. J'ai ajouté cela aux règles.

— ETHproductions

La séquence à OEIS: A001511

— Pas un arbre du

11

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

— xnor
source

Le ~ est-il -1 ou +1?

— Stan Strum

Peu importe, c'est (-x) - 1

— Stan Strum

10

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!

— Leaky Nun
source

Wow, il m'a fallu un certain temps pour comprendre comment les lignes sont générées. Bien joué.

— ETHproductions

2

a=2**len(bin(n))pour 72 octets

— ovs

2

Il frappera rapidement les erreurs de mémoire et imprimera un tas d'espace blanc supplémentaire (autorisé) - mais vous pouvez faire 54 en utilisant Python 2 .

— Jonathan Allan

9

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

— DJMcMayhem
source

Je ne suis pas tout à fait sûr, mais je pense que vous pouvez supprimer le |.

— Kritixi Lithos

@KritixiLithos Aha! Avec le recul, c'est tellement évident! Merci pour le conseil. :)

— DJMcMayhem

5

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:

Afficher l'extrait de code

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

Développer l'extrait

Animation:

Afficher l'extrait de code

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>

Développer l'extrait

— Rick Hitchcock
source

1

Bien joué. Vous pouvez changer c/2|0pour c>>1enregistrer un octet.

— ETHproductions

Bien, j'ai besoin de rafraîchir mes opérateurs au niveau du bit.

— Rick Hitchcock

4

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)

— Adam
source

3

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 #.

— Leaky Nun
source

2

Octave, 45 octets

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

Essayez-le sur Octave Online!

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

— rahnema1
source

2

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!

— Jörg Hülsermann
source

2

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

— Oliver
source

20 octets

— Shaggy

@Shaggy En fait, vous n'avez même pas besoin dul

— ETHproductions

@ETHproductions: oui, je viens de comprendre cela. 18 octets

— Shaggy

17 octets

— Shaggy

Une astuce intéressante avec les opérateurs au niveau du bit est de ne n&-ncapturer que le s final 1et tous les 0s finaux n. Je ne sais pas si cela va aider, mais ça vaut le coup ...

— ETHproductions

2

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.

— cmaster - réintégrer monica
source

Avez-vous même besoin du int i,l,m?

— Zacharý

@ZacharyT Non, il s'avère que je ne l'ai pas fait. Merci d'avoir sauvegardé ces 10 octets :-)

— cmaster - réintègre monica le

2

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

— KarlKastor
source

@JasonS C'est un langage de golf basé sur Python! J'ai maintenant lié le github de pyth . Je pensais que l' essayer! un lien vers l'exécuteur en ligne serait suffisant.

— KarlKastor

2

Python 2 , 47 octets

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

Essayez-le en ligne!

— Anders Kaseorg
source

1

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

Afficher l'extrait de code

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

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

Développer l'extrait

JavaScript (ES6), 77 octets

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

Afficher l'extrait de code

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

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

Développer l'extrait

— darrylyeo
source

1

@RickHitchcock Fixed.

— darrylyeo

1

Mathematica, 69 octets

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

— J42161217
source

1

( 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

— tuskiomi
source

1

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.

— Laikoni
source

1

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}

— zgrep
source

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!

— Hand-E-Food
source

La conversion en un Func<int, string>vous ferait-elle économiser quelques octets?

— TheLethalCoder

1

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.

— Neil
source

C'est encore absolu, juste maintenant il s'appelle JumpTo(désolé)

— ASCII uniquement

@ ASCII uniquement Ah, le wiki pourrait faire une mise à jour. (Ou je suppose que je pourrais le faire si vous voulez me donner la permission de modifier ...)

— Neil

@ ASCII uniquement Huh, j'aurais dû me souvenir que de codegolf.stackexchange.com/a/119904 ...

— Neil

Avez-vous un compte GitHub?

— ASCII uniquement

@ ASCII uniquement J'en ai deux ... Je ne peux pas décider lequel est le plus approprié ...

— Neil

1

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.

— cole
source

Il me ressemble à 38, à moins que 3le début ne soit entré ...

— ETHproductions

@ETHproductions merci, la honte de passer d'une définition tacite n'a pas sauvé d'octets ...

— cole

1

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

— miles

0

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

— PunPun1000
source

0

CJam, 34 octets

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

Meh.

— Esolanging Fruit
source

0

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!

— Giacomo Garabello
source

Suggérer à la n+~xplace den^x+1

— plafondcat

0

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!

— Xcali
source

Créer une règle binaire

Règles

Cas de test

Notation

Python 2 , 54 octets

Python 3 , 74 octets

V , 17 , 16 octets

JavaScript (ES6), 61 58 octets

APL (Dyalog) , 21 octets

Gelée , 11 10 octets

Octave, 45 octets

PHP , 139 octets

Japt , 20 17 octets

Explication:

C, 84 74 octets

Non golfé:

Testez avec:

Explication

Pyth , 15 octets

explication

Python 2 , 47 octets

JavaScript (ES8), 71 octets

JavaScript (ES6), 77 octets

Mathematica, 69 octets

( WESRRMICGSE ): 237 octets

Haskell , 64 62 octets

k, 33 octets

C #, 174 octets

Essayez-le en ligne!

Fusain , 27 23 octets

J, 38 octets

Java (OpenJDK 8) , 91 octets

CJam, 34 octets

C (gcc) , 70 octets

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