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

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
— 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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.