Étant donné un entier positif n >= 1, affichez les premières nlignes de la structure suivante:

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

La n-ième ligne indexée est la représentation binaire de n, mise en miroir sans copier le dernier caractère, avec #à la place de 1 et <space>à la place de 0. Toutes les lignes sont centrées.

Vous devez sortir en tant qu'art ASCII mais vous pouvez utiliser n'importe quel caractère non blanc à la place de celui que j'utilise #dans l'exemple. Les espaces de fin sont autorisés et les retours à la ligne de fin sont autorisés. La sortie doit ressembler à l'exemple, et pas d'espace blanc de tête supplémentaire ni de nouvelle ligne de tête.

Vous pouvez voir les 1023 premières rangées de la cathédrale fractale ici .

Pour générer des cas de test plus volumineux, voici une implémentation de référence non golfée en Python

MATL , 10 octets

:B2&Zv35*c

Essayez-le en ligne!

Explication

:      % Implicitly input n. Push range [1 2 ... n]
B      % Convert to binary. Gives a matrix where each row corresponds to
       % a number. Rows have left-padding zeros if needed
2      % Push 2
&Zv    % Symmetrize along sepecified dimension (2nd means horizontally),
       % without repeating the last element
35*    % Multiply by 35 (ASCII code for '#')
c      % Convert to char. Char 0 is shown as space. Implicitly display

05AB1E , 9 octets

Code:

Lb€û.c0ð:

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication:

L              # List [1, .., input]
 b             # Convert each to binary
  €û           # Palindromize each binary number
    .c         # Join the array by newlines and centralize
      0ð:      # Replace zeroes by spaces

Gelée , 12 octets

RBUz0ZUŒBo⁶Y

Essayez-le en ligne!

Python 2 , 92 octets

n=input()
for x in range(n):s=bin(2**len(bin(n))/4+x+1)[3:].replace(*'0 ');print s+s[-2::-1]

Essayez-le en ligne!

En Python 3, s=f'{x+1:0{len(bin(n))-2}b}'.replace(*'0 ')est plus court, mais int(input())et les parenthèses autour de l' printargument le poussent jusqu'à 95 octets.

JavaScript (ES6), 106 octets

Utilise 1comme caractère non blanc.

f=(n,k=0)=>k++<n?[...Array(32-Math.clz32(n))].reduce((s,_,i)=>(c=k>>i&1||' ')+s+(i?c:''),'')+`
`+f(n,k):''

Démo

f=(n,k=0)=>k++<n?[...Array(32-Math.clz32(n))].reduce((s,_,i)=>(c=k>>i&1||' ')+s+(i?c:''),'')+`
`+f(n,k):''

O.innerText = f(15)

<pre id=O>

Version alternative (même taille)

Sans Math.clz32():

f=(n,a=[k=i=0])=>n>>i+1?f(n,a,a[++i]=i):k++<n?a.reduce((s,i)=>(c=k>>i&1||' ')+s+(i?c:''),'')+`
`+f(n,a):''

Coque , 21 20 18 octets

Merci @Zgarb d'avoir joué au golf sur 2 octets!

