Dado um número inteiro positivo n >= 1, produza as primeiras nlinhas da seguinte estrutura:

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

A n-ésima linha indexada 1 é a representação binária de n, espelhada sem copiar o último caractere, com #no lugar de 1 e <space>no lugar de 0. Todas as linhas são centralizadas.

Você deve produzir como arte ASCII, mas pode usar qualquer caractere que não seja um espaço em branco no lugar de onde eu uso #no exemplo. O espaço em branco à direita é permitido e uma nova linha à direita é permitida. A saída deve se parecer com o exemplo, e não há espaço em branco extra nem novas linhas de destaque.

Você pode ver as primeiras 1023 linhas da catedral fractal aqui .

Para gerar casos de teste maiores, aqui está uma implementação de referência não destruída em Python

MATL , 10 bytes

:B2&Zv35*c

Experimente online!

Explicação

:      % 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 bytes

Código:

Lb€û.c0ð:

Usa a codificação 05AB1E . Experimente online!

Explicação:

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

Gelatina , 12 bytes

RBUz0ZUŒBo⁶Y

Experimente online!

Python 2 , 92 bytes

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

Experimente online!

No Python 3, s=f'{x+1:0{len(bin(n))-2}b}'.replace(*'0 ')é mais curto, mas int(input())e parens em torno do printargumento aumentam para 95 bytes.

JavaScript (ES6), 106 bytes

Usa 1como o caractere que não é um espaço em branco.

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

Demo

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>

Versão alternativa (mesmo tamanho)

Sem 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):''

Casca , 21 20 18 bytes

Obrigado @Zgarb por jogar fora 2 bytes!

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

Experimente online!

Ungolfed / Explicação

Para evitar o preenchimento prolongado, isso determina a largura do fractal que é dado como 2*len(bin(N))-1e gera todas as seqüências desse comprimento com os símbolos #,_('_' indica um espaço).

Como o poder cartesiano é gerado em ordem e os números binários também, isso é bom. Tudo o que precisamos fazer para obter o fractal neste momento é filtrar todos os palíndromos e é basicamente isso:

                    -- 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 bytes

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

Mathematica, 98 bytes

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

Experimente na sandbox Wolfram ! Os ⌊e ⌋são três bytes cada.

É uma abordagem diferente das outras respostas até agora, usando a natureza fractal do padrão. O passo principal é ArrayFlatten@{{0,#,0},{1,0,1},{1,#,1}}&, que faz as coisas fracamente, melhor explicadas na forma de figura:

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

O código repete essa etapa várias vezes para obter pelo menos n linhas e, em seguida, corta as linhas extras e a exibe de maneira adequada.

Gaia , 11 bytes

 #”B¦ₔṫ¦€|ṣ

Experimente online!

Explicação

    ¦ₔ       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 107 bytes

obrigado @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)

Experimente online!

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

obrigado TheLethalCoder pela ajuda.

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

Experimente online!

Certeza de que isso pode ser reduzido bastante, provavelmente no preenchimento e reversão da corda.

Carvão , 28 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ａ…·¹Ｎθ

Crie uma lista dos primeiros nnúmeros naturais.

Ｗ⌈θ«

Repita até que todos os elementos sejam zero.

Ｅθ§ #κ

Imprima o último dígito binário de cada elemento da lista como um ou #.

↓⸿

Mover para a coluna anterior.

ＡＥθ÷κ²θ

Divida todos os elementos da lista por dois.

»‖Ｏ

Depois que a metade esquerda tiver sido desenhada, reflita-a.

J, 29 bytes

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

Experimente online!

explicação

• i. inteiros até n, a entrada
• (#.^:_1) convertido em base 2
• (],}.@|.)linha por linha ( "1faz essa parte), pega o número binário ( ]é a identidade fn) e o cat ( ,) com seu reverso ( |.), onde o inverso é decapitado ( }.).
• ' #'{~converte 1s e 0s em hashes e espaços.

Próton , 95 bytes

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

Experimente online!

Existem bugs demais para não ter colchetes demais ... Preciso corrigir o analisador ...

SOGL V0.12 , 11 bytes

∫2─0@ŗ}¹╬⁴╚

Experimente aqui!

PHP, 98 97 95 94 + 1 bytes

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

Execute como pipe -nRou experimente online . Usa 1como espaço não em branco.

K (ngn / k) , 19 bytes

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

Experimente online!

Python 2 , 93 bytes

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

Experimente online!

Python 2 , 89 bytes

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

Experimente online!

C (gcc) , 146 108 105 bytes

#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("");}

Experimente online!

Essa é uma função f(n)chamada com o número de linhas n, usando um ponto de exclamação ( !) como caractere que não é um espaço em branco.

Explicação :

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

-7 bytes por @ 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"}
`

Experimente online!

Função recursiva. Infelizmente, o JS não suporta a reversão de uma sequência, portanto, 19 bytes são usados ​​para transformá-la em uma matriz e vice-versa.

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

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

Experimente online!

Usando '1' em vez de '#' porque salva alguns bytes.

Stax , 8 bytes

ç▼┼Ö☺ǬÉ

Execute e depure

Resposta mais curta até agora. Usa o código 1 do CP437 no lugar de #.

Equivalente ASCII:

{:B|pm|Cm