Complejidad simple

17

Salida

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

Espacios finales permitidos. La solución más corta gana.

pista0

pista1:

pista1

gracias @Tahg por corregir la pista1

code-golf  ascii-art  kolmogorov-complexity 
— ngn
fuente
8
La salida de @ngn solo desafía sin ninguna explicación de la forma en que se formaron los datos generalmente está mal visto (ver codegolf.stackexchange.com/q/126037 ), porque la primera respuesta tiende a volar la parte "misteriosa"
— Uriel
16
Personalmente, no me gustan los desafíos como este, donde encontrar la regla / receta es parte de la tarea. Además, una vez que una persona lo encuentra, todos los demás pueden seguirlo, así que ¿por qué no publicar en primer lugar?
— Luis Mendo
11
@LuisMendo Es un argumento interesante. El golf de código en su forma más pura se trata de "implementar una solución conocida de manera sucinta". Los acertijos en su forma más pura tratan de encontrar una solución: la implementación no es relevante o se considera un trabajo ocupado. Una opción sería publicar el "truco" en spoilers. De esa manera, los golfistas de código puro atacan el problema como un desafío de golf, y aquellos a quienes les gustan los desafíos de golf y rompecabezas podrían evitar mirar y resolver ambos.
— Jonás
55
Creo que la parte "misteriosa" es algo que definitivamente podría ver más. Aunque una respuesta podría encontrar el truco, el resto sigue siendo un desafío habitual de golf de código ... Y de todos modos es un buen desafío para aquellos que buscan encontrar el patrón al principio.
— totalmente humano
3
@ H.PWiz, no estoy seguro de que + 26 / -7 sea realmente "bien recibido". Se parece más a "mal recibido pero logró golpear el HNQ lo suficientemente rápido como para obtener una puntuación sesgada".
— Peter Taylor

Respuestas:

11

SOGL V0.12 , 17 16 14 bytes

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

Pruébalo aquí!

En una actualización posterior č▓podría eliminarse por 12 bytes, que convierte ToS de una matriz de matrices de caracteres, una cadena de varias líneas a una matriz de cadenas [["#","#"],[" ","#"]] -> ["##"," #"]-, porque ┼- el apéndice horizontal - no se adapta bien a las matrices de matrices de caracteres - que Icrea, porque también se usa para la rotación de matrices. En SOGL, una matriz de matrices de caracteres debería ser = matriz de cadenas, pero muchas cosas aún no lo admiten.

Explicación:

 #            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
fuente
1
espera, ¿cómo funciona esto
— Conor O'Brien
@ ConorO'Brien acaba de agregar una explicación: p
— dzaima
oh bonito `` `` ``
— 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 fragmento

Editar: Guardado 14 18 bytes gracias a @Shaggy. Guardado 3 bytes gracias a @ngn. Guardamos otros 12 bytes gracias a que los dos trabajaron juntos Ahorró 41 bytes al robar las observaciones de @ user202729 de que los cuartos usan reflejos en lugar de rotaciones. Sin golf:

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
fuente
¿Necesitas contar el f=aquí? Bien hecho, por cierto.
— Shaggy
— Shaggy
1
No necesita f=contar el byte, pero el fragmento de código no funciona sin él.
1
@Neil ¿Hay alguna posibilidad de que puedas agregar una explicación o una versión sin golf?
— Jonás
1
@ Jonás, espero que te sea útil.
— Neil
11

LOGO, 375 341 297 295 278 + 3 bytes

Agregue 3 bytes debido a la -pmarca, que habilita el modo de perspectiva de forma predeterminada, por lo que no es necesario ejecutar el perspectivecomando, ahorra 9 bytes en general.

Use FMSLogo en Windows con formato de nueva línea Unix (LF) (FMSLogo tiene problemas al analizar el formato de nueva línea 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

Desafortunadamente, no "¡Pruébelo en línea!" enlace porque no puedo encontrar ningún modo de perspectiva de soporte de intérprete en línea.

Idea: Dibuje una imagen de la imagen, luego recupere los píxeles de la imagen e imprima como salida.

Desglose de la imagen en partes simples repetidas:

.

Haz uso de la pista anterior. Sin embargo, dado que LOGO no admite la reflexión, solo podemos simular eso ingresando 3D (perspective ) y girar la tortuga 180 grados alrededor de un eje paralelo a la pantalla de la computadora.

Esto define una función auxiliar g, que da 2 parámetros l(longitud del lado de la imagen) y w(procedimiento utilizado para dibujar la imagen), dibuja 3 copias de su imagen reflejada. (ver pista en la pregunta) El procedimiento hrealiza el procedimiento principal.

— usuario202729
fuente
Probablemente pueda omitir algunos espacios como 90 fd-> 90fdy guardar algunos bytes.
— Jonathan Frech
@JonathanFrech Desafortunadamente, FMSLogo no es compatible con eso.
— user202729
¿Por qué lo admite entonces Papert ?
— Jonathan Frech
2
¿Es esta la única respuesta que realmente explota el patrón en lugar de un poco de empaque?
— Jonás
2
@Jonah La solución JS fue la primera en explotar el patrón, aunque lo hace de una manera interesante, con operaciones aritméticas y de bits modulares en lugar de concatenar matrices. Esta solución LOGO también es interesante y única con su enfoque de lectura de píxeles. No conozco suficiente LOGO para comprender el código, pero a juzgar por la descripción, repite ciertos patrones sin descender por la estructura del fractal (que ya di en la pista1).
— 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)

