Complexidade simples

17

Resultado

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

Espaços à direita permitidos. A solução mais curta vence.

dica0

dica1:

dica1

obrigado @Tahg por corrigir a dica1

code-golf ascii-art kolmogorov-complexity ngn
fonte
8
A saída @ngn apenas desafia sem explicação para a forma como os dados foram formados geralmente é desaprovada (consulte codegolf.stackexchange.com/q/126037 ), porque a primeira resposta tende a explodir a parte "misteriosa"
Uriel
16
Pessoalmente, não gosto de desafios como este, onde descobrir a regra / receita faz parte da tarefa. Além disso, uma vez que uma pessoa a encontre, todas as outras poderão segui-la, então por que não publicar em primeiro lugar?
Luis Mendo
11
@LuisMendo É um argumento interessante. O código de golfe em sua forma mais pura é "implementar uma solução conhecida de forma sucinta". Os quebra-cabeças em sua forma mais pura são sobre encontrar uma solução - a implementação não é relevante ou é considerada um trabalho ocupado. Uma opção seria postar o "truque" nos spoilers. Dessa forma, os jogadores de código puro para atacar o problema como um desafio de golfe, e aqueles que gostam dos desafios de golfe e quebra-cabeça podem evitar olhar e resolver os dois.
Jonah
5
Eu acho que a parte "misteriosa" é algo que eu definitivamente podia ver mais. Embora uma resposta possa encontrar o truque, o restante ainda é um desafio regular de golfe com código ... E fornece um bom desafio para aqueles que pretendem encontrar o padrão no início.
totallyhuman
3
@ H.PWiz, não tenho certeza de que + 26 / -7 seja realmente "bem recebido". Parece mais "mal recebido, mas conseguiu atingir o HNQ rápido o suficiente para obter uma pontuação distorcida".
Peter Taylor

Respostas:

11

SOGL V0.12 , 17 16 14 bytes

 #6{³IIč▓┼;I+§

Experimente aqui!

Em uma atualização posterior, č▓poderia ser removido por 12 bytes - que converte ToS de uma matriz de matrizes de caracteres em uma cadeia de linhas multilinhas em uma matriz de cadeias de caracteres - [["#","#"],[" ","#"]] -> ["##"," #"]- porque ┼- anexo horizontal - não lida bem com matrizes de matrizes de caracteres - que Icria, porque também é usado para rotação de array. No SOGL, uma matriz de matrizes de caracteres deve ser = matriz de strings, mas muitas coisas ainda não suportam isso.