S↑(tfS=↔ΠR" #"←DLḋ

Essayez-le en ligne!

Non golfé / Explication

Pour éviter un long rembourrage, cela détermine la largeur de la fractale qui est donnée en tant que 2*len(bin(N))-1et génère toutes les séquences de cette longueur avec les symboles #,_(«_» désigne un espace).

Étant donné que la puissance cartésienne est générée dans l'ordre et que les nombres binaires le sont aussi, c'est très bien. Tout ce que nous devons faire pour obtenir la fractale à ce stade, c'est filtrer tous les palindromes et c'est essentiellement ça:

                    -- implicit input N
S↑(                 -- take N from the following list
        ΠR" #"      --   Cartesian power of [" #"] to
                Lḋ  --     number of bits in bin(N)
               D    --     2*
              ←     --     -1
    fS=↔            --   filter out palindromes
   t                --   drop the first line (all spaces)

Mathematica, 94 octets

Column[Row/@Table[s=IntegerDigits[i,2];Join[s,Reverse@Most@s]/.{0->" ",1->"#"},{i,#}],Center]&

Mathematica, 98 octets

Riffle[Nest[ArrayFlatten@{{0,#,0},{1,0,1},{1,#,1}}&,{1},⌊Log2@#⌋]~Take~#"#"/. 0->" ","
"]<>""&

Essayez-le dans le bac à sable Wolfram ! Le ⌊et ⌋sont trois octets chacun.

C'est une approche différente des autres réponses jusqu'à présent, en utilisant la nature fractale du motif. L'étape clé est ArrayFlatten@{{0,#,0},{1,0,1},{1,#,1}}&, qui fait le truc fractal, mieux expliqué sous forme d'image:

                 [    ]
                 [grid]
[    ]           [    ]
[grid]   --->   #      #
[    ]          #[    ]#
                #[grid]#
                #[    ]#

Le code répète cette étape suffisamment de fois pour obtenir au moins n lignes, puis supprime les lignes supplémentaires et l'affiche correctement.

Gaia , 11 octets

 #”B¦ₔṫ¦€|ṣ

Essayez-le en ligne!

Explication

    ¦ₔ       For each number 1..input:
 #”B          Convert it to base 2 and use space as 0 and # as 1
      ṫ¦     Palindromize each
        €|   Centre the lines
          ṣ  Join with newlines

Python 2 , 120 118 118 107 octets

merci @luismendo, @officialaimm, @ halvard-hummel

def f(l):
 for a in range(1,l+1):print(bin(a)[2:]+bin(a)[-2:1:-1]).replace(*'0 ').center(len(bin(l+1))*2-4)

Essayez-le en ligne!

C # (.NET Core) , 192 178 octets 168 + 23

merci TheLethalCoder pour l'aide.

x=>new int[x].Select((_,z)=>Convert.ToString(z+1,2).PadLeft((int)Math.Log(x,2)+2).Replace('0',' ')).Aggregate((y,z)=>y+"\n"+z+new string(z.Reverse().Skip(1).ToArray()))

Essayez-le en ligne!

assez sûr que cela peut être réduit de beaucoup, très probablement dans le rembourrage et l'inversion de la chaîne.

Fusain , 28 octets

Ａ…·¹ＮθＷ⌈θ«Ｅθ§ #κ↓⸿ＡＥθ÷κ²θ»‖Ｏ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ａ…·¹Ｎθ

Créez une liste des premiers nnombres naturels.

Ｗ⌈θ«

Répétez jusqu'à ce que tous les éléments soient nuls.

Ｅθ§ #κ

Imprime le dernier chiffre binaire de chaque élément de la liste sous la forme d'un ou #.

↓⸿

Passez à la colonne précédente.

ＡＥθ÷κ²θ

Divisez tous les éléments de la liste par deux.

»‖Ｏ

Une fois la moitié gauche dessinée, réfléchissez-la.

J, 29 octets

' #'{~(],}.@|.)"1@(#.^:_1)@i.

Essayez-le en ligne!

explication

• i. entiers jusqu'à n, l'entrée
• (#.^:_1) converti en base 2
• (],}.@|.)ligne par ligne ( "1fait cette partie), prenez le nombre binaire ( ]est l'identité fn), et cat il ( ,) avec son inverse ( |.), où l'inverse est décapité ( }.).
• ' #'{~convertit les 1s et 0s en hachages et espaces.

Proton , 95 octets

r=>{for i:range(1,r)print(((bin(i)[2to]).rjust(len(bin(r))-2)[to-1,to by-1]).replace('0',' '))}

Essayez-le en ligne!

Il y a trop de bugs pour ne pas avoir trop de parenthèses ... J'ai besoin de corriger l'analyseur ...

SOGL V0.12 , 11 octets

∫2─0@ŗ}¹╬⁴╚

Essayez-le ici!

PHP, 98 97 95 94 + 1 octets

while($r++<$argn)echo$s=strtr(sprintf("%".-~log($argn,2).b,$r),0," "),substr(strrev("
$s"),1);

Exécuter en tant que pipe avec -nRou l' essayer en ligne . Utilise 1comme espace non blanc.

K (ngn / k) , 19 octets

{" #"@+a,1_|a:!x#2}

Essayez-le en ligne!

Python 2 , 93 octets

n=input()
for i in range(n):s=bin(2**n.bit_length()+i+1)[3:].replace(*'0 ');print s+s[-2::-1]

Essayez-le en ligne!

Python 2 , 89 octets

n=input()+1
w=' #'
while len(w)<n:w=[s+l+s for s in' #'for l in w]
print'\n'.join(w[1:n])

Essayez-le en ligne!

C (gcc) , 146 108 105 octets

#define o putchar(33-!(c&(1<<n)))
b;c;p(n){--n?o,p(n),o:o;}f(n){while(n>>++b);while(c++<n)p(b),puts("");}

Essayez-le en ligne!

Il s'agit d'une fonction f(n)appelée avec le nombre de lignes n, utilisant un point d'exclamation ( !) comme caractère non blanc.

Explication :

#define o putchar(33-!(c&(1<<n)))
b;c;
p(n)
{
    // least significant bit not yet reached?
    --n?
            // print bit twice with recursive step between
            o,
            p(n),
            o
        // for least significant, just print this bit
        :o;
}

// the main "cathedral function":
f(r)
{
    // determine max number of bits to shift
    while(r>>++b);

    // iterate over rows
    while(c++<r)

        // print row recursively
        p(b),

        // newline
        puts("");
}

/**
 * footer, just calling the function
 */
main(int argc, char **argv)
{
    f(atoi(argv[1]));
}

JavaScript (Node.js) , 156 149 octets

-7 octets par @ ConorO'Brien

f=(n,w=n.toString(2).length,b=n.toString(2).replace(/0/g," "),s=" ".repeat(w-b.length))=>`${--n?f(n,w)+s+b+[...b].reverse().join``.substr(1):s+"1"}
`

Essayez-le en ligne!

Fonction récursive. Malheureusement, JS ne prend pas en charge l'inversion d'une chaîne, donc 19 octets sont utilisés pour la transformer en tableau et inversement.

Perl 5 , 77 + 1 (-n) = 78 octets

$x=1+(log$_)/log 2;map{$_=sprintf"%0${x}b",$_;y/0/ /;say$_.chop.reverse}1..$_

Essayez-le en ligne!

Utiliser '1' au lieu de '#' car cela économise quelques octets.

Stax , 8 octets

ç▼┼Ö☺ǬÉ

Exécuter et déboguer

Réponse la plus courte jusqu'à présent. Utilise CP437 charcode 1 à la place de #.

Équivalent ASCII:

{:B|pm|Cm