Pruébalo en línea!

Inspirado por la respuesta JS de Neil .

— TFeld
fuente
n>>1es n/=2.
— Jonathan Frech
ase define y luego se usa una vez. Reemplazar su referencia con su valor podría ahorrar cuatro bytes.
— Jonathan Frech
Pasé por alto una simplificación útil: en lugar de hacer todo usando rotaciones, debería haber estado usando reflejos. ¡Me ahorró 41 bytes en mi respuesta!
— Neil
Creo que puede guardar dos bytes simplificando su [...[x],...[x]][z]selección .
— Jonathan Frech
1
@totallyhuman Bastante justo
— TFeld
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["#"]

Una implementación directa de hint1 en el spoiler.

La función mgenera la siguiente iteración. Las funciones principales se aplican m6 veces. Detalles 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

Editar: @ngn guardó un byte y @Laikoni otro 3. ¡Gracias!

— nimi
fuente
n$n$n$n$n$n["#"]es más corto que iterate n["#"]!!6:)
— ngn
@ngn: bien visto. ¡Muchas gracias!
— nimi
Puede usar en e=[]:e;foldr(zipWith(:))elugar de import Data.List;transposey luego acortar zipWith.
— Laikoni
6

Java 7, 259 238 237 200 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);}

Ahorré 2 bytes al eliminar {} en el bucle x, gracias ngn guardé
19 bytes de varios cambios de asignación, gracias Jonathan
guardó 24 bytes para imprimir vs devolver (no sabía que esto estaba permitido), y
guardó 13 bytes para cambios de bucle, gracias Nevay

Pruébalo en línea!

Mi primer desafío, y creo que respetable para Java. Utiliza la sugerencia 1 (que por cierto está mal, pero no puedo escribir comentarios). Probablemente se pueda jugar más, este pase fue básicamente como es, sin una bonita impresión.

— Tahg
fuente
No estoy seguro de si podría deberse a una diferencia de versión, pero probé su código en TIO usando Java 8 e imprime caracteres nulos en lugar de espacios.
— Jonathan Frech
Seguro que sí, gracias por notarlo. Aparentemente, Java está bastante contento con mostrar nulos como espacios en sus cadenas.
— Tahg
Puede guardar un byte quitándolo s=1del bucle for y reemplazándolo int s,t,x,y;por int s=1,t,x,y;.
— Jonathan Frech
1
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
la matriz de transformación adecuada es [[V, H], [_, T]] (O eso o hay alguna diferencia sutil en su algoritmo, pero eso es lo que necesitaba)
— 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='))

Pruébalo en línea.

Python 2, 1032 1025 bytes

Me gusta este más. Pero es mucho más largo. Podría jugar golf, pero no hay necesidad de eso. El enfoque de officialaimm es mucho más corto.

-7 gracias 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')

Pruébalo en línea.

— Simón
fuente
La pregunta lo permite [t]railing spaces, aunque su solución omite algunos espacios.
— Jonathan Frech
permitir espacios finales significa que no tengo que generarlos. ¿Es eso correcto? Ahorraría bytes en mi segundo enfoque. En el primero ya está hecho porque eliminé los espacios finales mientras guardaba mi archivo ...
— Simon
No estoy seguro, pero lo interpreté como permitir espacios adicionales, no permitir espacios faltantes.
— Jonathan Frech
x=='!'->x<'#'
— Jonathan Frech
if x.isdigit()->if"/"<x<"@"
— Jonathan Frech
3

Mathematica, 112 90 bytes

¡Gracias a Jonathan Frech por su ayuda para ahorrar 2 bytes!

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

Pruébalo en línea!(Matemáticas)

Por algunas razones, Mathics imprime los espacios iniciales en todas las líneas excepto la primera cuando imprime una cadena de varias líneas. También Mathics no es compatible con el operador .