Explicação:

 #            push "#"
  6{          6 times do
    ³           create 3 total copies of ToS
     II         rotate clockwise twice
       č▓       normalize as explained above
         ┼      append horizontally
          ;     get the 3rd copy ontop
           I    rotate clockwise
            +   append vertically
             §  reverse horizontally
dzaima
fonte
11
espere o que isso funciona #
Conor O'Brien
@ ConorO'Brien acabou de adicionar uma explicação: p
dzaima
`` `` ``
Conor O'Brien
22

JavaScript (ES6), 233 217 213 198 182 170 163 122 bytes

f=_=>[...Array(64)].map((_,x,a)=>a.map(g=(i=(n=64,x),j)=>(n>>=1)?i&n?j&n?g(j,i):` `:j&n?g(i,~j):g(~i,j):`#`).join``).join`
`
document.write(`<pre>${f()}</pre>`)
Expandir snippet

Edit: Salvo 14 18 bytes graças a @Shaggy. Economizou 3 bytes graças a @ngn. Economizou mais 12 bytes graças aos dois trabalhando juntos. Economizou 41 bytes roubando as observações de @ user202729 de que os trimestres usam reflexos em vez de rotações. Ungolfed:

function f() {
    var s = '';
    for (var i = 0; i < 64; i++) {
        for (var j = 0; j < 64; j++) {
            var x = i, y = j, c = '#'; // Default to #
            // Each non-blank quadrant maps to to the original
            // image by doubling and a reflection. Repeat
            // this six times unless we hit the blank quadrant.
            for (var n = 0; n < 6; n++) {
                if (x >= 32) {
                    if (y >= 32) {
                        // Bottom right quarter is a diagonal reflection
                        var t = x - 32;
                        x = y - 32;
                        y = t;
                    } else {
                        // Bottom left quarter is blank
                        c = ' ';
                        break;
                    }
                } else {
                    if (y >= 32) {
                       // Top right corner is a horizontal reflection
                       y = 63 - y;
                    } else {
                       // Top left corner is a vertical reflection
                       x = 31 - x;
                    }
                }
                x *= 2;
                y *= 2;
            }
            s += c;
        }
        s += '\n';
    }
    return s;
}
Neil
fonte
Você precisa contar o f=aqui? Bem feito, a propósito.
Shaggy
217 bytes
Salsicha
11
Você não precisa f=da contagem de bytes, mas o snippet de código não funciona sem ele.
11
@ Neil Alguma chance de você adicionar uma explicação ou uma versão não destruída?
Jonah
11
@ Jonah Espero que você ache isso útil.
Neil
11

LOGO, 375 341 297 295 278 + 3 bytes

Adicione 3 bytes por causa do -psinalizador, que habilita o modo de perspectiva por padrão e, portanto, não precisa executar o perspectivecomando, economiza 9 bytes no geral.

Use o FMSLogo no Windows com o formato de nova linha Unix (LF) (FMSLogo tem problema ao analisar o formato de nova linha CR)

to R
rt 90
end
to g :w :l
R fd 2*:l R bk :l up 180
run :w
R run :w
fd 2*:l R bk :l run :w
fd 2*:l up 180
end
to h
pu
ask -1[setxyz 0 0 870]g[g[g[g[g[g[rt 45 fd .7 pd fd 0 pu bk .7 lt 45]1]2]4]8]16]32
repeat 64[sety 64-# repeat 64[setx #-1 type if pixel=[0 0 0]""#["\ ]](pr)]
end

Infelizmente, não há "Experimente online!" link porque não consigo encontrar nenhum modo de perspectiva de suporte ao intérprete online.

Idéia: desenhe uma imagem da imagem, recupere os pixels da imagem e imprima como saída.

Repartição da imagem em partes simples e repetidas:

.

Faça uso da dica acima. No entanto, como o LOGO não suporta reflexão, só podemos simular isso entrando no modo 3D ( perspective) e girar a tartaruga 180 graus em torno de um eixo paralelo à tela do computador.

Isso define uma função auxiliar g, que, com 2 parâmetros l(comprimento do lado da imagem) e w(procedimento usado para desenhar a imagem), desenha 3 cópias da imagem refletida. (consulte a dica na pergunta) O procedimento hexecuta o procedimento principal.

user202729
fonte
Você provavelmente pode omitir alguns espaços como 90 fd-> 90fde salvar alguns bytes.
Jonathan Frech
@JonathanFrech Infelizmente, o FMSLogo não suporta isso.
user202729
Por que papert suporta isso então?
Jonathan Frech
2
Essa é a única resposta que realmente explora o padrão em vez de empacotar pouco?
Jonah
2
@Jonah A solução JS foi a primeira a explorar o padrão, embora o faça de uma maneira interessante - com aritmética modular e operações de bits em vez de concatenar matrizes. Esta solução LOGO também é interessante e única com sua abordagem de leitura de pixels. Eu não conheço LOGO suficiente para entender o código, mas a julgar pela descrição, ele repete certos padrões sem percorrer toda a estrutura do fractal (que eu já dei na dica 1).
NGN
10

05AB1E , 30 26 bytes

'#)6F©R®í®'#ð:®ζ)2ä€ø€J˜}»

Experimente online!

Emigna
fonte
8

Python 2 , 205 195 ... 145 144 142 144 bytes

g=lambda n,i,j,*_:g(n/2,*[~i,j,i,~j][2*(j&n>0)-(i&n>0):])if n*(i&n<=j&n)else'# '[i&n>0]
r=range(64)
for j in r:print''.join(g(32,j,i)for i in r)

Experimente online!

Inspirado pela resposta JS de Neil .

TFeld
fonte
n>>1é n/=2.
Jonathan Frech
aé definido e usado uma vez. Substituir sua referência por seu valor poderia economizar quatro bytes.
Jonathan Frech
Eu negligenciei uma simplificação útil - ao invés de fazer tudo usando rotações, eu deveria estar usando reflexões. Ele me salvou 41 bytes na minha resposta!
Neil
Eu acho que você pode salvar dois bytes, simplificando sua [...[x],...[x]][z]seleção .
Jonathan Frech
11
@totallyhuman Fair suficiente
TFeld 10/11
7

Haskell, 126 125 113 106 103 bytes

e=[]:e
z=zipWith
r=reverse
m s=z(++)(r s++map(' '<$)s)$map r s++foldr(z(:))e s
unlines$m$m$m$m$m$m["#"]

Uma implementação direta do hint1 no spoiler.

A função mgera a próxima iteração. As principais funções se aplicam m6 vezes. Detalhes para m:

m s=                          -- s is the current pattern
     zipWith(++)              -- concatenate pairwise the lines of
                (r s)++       --    the lines of s in reverse order, followed by
                map(' '<$)s   --    each char in s replaced by a space
                              -- and
                map r s++     --    each line of s reversed, followed by
                foldr ... s   --    the transposition of s


e=[]:e;foldr(zipWith(:))e     -- this right fold transposes a matrix

Edit: @ngn salvou um byte e @Laikoni outro 3. Obrigado!

nimi
fonte
n$n$n$n$n$n["#"]é mais curto do que iterate n["#"]!!6:)
NGN
@ngn: bem localizado. Muito obrigado!
nimi
Você pode usar em e=[]:e;foldr(zipWith(:))evez de import Data.List;transposee depois encurtar zipWith.
Laikoni 22/09
6

Java 7, 259238237200 bytes

void f(){char[][]o={{35}},n;for(int s=1,x,y;s<64;s*=2,o=n)for(n=new char[64][64],x=s;x-->0;)for(y=0;y<s;n[s+y++][x]=32)n[s+~y][x]=n[y][2*s+~x]=n[s+x][s+y]=o[y][x];for(char[]b:o)System.out.println(b);}

Economizou 2 bytes removendo o {} no loop x, obrigado ngn
Economizou 19 bytes de várias alterações de atribuição, obrigado Jonathan
Economizou 24 bytes para impressão versus retorno (não sabia que isso era permitido) e
salvou 13 bytes para alterações de loop, obrigado Nevay

Experimente online!

Meu primeiro desafio, e acho respeitável para Java. Usa a dica 1, (que está errada, mas não posso escrever comentários). Provavelmente pode ser ainda mais jogado, esse passe foi basicamente como está, sem uma impressão bonita.

Tahg
fonte
Não tenho certeza se isso pode ocorrer devido a uma diferença de versão, mas testei seu código no TIO usando Java 8 e imprime caracteres nulos em vez de espaços.
Jonathan Frech
Com certeza, obrigado por perceber. Aparentemente, Java está muito feliz em exibir nulos como espaços em suas Strings.
Tahg 21/09/17
Você pode salvar um byte removendo s=1do loop for e substituindo int s,t,x,y;por int s=1,t,x,y;.
Jonathan Frech
11
n[s-1-y][x]=o[y][x];n[y][t-1-x]=o[y][x];-> n[s-1-y][x]=n[y][t-1-x]=o[y][x];.
Jonathan Frech
2
a matriz de transformação adequada é [[V, H], [_, T]] (Ou isso ou há alguma diferença sutil em seu algoritmo, mas é o que eu precisava)
Tahg
3

Python 2, 586 bytes

import zlib,base64 as b
print zlib.decompress(b.b64decode('eJyVVlsOwzAI++8pJuX+d1zXDGLAUKi0pUp52ATcfj7+Wni3dF2/677ZO1dw+z/Zd3+rJU4SdkVHMcYQS9OuJVGio4N61p31+TGoQkco6eqoU6gSWdBJRrQhjhIdvLQ6YhNrqrEtUsu8yEbjmRqUWXlgYbl5EHfLC7cDQl4sxxAhO4wUv7fFPTx22sUWqOeEJ544Z3vn9FPU+ZmdHtCak6Fk3hfCx0FkOC8DF4YvmgoFMnCEwW2cDBkzftoiGy4GZaNhM8VYSl3YMEV7ctxsjLQKRCHZ3IB6+ATZpKSKmEyGrqZvEHY8lEQBWf8zbuAg0eypWG6nRqTLIzM+NPQa2faN89FlxhMY2vcTKDP7579fl0rmIpJ+grTvSyis798ghb4vM0CuVgbM1SFdvukjnFnfR1Gt3vAEngd6lGrIDdfkDU/ARwl+ecMHf5SzIzct8KhsqHANZ0FqFbpXdad5qH2DzOHJIHGM2pz26oug9i2+EBpX+cXQCpBA7/tne01lLb4wviHjtJE='))

Experimente online.

Python 2, 1032 1025 bytes

Eu gosto mais deste. Mas é muito mais longo. Poderia ser jogado para baixo, mas não há necessidade disso. A abordagem de officialaimm é muito mais curta.

-7 graças a Jonathan Frech

print''.join(' '*int(x)if'/'<x<'@'else("#"*(ord(x)-64),"\n")[x<"#"]for x in'99A9A2A4A2A1E2B4A9!99B8D4G2A3A4B8!88D8B6B4A2C1G8!88A2A9A7A4E1C1A2A8!88A2A1C1E3E4A9A2A8!88G1C2A2C2A4B8D8!88B4A3A2C2A2G8B55!98A4B2E3E1A2A9A55!88B4A559A9A2A1E2!98A4B99B8G2A2!98G88D8B4A2C!88C1A2A88A2A9A4E1!992A2A88A2A1C1E4A5!992D88G1C2A4B4!992B99B4A3A2G4!777A559A4B2E1A2A4!4A2A1E2B4A559A777!4G2A3A4B99B992!4B4A2C1G88D992!5A4E1C1A2A88A2A569!1E4A9A2A88A2A1C88!C2A4B8D88G98!2A2G8B99B4A89!2E1A2A9A559A4B88!55A9A2A1E3E2B4A98!55B8G2A2C2A3A4B88!8D8B4A2C2A2C1G88!8A2A9A4E3E1C1A2A88!8A2A1C1E4A7A9A2A88!8G1C2A4B6B8D88!8B4A3A2G4D8B99!9A4B2E1A2A4A2A9A99!99996A777!99996B992!99994D299!99994A2A992!99994A2A1C88!99994G98!99994B4A98!99995A4B88!9996E2B4A89!9995C2A3A4B88!9997A2C1G88!9997E1C1A2A88!9997A9A2A88!9997B8D88!9995D8B99!9995A2A9A99!9997A9A2A4A2A1E2!9997B8D4G2A2!9995D8B6B4A2C!9995A2A9A7A4E1!9995A2A1C1E3E4A5!9995G1C2A2C2A4B4!9995B4A3A2C2A2G4!9996A4B2E3E1A2A4!9995B4A559A5!9996A4B99B4!9996G88D4!9995C1A2A88A2A4!9999A2A88A2A1C!9999D88G1!9999B99B4A1!99991A559A4B')

Experimente online.

Simon
fonte
A pergunta permite [t]railing spaces, embora sua solução omita alguns espaços.
Jonathan Frech
Permitir espaços à direita significa que eu não tenho que produzi-los. Isso está correto? Isso salvaria bytes na minha segunda abordagem. No primeiro, ele já está pronto, porque eu apaguei os espaços à direita, salvando meu arquivo ...
Simon
Não sei ao certo, mas o interpretei como permitindo espaços adicionais, não permitindo espaços ausentes.
Jonathan Frech
x=='!' -> x<'#'
Jonathan Frech
if x.isdigit() -> if"/"<x<"@"
Jonathan Frech 20/09
3

Mathematica, 112 90 bytes

Obrigado a Jonathan Frech pela ajuda em salvar 2 bytes!

""<>Nest[{{(r=Reverse)@#,r/@#},{" "+0#,#}}~Flatten~{{1,3},{2,4}}&,{{"#"}},6]~Riffle~"
"

Experimente online! (Matemática)

Por alguns motivos, o Mathics imprime espaços à esquerda em todas as linhas, exceto a primeira ao imprimir uma sequência de linhas múltiplas. Também Mathics não suporta operador .

Explicação:

  • {{Reverse@#,Reverse/@#},{" "+0#,#}}: Representa o reverso na horizontal, o reverso na vertical, substituir todos por " "e transpor ( é operador de transposição no Mathematica), correspondendo a diferentes maneiras de refletir ou girar a imagem.
  • ~Flatten~{{1,3},{2,4}} : Achatar em dimensões particulares.
  • Nest[ ... ,{{"#"}},6]: Aplique a função dentro de {{"#"}}6 vezes.
  • ~Riffle~"<literal newline character>" : Reproduz um caractere de nova linha entre cada linha.
  • ""<> : Junte todas as cordas.
user202729
fonte
Você pode definir substituir Reversepor Re definir R=Reverse;para salvar dois bytes.
22617 Jonathan Frech
2

C # (.NET Core) , 1016 1002 980 955 bytes

Economizou 14 bytes graças a Kevin Cruijssen!
Economizou 47 bytes graças a Jonathan Frech!

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,325982355457<<21,1092065689603<<20,835235872783<<20,291765223433<<20,0x7c20090000970000,-15289957744513<<17,21955973480545<<17,68788263321667<<16,68799053409<<17,206425089091<<16,0xf00c27277f0000,618546478825<<16,650622541833<<16,0xfee430300f0000,208473439235<<18,72203117569<<18,1<<21,3<<20,15<<20,9<<20,9895936,127<<17,97<<17,67<<16,15969<<17,3829596160,662634496,16105<<16,8201<<16,806289408,4027318272,9217L<<18,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64,'0').Replace('0',' ').Replace('1','#'));}

Experimente online!

Explicação

O formato da saída é armazenado em uma matriz de números assinados de 64 bits, que se encaixa perfeitamente, pois cada linha possui 64 caracteres. Os espaços vazios são representados por 0e #são representados por 1.

Os números são então convertidos em sua sequência binária, os zeros são preenchidos à esquerda até que a cadeia tenha 64 caracteres de largura e os caracteres 0e 1sejam substituídos por  e# .

O código é armazenado dentro de uma função lamba, mais especificamente um System.Func<string> .

Algumas constantes no long[]são encurtadas executando algumas alterações de bits.

Ian H.
fonte
Não há espaço desnecessário long[] n=new[]?
Jonathan Frech
@ JonathanFrech Ah, você está certo, aparentemente ele entrou lá de alguma forma.
Ian H.
11
Você salvaria 4 bytes por não precisar especificar o caractere de preenchimento.
Neil
11
Bem, se o final lnão for necessário, você provavelmente poderá salvar ainda mais bytes .
Jonathan Frech
11
Parece que a parte inferior está com erros.
Shaggy
2

Carvão , 42 bytes

#↓##ＦＥ⁵Ｘ²ι«‖↑Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι⟲ＣＪ⁰±φＴ×⁴ι×⁴ι

Experimente online! Link é a versão detalhada do código. Seriam 25 bytes se isso funcionasse:

#ＦＥ⁷Ｘ²ι«‖↑⟲Ｃ→⁴⟲ＣＪ⁰±φＴιι

Explicação:

#↓##

Gere manualmente a primeira recursão, pois não é possível girar (1, 0,5). (Essa rotação só faria sentido se fosse 180 °.)

ＦＥ⁵Ｘ²ι«

Faça um loop sobre as cinco primeiras potências de 2 (1, 2, 4, 8, 16).

‖↑

Reflita a tela verticalmente. Isso completa o quarto superior esquerdo do resultado.

Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι

Gire a tela 180 ° em torno de um ponto na metade do lado direito. A cópia acaba na posição correta para o quarto superior direito do resultado.

⟲Ｃ

Gire a tela 90 ° ao redor do canto inferior direito. A cópia do canto superior direito termina na posição correta para o canto inferior direito do resultado. A cópia do canto superior esquerdo é estranha.

Ｊ⁰±φＴ×⁴ι×⁴ι

Apare a tela no tamanho desejado. O corte começa no cursor ou no canto superior esquerdo da tela, o que estiver mais abaixo no canto direito. O cursor é, portanto, enviado para (0, -1000) para garantir que não interfira com o corte.

Neil
fonte
1

Python 2 , 715711 bytes

  • -4 bytes graças a @ Jonathan Frech
for k in range(64):print"".join(ord(i)*" #"[j%2]for j,i in enumerate('												<?<<<89:11222	202	4	$" 	!%$%$&%$($%&'))[k<<6:][:64]

Experimente online!

officialaimm
fonte
11
711 bytes.
Jonathan Frech
@ JonathanFrech Obrigado, acho que não havia novas linhas. : D
officialaimm
1

Perl 5 , 452 bytes

Código de 451 bytes + 1 para -p.

Pacotes de todos os dados na seqüência, em vez de roubar @ Neil 's resposta correta .

$_=unpack"B*","\x00\x00\x20\x09\x09\x7c\xc2\x33\x00\x30\x0f\x0f\xe4\x43\x33\x00\xf0\x0c\x0c\x27\x7f\x33\x00\x90\x04\x04\x3e\xe9\x33\x00\x97\x7c\x7c\x20\x09\x33\x00\xfe\xe4\xe4\x30\x0f\x33\x00\xc2\x27\x27\xf0\x0c\x33\x00\x43\x3e\x3e\x90\x04\x33\x00\xc2\x00\x00\x20\x09\x7c\x00\x00\x43\x00\x00\x30\x0f\xe4\x00\x00\x7f\x00\x00\xf0\x0c\x27\x00\x00\xe9\x00\x00\x90\x04\x3e\x00\x00\x09\x00\x00\x97\x7c\x20\x00\x00\x0f\x00\x00\xfe\xe4\x30\x00\x00\x0c\x00\x00\xc2\x27\xf0\x00\x00\x04\x00\x00\x43\x3e\x90\x09\x7c\xc2\x00\x00\x20\x00\x00\x0f\xe4\x43\x00\x00\x30\x00\x00\x0c\x27\x7f\x00\x00\xf0\x00\x00\x04\x3e\xe9\x00\x00\x90\x00\x00\x7c\x20\x09\x00\x00\x97\x00\x00\xe4\x30\x0f\x00\x00\xfe\x00\x00\x27\xf0\x0c\x00\x00\xc2\x00\x00\x3e\x90\x04\x00\x00\x43\x33\x00\x20\x09\x7c\x7c\xc2\x33\x00\x30\x0f\xe4\xe4\x43\x33\x00\xf0\x0c\x27\x27\x7f\x33\x00\x90\x04\x3e\x3e\xe9\x33\x00\x97\x7c\x20\x20\x09\x33\x00\xfe\xe4\x30\x30\x0f\x33\x00\xc2\x27\xf0\xf0\x0c\x33\x00\x43\x3e\x90\x90\x04\x37\x00\x20\x37\x00\x30\x37\x00\xf0\x37\x00\x90\x37\x00\x97\x37\x00\xfe\x37\x00\xc2\x37\x00\x43\x36\x00\x7c\xc2\x36\x00\xe4\x43\x36\x00\x27\x7f\x36\x00\x3e\xe9\x36\x00\x20\x09\x36\x00\x30\x0f\x36\x00\xf0\x0c\x36\x00\x90\x04\x36\x00\x20\x09\x09\x7c\x34\x00\x30\x0f\x0f\xe4\x34\x00\xf0\x0c\x0c\x27\x34\x00\x90\x04\x04\x3e\x34\x00\x97\x7c\x7c\x20\x34\x00\xfe\xe4\xe4\x30\x34\x00\xc2\x27\x27\xf0\x34\x00\x43\x3e\x3e\x90\x34\x00\xc2\x00\x00\x20\x34\x00\x43\x00\x00\x30\x34\x00\x7f\x00\x00\xf0\x34\x00\xe9\x00\x00\x90\x34\x00\x09\x00\x00\x97\x34\x00\x0f\x00\x00\xfe\x34\x00\x0c\x00\x00\xc2\x34\x00\x04\x00\x00\x43"=~s/[3-9](.)/$1x$&/ger;y/01/ #/;s/.{64}/$&
/g

Saída reversível de xxdpara o arquivo de 451 bytes:

00000000: 245f 3d75 6e70 6163 6b22 422a 222c 2200  $_=unpack"B*",".
00000010: 0020 0909 7cc2 3300 300f 0fe4 4333 00f0  . ..|.3.0...C3..
00000020: 0c0c 277f 3300 9004 043e e933 0097 7c7c  ..'.3....>.3..||
00000030: 2009 3300 fee4 e430 0f33 00c2 2727 f00c   .3....0.3..''..
00000040: 3300 433e 3e90 0433 00c2 0000 2009 7c00  3.C>>..3.... .|.
00000050: 0043 0000 300f e400 007f 0000 f00c 2700  .C..0.........'.
00000060: 00e9 0000 9004 3e00 0009 0000 977c 2000  ......>......| .
00000070: 000f 0000 fee4 3000 000c 0000 c227 f000  ......0......'..
00000080: 0004 0000 433e 9009 7cc2 0000 2000 000f  ....C>..|... ...
00000090: e443 0000 3000 000c 277f 0000 f000 0004  .C..0...'.......
000000a0: 3ee9 0000 9000 007c 2009 0000 9700 00e4  >......| .......
000000b0: 300f 0000 fe00 0027 f00c 0000 c200 003e  0......'.......>
000000c0: 9004 0000 4333 0020 097c 7cc2 3300 300f  ....C3. .||.3.0.
000000d0: e4e4 4333 00f0 0c27 277f 3300 9004 3e3e  ..C3...''.3...>>
000000e0: e933 0097 7c20 2009 3300 fee4 3030 0f33  .3..|  .3...00.3
000000f0: 00c2 27f0 f00c 3300 433e 9090 0437 0020  ..'...3.C>...7. 
00000100: 3700 3037 00f0 3700 9037 0097 3700 fe37  7.07..7..7..7..7
00000110: 00c2 3700 4336 007c c236 00e4 4336 0027  ..7.C6.|.6..C6.'
00000120: 7f36 003e e936 0020 0936 0030 0f36 00f0  .6.>.6. .6.0.6..
00000130: 0c36 0090 0436 0020 0909 7c34 0030 0f0f  .6...6. ..|4.0..
00000140: e434 00f0 0c0c 2734 0090 0404 3e34 0097  .4....'4....>4..
00000150: 7c7c 2034 00fe e4e4 3034 00c2 2727 f034  || 4....04..''.4
00000160: 0043 3e3e 9034 00c2 0000 2034 0043 0000  .C>>.4.... 4.C..
00000170: 3034 007f 0000 f034 00e9 0000 9034 0009  04.....4.....4..
00000180: 0000 9734 000f 0000 fe34 000c 0000 c234  ...4.....4.....4
00000190: 0004 0000 4322 3d7e 732f 5b33 2d39 5d28  ....C"=~s/[3-9](
000001a0: 2e29 2f24 3178 2426 2f67 6572 3b79 2f30  .)/$1x$&/ger;y/0
000001b0: 312f 2023 2f3b 732f 2e7b 3634 7d2f 2426  1/ #/;s/.{64}/$&
000001c0: 0a2f 67                                  ./g

Experimente online!

Dom Hastings
fonte
1

Jq 1.5 , 538 535 488 476 bytes

Esta é uma representação direta. Ainda não tentei nenhuma codificação sofisticada.Pares 0,0 substituídos pela função Z.

Agradecemos novamente a Jonathan Frech por ajudar a eliminar 3 bytes!

def B:recurse(if.>0then./2|floor else empty end)|.%2;def S:256+.|[B]|reverse[2:]|map(if.>0then"#"else" "end)|join("");def Z:0,0;[[Z,3,1,1,4,5,2],[1,4,5,2,2,3,Z],[Z,Z,2,3,Z],[Z,Z,3,1,1,4]]as$m|[[],[9,15,12,4,124,228,39,62],[Z,Z,Z,Z,124,228,39,62,32,48,240,144],[32,48,240,144,151,254,194,67,194,67,127,233,9,15,12,4],[124,228,39,62,32,48,240,144,32,48,240,144,151,254,194,67],[194,67,127,233,9,15,12,4,9,15,12,4,124,228,39,62]]as$c|$m[]|range(16)as$l|map($c[.][$l]|S)|join("")

Contador de caracteres

$ wc -c picture.jq
 476 picture.jq

Amostra de execução

$ jq -Mnr -f picture.jq
                  #         #  #    #  # #####  ##    #         
                  ##        ####    #######  #   #    ##        
                ####        ##      ##    #  ### #######        
                #  #         #       #    ##### ### #  #        
                #  # ### #####   #####    #         #  #        
                ####### ###  #  ###  #    ##        ####        
                ##    #   #  ###  #  #######        ##          
                 #    ##  #####   ##### #  #         #          
                ##    #                   #         #  # #####  
                 #    ##                  ##        #######  #  
                 #######                ####        ##    #  ###
                ### #  #                #  #         #    ##### 
                    #  #                #  # ### #####    #     
                    ####                ####### ###  #    ##    
                    ##                  ##    #   #  #######    
                     #                   #    ##  ##### #  #    
    #  # #####  ##    #                   #                     
    #######  #   #    ##                  ##                    
    ##    #  ### #######                ####                    
     #    ##### ### #  #                #  #                    
 #####    #         #  #                #  # ###                
###  #    ##        ####                #######                 
  #  #######        ##                  ##    #                 
  ##### #  #         #                   #    ##                
          #         #  # #####   #####  ##    #                 
          ##        #######  #  ###  #   #    ##                
        ####        ##    #  ###  #  ### #######                
        #  #         #    #####   ##### ### #  #                
        #  # ### #####    #       #         #  #                
        ####### ###  #    ##      ##        ####                
        ##    #   #  #######    ####        ##                  
         #    ##  ##### #  #    #  #         #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        #  #                    
                                        #  # ###                
                                        #######                 
                                        ##    #                 
                                         #    ##                
                                 #####  ##    #                 
                                ###  #   #    ##                
                                  #  ### #######                
                                  ##### ### #  #                
                                  #         #  #                
                                  ##        ####                
                                ####        ##                  
                                #  #         #                  
                                  #         #  #    #  # #####  
                                  ##        ####    #######  #  
                                ####        ##      ##    #  ###
                                #  #         #       #    ##### 
                                #  # ### #####   #####    #     
                                ####### ###  #  ###  #    ##    
                                ##    #   #  ###  #  #######    
                                 #    ##  #####   ##### #  #    
                                ##    #                   #     
                                 #    ##                  ##    
                                 #######                ####    
                                ### #  #                #  #    
                                    #  #                #  # ###
                                    ####                ####### 
                                    ##                  ##    # 
                                     #                   #    ##
jq170727
fonte
11
Três espaços omitíveis em B: rece 16) as $l|.
Jonathan Frech
11
if.==0then" "else"#"end-> if.>0then"#"else" "end.
Jonathan Frech
1

Python 2 , 174 164 154 bytes (com base em operações de matriz)

  • -10 bytes graças a ngn.
  • -10 bytes graças a Jonathan Frech.
from numpy import*
s=[['#']]
exec'b=fliplr(s);s=vstack((hstack((flipud(s),b)),hstack((eye(len(s)),rot90(b)))));'*6
s[s>'#']=' '
for l in s:print''.join(l)

Experimente online!

mdahmoune
fonte
import *-> import*; in s.tolist()->in s
ngn 28/09
11
154 bytes .
Jonathan Frech
0

JavaScript (Node.js) , 1233 bytes

_=>` 18# 9# 2# 4# 2# #5 2#2 4#
 18#2 8#4 4#7 2# 3# 4#2
 16#4 8#2 6#2 4# 2#3 #7
 16# 2# 9# 7# 4#5 #3 # 2#
 16# 2# #3 #5 3#5 4# 9# 2#
 16#7 #3 2# 2#3 2# 4#2 8#4
 16#2 4# 3# 2#3 2# 2#7 8#2
 17# 4#2 2#5 3#5 # 2# 9#
 16#2 4# 19# 9# 2# #5
 17# 4#2 18#2 8#7 2#
 17#7 16#4 8#2 4# 2#3
 16#3 # 2# 16# 2# 9# 4#5
 20# 2# 16# 2# #3 #5 4#
 20#4 16#7 #3 2# 4#2
 20#2 18#2 4# 3# 2#7
 21# 19# 4#2 2#5 # 2#
 4# 2# #5 2#2 4# 19#
 4#7 2# 3# 4#2 18#2
 4#2 4# 2#3 #7 16#4
 5# 4#5 #3 # 2# 16# 2#
 #5 4# 9# 2# 16# 2# #3
#3 2# 4#2 8#4 16#7
 2# 2#7 8#2 18#2 4#
 2#5 # 2# 9# 19# 4#2
 10# 9# 2# #5 3#5 2#2 4#
 10#2 8#7 2# 2#3 2# 3# 4#2
 8#4 8#2 4# 2#3 2# 2#3 #7
 8# 2# 9# 4#5 3#5 #3 # 2#
 8# 2# #3 #5 4# 7# 9# 2#
 8#7 #3 2# 4#2 6#2 8#4
 8#2 4# 3# 2#7 4#4 8#2
 9# 4#2 2#5 # 2# 4# 2# 9#
 42#
 42#2
 40#4
 40# 2#
 40# 2# #3
 40#7
 40#2 4#
 41# 4#2
 33#5 2#2 4#
 32#3 2# 3# 4#2
 34# 2#3 #7
 34#5 #3 # 2#
 34# 9# 2#
 34#2 8#4
 32#4 8#2
 32# 2# 9#
 34# 9# 2# 4# 2# #5
 34#2 8#4 4#7 2#
 32#4 8#2 6#2 4# 2#3
 32# 2# 9# 7# 4#5
 32# 2# #3 #5 3#5 4#
 32#7 #3 2# 2#3 2# 4#2
 32#2 4# 3# 2#3 2# 2#7
 33# 4#2 2#5 3#5 # 2#
 32#2 4# 19#
 33# 4#2 18#2
 33#7 16#4
 32#3 # 2# 16# 2#
 36# 2# 16# 2# #3
 36#4 16#7
 36#2 18#2 4#
 37# 19# 4#2`.replace(/(.)(\d+)/g,(_,c,n)=>c.repeat(n))

Experimente online!

totalmente humano
fonte
Ooh, qual é o problema agora? Erm ... estou faltando alguma coisa?
totallyhuman
11
Não diminuí a votação, mas, para sua informação, pode ser compactado muito mais usando isso .
Eu também não, mas isso não está no espírito da pergunta. O padrão foi gerado, presumivelmente, por algum procedimento recursivo simples. O desafio é determinar a regra, quando sua solução será extremamente curta.
Jonah
11
Converta na base 36 para salvar ~ 50 bytes.
Shaggy
2
Estou perfeitamente ciente de que essa não é a solução ideal ou a solução mais curta ou inteligente. Eu simplesmente tentei usar um algoritmo e acabou sendo esse. Esta é, no entanto, uma solução perfeitamente válida e, portanto, não merece votos negativos. Soluções chatas não devem ser votadas, mas também não devem ser votadas.
totallyhuman
0

C # (.NET Core) , 976 969 bytes

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,0x97cc20000200000,0xfe44300003<<20,0xc277f0000f<<20,0x43ee900009<<20,0x7c20090000970000,-0x1bcff0ffff020000,0x27f00c0000c20000,0x3e90040000430000,9017629528424448,0x300fe4e4430000,0xf00c27277f0000,0x90043e3ee90000,0x977c2020090000,0xfee430300f0000,0xc227f0f00c0000,0x433e9090040000,2097152,3145728,15728640,9437184,9895936,16646144,12713984,4390912,2093088768,3829596160,662634496,1055457280,537460736,806289408,4027318272,2416181248,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64).Replace('0',' ').Replace('1','#'));}