Explicación:

  • {{Reverse@#,Reverse/@#},{" "+0#,#}} : Representa el reverso horizontal, reverso vertical, reemplazar todo por" " y transponer ( es el operador de transposición en Mathematica), correspondiente a diferentes formas de reflejar o rotar la imagen.
  • ~Flatten~{{1,3},{2,4}} : Acoplar en dimensiones particulares.
  • Nest[ ... ,{{"#"}},6] : Aplica la función dentro de {{"#"}} 6 veces.
  • ~Riffle~"<literal newline character>" : Riffle un carácter de nueva línea entre cada línea.
  • ""<> : Une todas las cuerdas juntas.
— usuario202729
fuente
Puede definir reemplazar Reversecon Ry definir R=Reverse;para guardar dos bytes.
— Jonathan Frech
2

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

¡Ahorró 14 bytes gracias a Kevin Cruijssen!
¡Ahorró 47 bytes gracias 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','#'));}

Pruébalo en línea!

Explicación

El formato de la salida se almacena dentro de una matriz de números de 64 bits con signo, que se ajusta perfectamente ya que cada línea tiene 64 caracteres de longitud. Los espacios vacíos están representados por 0y #está representado por 1.

Los números se convierten a su cadena binaria, los ceros se rellenan a la izquierda hasta que la cadena tenga 64 caracteres de ancho y luego los caracteres 0y 1se reemplazan con  y# .

El código se almacena dentro de una función lamba, más específicamente a System.Func<string>.

Algunas constantes en el long[]se acortan realizando algunos cambios de bits.

— Ian H.
fuente
¿No hay un espacio innecesario en long[] n=new[]?
— Jonathan Frech
@ JonathanFrech Ah, tienes razón, aparentemente se coló allí de alguna manera.
— Ian H.
1
Ahorraría 4 bytes al no tener que especificar el carácter de relleno.
— Neil
1
Bueno, si lno se necesita el seguimiento , probablemente pueda guardar aún más bytes .
— Jonathan Frech
1
Parece que el fondo de esto está molesto.
— Shaggy
2

Carbón de leña , 42 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Sería 25 bytes si esto funcionara:

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

Explicación:

#↓##

Genere manualmente la primera recursión, ya que no es posible rotar (1, 0.5). (Tal rotación solo tendría sentido si fuera 180 °).

ＦＥ⁵Ｘ²ι«

Recorre los primeros cinco poderes de 2 (1, 2, 4, 8, 16).

‖↑

Refleja el lienzo verticalmente. Esto completa el cuarto superior izquierdo del resultado.

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

Gire el lienzo 180 ° alrededor de un punto hasta la mitad del lado derecho. La copia termina en la posición correcta para el cuarto superior derecho del resultado.

⟲Ｃ

Gire el lienzo 90 ° alrededor de la esquina inferior derecha. La copia de la esquina superior derecha termina en la posición correcta para la esquina inferior derecha del resultado. La copia de la esquina superior izquierda es extraña.

Ｊ⁰±φＴ×⁴ι×⁴ι

Recorta el lienzo al tamaño que queramos. El recorte comienza en el cursor o en la parte superior izquierda del lienzo, el que esté en la parte inferior derecha. Por lo tanto, el cursor se envía a (0, -1000) para asegurarse de que no interfiere con el recorte.

— Neil
fuente
1

Perl 5 , 452 bytes

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

Paquetes de todos los datos en la cadena, en lugar de robar @ Neil 's respuesta correcta .

$_=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

Salida reversible de xxdun archivo 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

Pruébalo en línea!

— Dom Hastings
fuente
1

Jq 1.5 , 538 535 488 476 bytes

Esta es una representación directa. Todavía no he intentado ninguna codificación elegante. Reemplazado 0,0 pares con la función Z.

¡Gracias nuevamente a Jonathan Frech por ayudar 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("")

Número de letras

$ wc -c picture.jq
 476 picture.jq

Ejecución de la muestra

$ jq -Mnr -f picture.jq
                  #         #  #    #  # #####  ##    #         
                  ##        ####    #######  #   #    ##        
                ####        ##      ##    #  ### #######        
                #  #         #       #    ##### ### #  #        
                #  # ### #####   #####    #         #  #        
                ####### ###  #  ###  #    ##        ####        
                ##    #   #  ###  #  #######        ##          
                 #    ##  #####   ##### #  #         #          
                ##    #                   #         #  # #####  
                 #    ##                  ##        #######  #  
                 #######                ####        ##    #  ###
                ### #  #                #  #         #    ##### 
                    #  #                #  # ### #####    #     
                    ####                ####### ###  #    ##    
                    ##                  ##    #   #  #######    
                     #                   #    ##  ##### #  #    
    #  # #####  ##    #                   #                     
    #######  #   #    ##                  ##                    
    ##    #  ### #######                ####                    
     #    ##### ### #  #                #  #                    
 #####    #         #  #                #  # ###                
###  #    ##        ####                #######                 
  #  #######        ##                  ##    #                 
  ##### #  #         #                   #    ##                
          #         #  # #####   #####  ##    #                 
          ##        #######  #  ###  #   #    ##                
        ####        ##    #  ###  #  ### #######                
        #  #         #    #####   ##### ### #  #                
        #  # ### #####    #       #         #  #                
        ####### ###  #    ##      ##        ####                
        ##    #   #  #######    ####        ##                  
         #    ##  ##### #  #    #  #         #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        #  #                    
                                        #  # ###                
                                        #######                 
                                        ##    #                 
                                         #    ##                
                                 #####  ##    #                 
                                ###  #   #    ##                
                                  #  ### #######                
                                  ##### ### #  #                
                                  #         #  #                
                                  ##        ####                
                                ####        ##                  
                                #  #         #                  
                                  #         #  #    #  # #####  
                                  ##        ####    #######  #  
                                ####        ##      ##    #  ###
                                #  #         #       #    ##### 
                                #  # ### #####   #####    #     
                                ####### ###  #  ###  #    ##    
                                ##    #   #  ###  #  #######    
                                 #    ##  #####   ##### #  #    
                                ##    #                   #     
                                 #    ##                  ##    
                                 #######                ####    
                                ### #  #                #  #    
                                    #  #                #  # ###
                                    ####                ####### 
                                    ##                  ##    # 
                                     #                   #    ##
— jq170727
fuente
1
Tres espacios omitibles en B: recy 16) as $l|.
— Jonathan Frech
1
if.==0then" "else"#"end-> if.>0then"#"else" "end.
— Jonathan Frech
1

Python 2 , 174 164 154 bytes (basado en operaciones matriciales)

  • -10 bytes gracias a ngn.
  • -10 bytes gracias 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)