Experimente online!

meu pronome é monicareinstate
fonte
Olá, seja bem-vindo ao PPCG! Isso parece quase exatamente o mesmo que a resposta C # .NET de @IanH . Portanto, se você tiver alguma melhoria para ele, faça um comentário em vez de criar uma nova resposta que seja quase exatamente a mesma. Quanto à sua pergunta, você pode usar <s>969</s>para atravessar os bytes anteriores.
Kevin Cruijssen
4
Eu não tenho a reputação necessária para comentar.
meu pronome é monicareinstate
Por favor, não tente burlar os requisitos do representante.
Shaggy
2
Isso significa que no PPCG não posso tentar ajudar os outros se minha reputação é muito baixa?
meu pronome é monicareinstate
3
@Shaggy para ser justo, a stackexchange é um pouco dura para os novatos, não vamos dificultar para eles assumindo a malícia muito rapidamente
NGN
0

C # (.NET Core) , 739 bytes

_=>{var r="";for(int i=0,j,k=0;i<626;i++)for(j=0;j++<@"4#+#$#&#$##'$$&#=$*&&)$#%#&$:&*$($&#$%#):#$#+#)#&'#%##$#:#$##%#'%'&#+#$#:)#%$#$%$#&$*&:$&#%#$%$#$)*$=#&$$'%'##$#+#<$&#5#+#$##'5#&$4$*)$#5)2&*$&#$%2%##$#2#$#+#&'7#$#2#$##%#'&#;&2)#%$#&$:$4$&#%#$);#5#&$$'##$#*#$##'$$&#5#;)$#%#&$4$:$&#$%#)2&;#&'#%##$#2#$#7'&#+#$#2#$##%2%$#&$*&2)5#$)*$4$&#5'##$#+#5#&$<#+#$##'%'$$&#=$*)$#$%$#%#&$:&*$&#$%$#$%#):#$#+#&'%'#%##$#:#$##%#'&#)#+#$#:)#%$#&$($*&:$&#%#$)&&*$=#&$$'##$#&#$#+#^#a$^&^#$#^#$##%Z)[$&#\#&$S'$$&#S%$#%#&$T#$%#)T'#%##$#T#+#$#T$*&R&*$T#$#+#V#+#$#&#$##'F$*&&)$#D&*$($&#$%B#$#+#)#&'C#$##%#'%'&#G)#%$#$%$#&$F$&#%#$%$#$)G#&$$'%'##$#F$&#5#H#&$4$G)2&F%##$#2#$#J#$#2#$##%F&2)G$4$&#H#5#&$"[i]-34;){r+=i%2<1?' ':'#';if(++k%64<1)r+='\n';}return r;}

Experimente online!

Usa a mesma abordagem é esta outra resposta .

Charlie
fonte
0

K (ngn / k) , 32 31 27 bytes

6{,[|x;""x],'(+|+x),+x}/"#"

Experimente online!

6{ }/ 6 vezes

+x transpor

|x inverter verticalmente

+|+x inverter horizontalmente

, concatenar verticalmente

,' concatenar horizontalmente

,[A;B]é o mesmo que A,B. ajuda a evitar parênteses ao redorA e ao redor de toda a expressão

""xuse os elementos de xcomo índices na string vazia. A indexação fora dos limites produz espaços, portanto, essa expressão retornará uma matriz de todos os espaços, do mesmo tamanho quex

ngn
fonte