Pruébalo en línea!

— mdahmoune
fuente
import *-> import*; in s.tolist()->in s
— ngn
1
— 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))

Pruébalo en línea!

— totalmente humano
fuente
Ooh, ¿cuál es el problema ahora? Erm ... ¿Me estoy perdiendo algo?
— totalmente humano
1
No voté en contra, pero, para tu información, se puede comprimir mucho más usando esto .
Yo tampoco, pero esto no está en el espíritu de la pregunta. El patrón fue generado, presumiblemente, por un simple procedimiento recursivo. El desafío es determinar la regla, en cuyo punto su solución será extremadamente corta.
— Jonás
1
Convierte a base 36 para guardar ~ 50 bytes.
— Shaggy
2
Soy completamente consciente de que esta no es la solución óptima o la solución más corta o inteligente. Simplemente intenté usar un algoritmo y terminó siendo esto. Sin embargo, esto es perfectamente válido. solución y, por lo tanto, no merece votos negativos. Las soluciones aburridas no deberían votarse positivamente, pero tampoco deberían votarse negativamente.
— totalmente humano
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','#'));}

Pruébalo en línea!

— mi pronombre es monicareinstate
fuente
Hola, bienvenido a PPCG! Esto se ve casi exactamente igual a la respuesta de C # .NET de @IanH . Entonces, si tiene alguna mejora para él, haga un comentario en lugar de crear una nueva respuesta que sea casi exactamente la misma. En cuanto a su pregunta, puede usar <s>969</s>para tachar los bytes anteriores.
— Kevin Cruijssen
44
No tengo la reputación necesaria para comentar.
— mi pronombre es monicareinstate
Por favor, no intente eludir los requisitos de representación.
— Shaggy
2
¿Significa esto que en PPCG no puedo intentar ayudar a otros si mi reputación es demasiado baja?
— mi pronombre es monicareinstate
3
@Shaggy para ser justos, stackexchange es un poco duro para los recién llegados, no lo hagamos más difícil asumiendo malicia demasiado rápido
— 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;}

Pruébalo en línea!

Utiliza el mismo enfoque es esta otra respuesta .

— Charlie
fuente
0

K (ngn / k) , 32 31 27 bytes

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

Pruébalo en línea!

6{ }/ 6 veces hacer

+x transponer

|x revertir verticalmente

+|+x revertir horizontalmente

, concatenar verticalmente

,' concatenar horizontalmente

,[A;B]es el mismo que A,B. ayuda a evitar paréntesisA y alrededor de toda la expresión

""xuse los elementos de xcomo índices en la cadena vacía. la indexación fuera de los límites produce espacios, por lo que esta expresión devolverá una matriz de todos los espacios, del mismo tamaño quex

— ngn
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.