En honor de Adam West

90

Adam West falleció, y me gustaría honrar su memoria aquí en PPCG, aunque dudo que él supiera de nuestra existencia. Si bien hay muchas, muchas cosas diferentes por las que este hombre es conocido, ninguna es más prominente que su papel como el Batman original . Siempre recordaré a mi padrastro que sigue viendo a Batman y Robin de la vieja escuela hasta el día de hoy. Este desafío es de naturaleza simplista, no está en línea con el hombre complicado que era Adam West. Sin embargo, es lo mejor que se me ocurrió, ya que esta es la imagen más icónica de la carrera del hombre.


Quería publicar esto antes, pero estaba esperando que alguien inventara algo mejor.


Imprima lo siguiente (con o sin espacios finales / líneas nuevas):

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **

Este es el , ganará el conteo de bytes más bajo.

Urna de pulpo mágico
fuente
77
Debe prohibir cadenas codificadas. ¡Realmente no es divertido!
sergiol
77
Él no era el Batman original. Ese honor le pertenece a Lewis Wilson.
Shaggy
42
Cuando vi el título, pensé que el resultado iba a ser "na-na-na-na-na-na-na-na na-na-na-na-na-na-na-na".
D Krueger
3
@DKrueger: hazlo así en otra pregunta :)
Olivier Dulac
44
¿Por qué no comenzó esto el año pasado? ¡Carrie Fisher, Prince, David Bowie y Alan Rickman!
caird coinheringaahing

Respuestas:

47

Jalea , 44 bytes

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ߌÆ@Ƥ’b25o99Jx$ị⁾ *s25ŒBY

Pruébalo en línea!

Cómo funciona

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ߌÆ@Ƥ’

Este es un literal numérico. Todos los caracteres se reemplazan con sus índices basados ​​en 1 en la página de códigos de Jelly, el resultado se interpreta como un entero biyectivo base-250, produciendo

58616171447449697510361193418481584558895594063391402

Luego, b25convierta ese entero en base 25 y o99reemplace 0 con 99 , produciendo

11 1 20 4 10 1 8 4 12 4 3 6 12 4 2 9 9 5 1 99 1 24 2 5 7 11 4 4 7 3 4 3 7 2 7 1 6 2

Jx$sustituye a la j ésimo base-25 dígitos n con n copias de j , produciendo

1 1 1 1 1 1 1 1 1 1 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 7 7 7 7 7 7 7 7 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 11 11 11 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 14 14 14 14 15 15 16 16 16 16 16 16 16 16 16 17 17 17 17 17 17 17 17 17 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 23 23 24 24 24 24 24 25 25 25 25 25 25 25 26 26 26 26 26 26 26 26 26 26 26 27 27 27 27 28 28 28 28 29 29 29 29 29 29 29 30 30 30 31 31 31 31 32 32 32 33 33 33 33 33 33 33 34 34 35 35 35 35 35 35 35 36 37 37 37 37 37 37 38 38

Ahora, los ị⁾ *índices en el par de caracteres. La indexación se basa en 1 y es modular, por lo que los números impares se reemplazan por espacios, incluso los que tienen asteriscos. Esto produce

           *                    ****          *        ****            ****   ******            ****  *********         ***** *************************************************************************************************** ************************  *****       ***********    ****       ***    ***       **       *      **

s25corta el resultado en trozos de longitud 25 . Si escribimos cada fragmento en su propia línea, obtenemos

           *             
       ****          *   
     ****            ****
   ******            ****
  *********         *****
 ************************
*************************
*************************
*************************
 ************************
  *****       ***********
    ****       ***    ***
       **       *      **

El átomo de reboteŒB palindromiza cada fragmento agregando una copia invertida sin su primer carácter, produciendo

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       

Finalmente, Ypresenta los avances de línea reales.

Dennis
fuente
1
Y pensé que “QƤḣọḲ£¿ẆịµñẒṢƊ¬ƒỤ2ỴÐ,ịṁ&Ḅ<ḋsḳn.⁷ṛḃṡ⁾6bḋeṁ’ṃ⁾ *s25ŒBYera lo suficientemente corto en 53 bytes ...
Erik the Outgolfer
Intenté 14 cosas diferentes, y finalmente llegué a esto por prueba y error. No entendí lo que querías decir con "reemplaza 0 con 99" hasta que lo intenté yo mismo.
Magic Octopus Urn
156

Wordfuck , 5761 2686 bytes

Supongo que usar su nombre como código fuente le da a Adam West algo de honor.

adam west adam west adam_wes t_a dam_we st_a dam_ west adam west adam west adam west_ad am_west_a dam_we st ad am we st ad am we st ad am west_a dam_we st_a dam_ west_ada m_w est ada m_w est ada m_west_ adam west_a dam_west_ adam_we st_ ad am_west ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_w est_ adam west adam west adam west adam west adam we st_adam west_ad am we st ad am we st adam_w es t_ ad am west_ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am west_a da m_ we st adam_w es t_adam_ west_ad am we st ad am west_a da m_ we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am_wes t_ adam_we st_adam we st ad am_wes t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st adam_w es t_adam_ west_ad am we st_ada m_ we st ad am we st ad am west_ad am we st ad am we st ad am west_a da m_ we st ad am we st ad am_west ad am we st ad am we st ad am_wes t_ ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am_west ad am west_a da m_ we st ad am_west ad am we st ad am we st_ada m_ we st ad am we st ad am we st ad am we st ad am we st ad am west_ad am we st ad am we st adam_w es t_ ad am we st_ada m_ west_ad am_west ad am we st adam_w es t_ ad am west_ad am we st ad am we st adam_w es t_ ad am_west ad am we st adam_w es t_ ad am we st_adam we st ad am west_a da m_ we st_adam we st ad am we st ad am_wes t_ ad am we st_ada m_ west_ad am_west ad am we st ad am we st_ada m_ we st_adam we st ad am we st ad am_wes t_ adam_we st ad am we st ad am_wes t_ ad am west_ad am we st ad am we st_ada m_ west_ad am we st ad am we st adam_w es t!

Pruébalo en línea! (cerebro inflado)

Adam West cantando (gracias @carusocomputing)

Uriel
fuente
69
Este es terrible. Me encanta.
TheWanderer
25
Hmm Si. Bastante bien, pero creo que olvidaste un guión bajo en la línea 1.
Mateen Ulhaq
2
¿Hay alguna manera de que podamos probar esto?
Shaggy
44
@ ¡Bienvenido a PCCG! Realmente no competimos en este sitio, por supuesto, esta no es la solución ganadora, pero tiene un tema hilarante y desafiante, por lo que se vota para que más personas puedan disfrutarlo. ¡Esperando votar sus respuestas pronto!
Uriel
3
@Shaggy Pruébalo en línea! (STDERR)
Adám
67

Pitón, 530 529 528 524 bytes

import zlib as Holy
B=list("NNAAAnAAnnAnaAannnaaaaNaAAnNanAaAanNNaNNaNaanNNANanNNANaAnAaANANAAnAaANNnAanAaNnAaAANNAaAnNANAaaANNAanAaNaNNNAaNNanAAnNNnaaaNANANANnnaaaNaaAAAANaNaNaNAnNAAAAaaaaANAaNnnAaAaNAAaANNnaaNnNnaannaaAaananannNnAAAAAanAananANAnaAAnANAAaaaAaaanaaAAaanNAnanAAnnnANAnNAnnAnnnanaNNaaaNaNNaAAnNAaaANNNANAnAaaAaNaANnNNNaaAanaaaanaaaaaAaAaNnNnnaAnANaNnnANanNA")
A=dict(N='11',A='01',n='10',a='00')   
T=""
POP=BIFF=POW=OOF=lambda:A[B.pop()]
while B:T+=chr(int(POP()+POW()+BIFF()+OOF(),2))
print Holy.decompress(T)
rrauenza
fuente
55
Oh señor, no me he reído tanto en un rato. NAanANANaNANaNAANnAnaNANanaNA
Magic Octopus Urn
99
En el código de golf, se supone que debemos hacer que el byte cuente pequeño, pero su entrada es bastante considerable . ;)
PM 2Ring
34
En ocasiones, uno debe hacer sacrificios por el bien mayor.
rrauenza
1
Eso suena como algo que Batman diría. ;) Tengo que admitir que me parece un B.pop(0)poco molesto. ¿Por qué no invertir Bpara poder usar el mucho más eficiente (y más corto) B.pop()? El pop(0)tiene que mover todos los elementos restantes de la lista hacia abajo una ranura. Claro, sucede a velocidad C, pero sigue siendo menos eficiente que aparecer desde el final de la cadena.
PM 2Ring
55
Los alias de POP, BIFF, POW, OOFme hicieron escupir lo que estaba bebiendo en mi monitor. Gracias lol. +1.
rayryeng
21

JavaScript (ES6), 148146 bytes

_=>`n2zh2
f8l2b2l8
b8pep8
7cpepc
5ijiji
3yyq
0
0
0
3yyq
5afy8fa
98f69a96f8
f4f2d6d2f4`.replace(/./g,c=>'* '[(n=parseInt(c,36))&1].repeat(n/2||49))

Manifestación

Arnauld
fuente
12

Python, 149 142 bytes

7 bytes guardados gracias a @ PM2Ring

for l in"b1d 74a13 54c4 36c4 2995 1o 0p 0p 0p 1o 257b 447343 727162".split():x=''.join(s*int(k,36)for s,k in zip(' *'*3,l));print(x+x[-2::-1])
Uriel
fuente
Agradable. Puede eliminar 7 bytes:x=''.join(s*int(k,36)for s,k in zip(' *'*3,l))
PM 2Ring
Sin preocupaciones. Logré escribir una versión de Python aún más corta. ;)
PM 2Ring
1
@ PM2Ring tienes mi +1
Uriel
12

MATL , 61 59 bytes

' *'60:'*u9|K9j[~F9R,>ejc4Q,7;F\1l_=7sFR'F11:ZaY"13e)25ZvZ)

Pruébalo en línea!

Cómo funciona

Utiliza las siguientes técnicas estándar:

  • Ya que la imagen es simétrica horizontalmente , solo se codifica la mitad izquierda (incluida la columna central).
  • La imagen se linealiza en el orden de columnas principales (abajo, luego a través) y la secuencia resultante es codifica en longitud de ejecución .
  • Las longitudes de ejecución resultantes toman valores de 1a 11, por lo que la secuencia de longitudes de ejecución se comprime mediante conversión de base , de base 11a base 94(caracteres ASCII imprimibles excepto comillas simples, que necesitarían escapar).
Luis Mendo
fuente
1
Hay 60 ejecuciones en orden de columna mayor, pero solo 38 en fila mayor. ¿Eso ahorraría bytes?
Dennis
@Dennis El problema es que en ese caso las longitudes de ejecución son [1:12 20 24 99], lo que dificulta la compresión. Mi mejor intento es a 60 bytes
Luis Mendo
En lugar de construir el conjunto exacto, ¿ha intentado simplemente usar la base 25 y reemplazar 0 con 99 con, por ejemplo Y|,? No sé suficiente cajero automático MATL para probar si eso es realmente más corto ...
Dennis
@ Dennis Eso parece prometedor. Usando el conjunto [1:24 99], eliminé un byte . Si utilizo [0:24](base 25) No sé cómo convertir 0en 99en pocos bytes
Luis Mendo
1
Right Y|no funciona en MATL / Octave como lo hace en Jelly / Python. En este último, 0 or 99produce 99 ...
Dennis
7

05AB1E , 47 bytes

„ *19×S•«M;Ó8ζ?èYÑ?½¨/Ž´.δòÈÖ<•25вт<19ǝ×J13ä€û»

Pruébalo en línea!

Emigna
fuente
Portado algoritmo de Dennis ¿verdad?
Erik the Outgolfer
@EriktheOutgolfer: tomó prestado el replace 99 trickde él (ahorró 4 bytes en el camino directo). Sin embargo, todavía estoy buscando una mejor manera.
Emigna
-1 mediante el uso en .∞lugar de €û»(las réplicas se unen implícitamente a las listas en las nuevas líneas primero en la versión heredada, antes de aplicar la réplica). También he intentado usar ₂вen lugar de 25в, pero por desgracia el número entero comprimido es entonces de 1 byte más largo, así, por lo que no guarda nada: •2Ø°×á[1∊Œ)’˜Àå<тIÞ‡p5ÉQ•₂в.
Kevin Cruijssen
7

vim, 168156 bytes

:nm N a <C-v><ESC>
:nm A a*<C-v><ESC>
:nm B aY<C-v><ESC>yyp!!rev<C-v><CR>kJh4xo<C-v><ESC>
11NA13NB7N4A10NA3NB5N4A12N4AB3N6A12N4AB2N9A9N5ABN24AB25ABkyyppjN24AB2N5A7N11AB4N4A7N3A4N3AB7N2A7NA6N2ABdd

Esto supone un entorno Unix, para rev. Utilizo una codificación bastante sencilla (recuento, carácter), con N y A añadiendo un y *respectivamente, y B haciendo la copia y el reverso.

En el archivo real, las entradas entre corchetes se reemplazan por los bytes literales que representan. <C-v>es 0x16, <ESC>es 0x1b y<CR> es 0x0d.

Pruébalo en línea

Rayo
fuente
Creo que sería más rápido no molestarse en hacer las macros 'b' y 'c', y en su lugar reasignarlas directamente. :nm N a <C-v><esc>y:nm A a*<C-v><esc>
DJMcMayhem
@DJMcMayhem Así es. Por alguna razón, pensé que sería más difícil almacenarlo <C-v>en un archivo de lo que es, así que utilicé el método indirecto para poder probarlo { cat foo.vim; echo ':wq'; } | vim out.txt. No estoy seguro de por qué no se me ocurrió intentar <C-v><C-v>ayer.
Ray
¡Me alegra saber que lo tienes funcionando! Otra forma de probar las respuestas vim por conveniencia es ¡ Pruébelo en línea! , que realmente usa un esolang que escribí, pero de todos modos es (principalmente) compatible con versiones anteriores. La -vbandera te permite usar descripciones de teclas vim (me gusta <C-v>y otras cosas)
DJMcMayhem
@DJMcMayhem Muy bien. Gracias.
Ray
¿No puedes escribir en <NL>lugar de <NEWLINE>?
L3viathan
7

Carbón , 69 54 52 48 bytes

E⪪”|↖y{{﹪yc›o”n↗πf>T≔Y¿PN|ωπQβ” ⪫Eιק* μ⌕βλω‖O←

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: Gracias a @ ASCII-solamente, guardados 4 bytes por el cambio de una bandera independiente para bucle sobre índices, 7 bytes mediante el uso de la (indocumentado?) ⸿Carácter, y otras 4 bytes usando el alfabeto para la longitud de recorrido de codificación. Se guardaron otros 2 bytes porque AtIndexautomáticamente toma el módulo. Se guardaron otros 4 bytes porque Mapcrea automáticamente una variable de índice. Explicación:

Print(Map(

El exterior Mapdevuelve una matriz. Printmaneja esto imprimiendo cada elemento en su propia línea, evitando así tener que manualmente Joincon \n.

Split("anb adbke eme fjj y z z z y lhf dedhe cgbhc" " "),

La cadena codifica todas las medias filas de la salida. Las letras alternas se refieren al número de *sy espacios ( a=0se usa para manejar una fila que comienza con un espacio). El espacio es una opción conveniente del delimitador, pero también se comprime bien (x también se comprime a un total de 55 bytes). Cada fila se procesa por separado. (Nota: el desverbosificador no puede eliminar el separador entre una cadena comprimida y sin comprimir; de lo contrario, el código tendría que ser ,legible).

Join(Map(i, Times(AtIndex("* ", m), Find(b, l))), w)));

Pase sobre cada letra, expandiéndose al número apropiado de *so espacios. La variable mes el índice del bucle interno para esto Map, mientras lcontiene la letra. El resultado se Joinedita en una sola cadena usando la cadena vacía predefinida w.

ReflectOverlap(:Left);

Una vez que se imprimen todas las filas, refleje todo a la izquierda, superponiendo la columna central.

Traté de manejar las nuevas líneas, espacios y estrellas todo en un bucle, pero en realidad tomó dos bytes más de esta manera:

Print(Join(Map("anb adbke eme fjj y z z z y lhf dedhe cgbhc", Ternary(Equals(" ", i), "\n", Times(AtIndex("* ", k), Find(b, i)))), w));
ReflectOverlap(:Left);
Neil
fuente
1
+1 Realmente necesito aprender Carbón (también tiene Hexagony y Cubix). Tres de mis lenguajes de programación favoritos que veo aquí. Por cierto, supongo que ya estabas planeando hacerlo, pero ¿podrías agregar una explicación?
Kevin Cruijssen
@KevinCruijssen Hmm, supongo que incluso el código detallado necesita alguna aclaración ... ¿es suficiente?
Neil
Ah, no me había dado cuenta de que el TIO contenía la versión detallada tbh. Sin embargo, una explicación en la respuesta en sí nunca está de más, así que gracias por tomarse el tiempo para escribirla.
Kevin Cruijssen
Quiero aprender el carbón, pero necesita una página como 05AB1E que explique qué hace realmente cada carbón de la página de códigos sin tener que sumergirse en el código.
Magic Octopus Urn
2
@carusocomputing No está tan mal: además de las cadenas comprimidas, tienes cadenas normales (caracteres ASCII y pilcrow), números (dígitos superíndices), flechas (... flechas), comandos (generalmente letras mayúsculas de ancho completo) y operadores (todo de lo contrario), para que pueda buscarlos en la página correspondiente de la wiki.
Neil
6

Clojure, 833 437 bytes

Casi por definición, Clojure nunca ganará ningún premio por brevedad, pero mientras esperaba CADA SEMANA GANADA para los DOS (cuéntelos - DOS ) episodios de Batman (¡el mismo tiempo de Bat, el mismo canal de Bat!) Está claro que hay ¡no hay tiempo que perder!

¡Rápido Robin, al Bat-REPL!

(defn r[c n](clojure.string/join(repeat n c)))(defn pl[col](loop[i 0 c " "](print(r c (nth col i)))(if(< i (dec (count col)))(recur (inc i) (if (= c " ") "*" " "))(println))))(defn p[](loop[lines [[11 1 25 1][7 4 10 1 5 1 10 4][5 4 12 7 12 4][3 6 12 7 12 6][2 9 9 9 9 9][1 47][0 49][0 49][0 49][1 47][2 5 7 21 7 5][4 4 7 3 4 5 4 3 7 4][7 2 7 1 6 3 6 1 7 2]] i 0] (pl (nth lines i))(if (< i (dec (count lines)))(recur lines (inc i))nil)))

Versión sin golf:

(defn repstr [c n]
  (clojure.string/join (repeat n c)))

(defn print-bat-signal-line [col]
  (loop [i  0
         c  " "]
    (print (repstr c (nth col i)))
    (if (< i (dec (count col)))
      (recur (inc i) (if (= c " ") "*" " "))
      (println))))

(defn print-bat-signal []
  (loop [lines [[11 1 25 1]  ; spaces asterisks spaces asterisks
                [7 4 10 1 5 1 10 4]
                [5 4 12 7 12 4]
                [3 6 12 7 12 6]
                [2 9 9 9 9 9]
                [1 47]
                [0 49]
                [0 49]
                [0 49]
                [1 47]
                [2 5 7 21 7 5]
                [4 4 7 3 4 5 4 3 7 4]
                [7 2 7 1 6 3 6 1 7 2]]
        i      0]
    (print-bat-signal-line (nth lines i))
    (if (< i (dec (count lines)))
      (recur lines (inc i))
      nil)))

RIP Adam West. No importa cuán ridículos sean esos espectáculos, aquellos de nosotros que éramos niños los saludamos.

Bob Jarvis
fuente
Si bien no es golf, todavía le gana a la respuesta del gato je.
Magic Octopus Urn
Versión de golf añadida. Lo podría girar de lado para que parezca que está trepando una pared si pudiera. :-)
Bob Jarvis
6

C (gcc) , 191 bytes

#define x 16777215
char*b,*c,a[50];l[]={4096,122888,491535,2064399,4186143,x/2,x,x,x,x/2,4064255,983495,98435,0},*p=l;main(){for(;*p;p++,puts(a))for(b=c=a+23;b>=a;*p/=2)*b--=*c++=" *"[*p&1];}

Pruébalo en línea!

Hagen von Eitzen
fuente
6

Varias soluciones, todas utilizando Run Length Encoding, con una variedad de técnicas para codificar los datos RLE.

Python 3, 125 121 bytes

Esta versión usa una bytescadena para almacenar los datos.

s=''
for c in b'<)@4/:),0/>/,3>/*981(WYYY(W*14=./4-.-4+4)2+':s+=' *'[c%2]*(c//2-19);s*=len(s)<25or print(s+s[-2::-1])or 0

Dejar sser una cadena de estrellas o de espacios. Entonces la ncodificación de bytes sestá dada por

n = 38 + 2*len(s) + (s[0]=='*')

Python 2, 133126 bytes

Esta versión usa codificación alfabética. El valor de la letra determina la longitud de la cadena de salida, el caso de la letra determina si está compuesta de espacios o estrellas.

s=''
for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB':
 s+=' *'[c<'a']*(int(c,36)-9)
 if len(s)>24:print s+s[-2::-1];s='' 

Mi solución original de 133 bytes Python 2.

Esta versión utiliza cadenas de longitud cero para que pueda alternar fácilmente entre cadenas de estrellas y espaciales.

s=''
for c,n in zip(24*' *','b1d074a13054c436c429951o0p0p0p1o257b447343727162'):
 s+=c*int(n,36)
 if len(s)>24:print s+s[-2::-1];s=''

Solo por diversión, aquí hay una frase que usa la codificación alfabética.

Python 2, 148 bytes

print'\n'.join(''.join(s+s[-2::-1])for s in zip(*[iter(''.join(' *'[c<'a']*(int(c,36)-9)for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB'))]*25))

Para aún más diversión, aquí hay un patrón en Conway's Game of Life que genera una versión del logotipo de Batman. Tuve que duplicar cada línea para mantener la relación de aspecto aproximadamente igual a la versión de texto. Este patrón realmente no calcula el logotipo (aunque es posible hacer cálculos en Life, es Turing completo), simplemente lo reproduce desde los bucles de memoria, por lo que supongo que no puedo publicarlo como una entrada de golf de código (aunque me hice crearlo utilizando un script en Python que escribí hace unos años). ;)

Está codificado en un formato RLE bastante estándar que la mayoría de los motores Life pueden cargar. Si no tiene un programa GoL (por ejemplo, Golly ), puede verlo en acción en línea con este motor Life en línea , que puede importar archivos Life RLE. Aquí hay una versión PNG de ese patrón Life , algunos programas Life (incluido Golly) pueden cargar patrones Life desde PNG y varios otros formatos de archivo de imagen.

PM 2Ring
fuente
6

T-SQL, 283 276 222 bytes

SELECT CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAFNQgAMtBVxAi5cLxgICdB3IAkAAVYuqEsLHIgRWjV0KqxBIvZYWujQeEaAGLdIALxeJGuinhXSvQEMCPVSQAbIcJPJQReGSSHxU9WAeSppAqEMoBwCfudAGawIAAA=='as XML).value('.','varbinary(max)'))AS varchar(max))

Implementando la compresión GZIP de la cadena original de Batman, través del método publicado aquí . Esto funciona solo en SQL 2016 y versiones posteriores.

Para versiones anteriores de SQL, use mi método anterior ( 276 bytes ):

DECLARE @ CHAR(999)=REPLACE(REPLACE(REPLACE('PRINT SPACE(11#1$25#1&$7#4$10#1$5#1$10#4&$5#4$12#7$12#4&$3#6$12#7$12#6&$2#9$9#9$9#9&$1#47&#49&#49&#49&$1#47&$2#5$7#21$7#5&$4#4$7#3$4#5$4#3$7#5&$7#2$7#1$6#3$6#1$7#2)','#',')+REPLICATE(''*'','),'$',')+SPACE('),'&',')+CHAR(13')EXEC(@)

Básicamente estoy codificando manualmente una cadena gigante que determina qué imprimir a continuación, usando el siguiente método:

  • #7 es reemplazado por +REPLICATE('*',7)
  • $4 es reemplazado por +SPACE(4)
  • & es reemplazado por +CHAR(13)

Después del reemplazo, se ve la cadena completa de 958 caracteres (con saltos de línea en cada línea en el símbolo de Batman:

PRINT 
SPACE(11)+REPLICATE('*',1)+SPACE(25)+REPLICATE('*',1)+CHAR(13)
+SPACE(7)+REPLICATE('*',4)+SPACE(10)+REPLICATE('*',1)+SPACE(5)+REPLICATE('*',1)+SPACE(10)+REPLICATE('*',4)+CHAR(13)
+SPACE(5)+REPLICATE('*',4)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',4)+CHAR(13)
+SPACE(3)+REPLICATE('*',6)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',6)+CHAR(13)
+SPACE(2)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+SPACE(2)+REPLICATE('*',5)+SPACE(7)+REPLICATE('*',21)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(4)+REPLICATE('*',4)+SPACE(7)+REPLICATE('*',3)+SPACE(4)+REPLICATE('*',5)+SPACE(4)+REPLICATE('*',3)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(7)+REPLICATE('*',2)+SPACE(7)+REPLICATE('*',1)+SPACE(6)+REPLICATE('*',3)+SPACE(6)+REPLICATE('*',1)+SPACE(7)+REPLICATE('*',2)

Que se ejecuta como SQL dinámico, produciendo el siguiente resultado:

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       *****
       **       *      ***      *       **
BradC
fuente
5

PHP , 137 bytes

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

Pruébalo en línea!

PHP , 177 bytes

foreach(["9zojk",a2878,aa4nb,b7u9z,chbf3,eze2n,jz6rj,jz6rj,jz6rj,eze2n,cepdr,ako8z,a1pc1]as$v)echo$t=strtr(substr(base_convert($v,36,2),1),10,"* "),"* "[$k++<2],strrev($t),"\n";

Pruébalo en línea!

PHP , 179 bytes

for(;$o=ord(kAlgDjAbeDlCcFlCbIiDaWXXXaWbEgJdDgCdBgBgAfA[$i++]);($x+=$s)%24?:print$r.("* "[$k++<2]).strrev($r)."\n".$r="")$r.=strtr(str_repeat($b=+($o>96),$s=$o-64-$b*32),10," *");

Pruébalo en línea!

Jörg Hülsermann
fuente
Su primer ejemplo necesita citas
Steven Penny
2
@StevenPenny No, no lo hace. ¿Ha comprobado el enlace probarlo en línea ?
ovs
1
@StevenPenny En este caso, PHP utiliza la conversión de constantes no existentes a las cadenas. Solo lanzo un error de aviso que está permitido en Codegolf. Y el "=" que falta al final de la cadena codificada en base64 se agregará automáticamente
Jörg Hülsermann
4

Java, 296 214 bytes

Golfizado:

()->{String r="";boolean b=1<0;for(int a:";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()){for(int i=0;i<a-48;++i)r+=(b?'*':' ');if(a<49)r+='\n';else b=!b;}return r;}

Sin golf:

public class InHonorOfAdamWest {

  public static void main(String[] args) {
    System.out.println(f(() -> {
      String r = "";
      boolean b = 1 < 0;
      for (int a : ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()) {
        for (int i = 0; i < a - 48; ++i) {
          r += (b ? '*' : ' ');
        }
        if (a < 49) {
          r += '\n';
        }
        else {
          b = !b;
        }
      }
      return r;
    }));
  }

  private static String f(java.util.function.Supplier<String> f) {
    return f.get();
  }
}

fuente
Podría usarse ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172"para datos, y for(char a:x){a=(int)a-48; [...]básicamente está sumando 48 a cada uno de los números y convirtiéndolos a su equivalente ascii char. Creo que esto te ahorrará 70-80 bytes. También creo que codificar los datos en la lamba también reducirá los bytes.
Magic Octopus Urn
También boolean b=false;puede ser boolean b=1<0, o incluso mejor, podría usar un inty también combinar la declaración para ien la misma línea;).
Magic Octopus Urn
1
@carusocomputing gracias, no pensé en empacarlo en una cadena. El suyo tenía un valor Unicode malo, tuve que regenerarlo y la salida se muestra correctamente ahora.
Como no lo usa ien su bucle for, creo que puede usarlo for(int i=0;i++<a-48;)como for-head.
Roman Gräf
3

Chicle , 75

volcado xxd:

00000000: cd92 b501 8050 1043 fb4c 91fa efbf 1f0e  .....P.C.L......
00000010: 2f87 d371 5814 37d3 7c35 4d2b 1826 64f6  /..qX.7.|5M+.&d.
00000020: d8aa 419c 2a11 3e75 ce25 6d1e ee9d 22e0  ..A.*.>u.%m...".
00000030: bb11 f04f 0d7f 2e38 dfc8 6926 3dad 0871  ...O...8..i&=..q
00000040: f316 1071 6db8 fc07 a408 f7              ...qm......

Pruébalo en línea .

Trauma digital
fuente
3

Coffeescript (282 Bytes)

t=['6bk','59mw','l2j3','2ghsf','4zg2n','9zldr','jz6rj','4u7zz','165qf','47wj']
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d)->parseInt(t[d], 36).toString(2).padStart 25, '0').forEach (d)->console.log (d+d.split('').reverse().join('').substring(1)).replace(/0/g, ' ').replace(/1/g,'*')

Explicación (usando plain-ol ES6)

  • Al igual que otros mencionados, la imagen es simétrica, por lo que podemos desechar la mitad en la codificación
  • También se repiten varias líneas, por lo que podemos lanzar cada línea en una tabla de búsqueda para guardar algunos bytes
  • Convertimos cada media línea en binario (usando 0 como espacio y 1 como *), y lo codificamos en ese radix más alto en Javascript (36), lo que resulta en la matriz de codificación.
  • El primer mapa toma cada línea y la convierte de nuevo en su media línea de salida final, rellenándola con 0s
  • El segundo mapa concatena cada línea con su mitad invertida (tirando la columna del medio la segunda vez), y reemplaza los 0 y 1 con espacios y * s

var t = [
    '6bk',
    '59mw',
    'l2j3',
    '2ghsf',
    '4zg2n',
    '9zldr',
    'jz6rj',
    '4u7zz',
    '165qf',
    '47wj'
];
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d) => {
    return parseInt(t[d], 36).toString(2).padStart(25, '0');
})
.forEach((d) => {
    console.log((d + d.split('').reverse().join('').substring(1))
        .replace(/0/g, ' ')
        .replace(/1/g, '*'));
});

cjbrooks12
fuente
Buena respuesta! Bienvenido al sitio! :)
DJMcMayhem
2

V , 102 bytes

i±³ *±± 
³ *± ´*· 
´*±² ´*µ 
´*±² ¶*³ 
µ*¹ ¹*  
²´* Ä3o²µ*jo±±*· µ*  
³*´ ³*· ´*´ 
**¶ *· **· Îæ$vp

Pruébalo en línea!

Hexdump:

00000000: 69b1 b320 2ab1 b120 0ab3 202a b120 b42a  i.. *.. .. *. .*
00000010: b720 0ab4 2ab1 b220 b42a b520 0ab4 2ab1  . ..*.. .*. ..*.
00000020: b220 b62a b320 0ab5 2ab9 20b9 2a20 200a  . .*. ..*. .*  .
00000030: b2b4 2a20 1bc4 336f b2b5 2a1b 6a6f b1b1  ..* ..3o..*.jo..
00000040: 2ab7 20b5 2a20 200a b32a b420 b32a b720  *. .*  ..*. .*. 
00000050: b42a b420 0a2a 2ab6 202a b720 2a2a b720  .*. .**. *. **. 
00000060: 1bce e624 7670                           ...$vp

Utiliza la codificación de longitud de ejecución para generar la siguiente mitad de Batman:

             *           
   *          ****       
****            ****     
****            ******   
*****         *********  
************************ 
*************************
*************************
*************************
************************ 
***********       *****  
***    ***       ****    
**      *       **      

Y luego invierte y duplica cada línea.

DJMcMayhem
fuente
2

Python 2 , 134 bytes

for w in'1D 4A13 4C4 6C4 995 O P P P O 57B 47343 27162'.split():r=''.join(c*int(k,36)for c,k in zip(3*'* ',w));print'%25s'%r+r[-2::-1]

Pruébalo en línea!

La longitud de ejecución codifica cada línea desde la mitad izquierda en la base 36. La duplica para formar la línea completa, que se imprime. Los espacios iniciales no están codificados; en cambio, la mitad izquierda está acolchada hasta la longitud 25.

xnor
fuente
Me gustaría poder utilizar ese truco relleno en mi versión ...
PM 2Ring
2

Mathematica 151 Bytes

Uncompress@"1:eJxTTMoPCm5iYmBQQAAtBVxAK8bA0AjGBgJ0PcgCQABXjaoWwsciBFWPXRKrEESHlha6AjwiYC1apAGQHhK10FsTOV6Chgp6CCEDZDlYdKKKw6WR+OjxD+KiJBSEQoR6AC49ZiI="

Barato y poco creativo. La cadena es solo del Compresscomando incorporado utilizado en la salida requerida.

Actualizar:

Creo que puedo hacerlo mejor con las funciones incorporadas ImportString\ ExportStringpero no puedo ver para copiar y pegar las cadenas resultantes ExportStringcorrectamente. P.ej

b = "           *                         *\n       ****          *     *          ****\n     ****            *******            ****\n   ******            *******            ******\n  *********         *********         *********\n ***********************************************\n*************************************************\n*************************************************\n*************************************************\n ***********************************************\n  *****       *********************       *****\n    ****       ***    *****    ***       ****\n       **       *      ***      *       **"
ExportString[b,"GZIP"]
ImportString[%,"GZIP"]

Parece que no puedo copiar la salida de texto de la segunda línea para reemplazar la %de la tercera línea.

Ian Miller
fuente
2

Golpetazo ,407 322 bytes

w=`yes 1|head -30|tr -d '\n'`
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
x=`printf "%.$[0x${a}]d%.$[0x${b}]s%.$[0x${c}]d%.$[0x${d}]s%.$[0x${e}]d%.$[0x${f}]s" 0 $w 0 $w 0 $w`
echo -n $x$[f<1?0:1]
rev<<<$x
}|tr 01 \ \*

Pruébalo en línea!

realmente horrible, necesita más tiempo o ayuda para jugar al golf. genera la salida con 0 un 1 y translitera al final. Codificado en dígitos hexadecimales la cantidad de 0 y 1, teniendo cuidado de hacer el último dígito 0 para las dos primeras filas como un indicador para la columna central de salida. Utiliza printf pressision ya sea para dígitos o cadenas para generar 0 y 1. cree que el %.$[0x${X}]Cpatrón podría usarse para jugar golf.

w=`yes 1|head -30|tr -d '\n'`  # w=111111111111111111111111111111   
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
printf "%.$[0x${a}]d
%.$[0x${b}]s
%.$[0x${c}]d
%.$[0x${d}]s
%.$[0x${e}]d
%.$[0x${f}]s" 0 $w 0 $w 0 $w
echo -n $[f<1?0:1]
printf "%.$[0x${f}]s
%.$[0x${e}]d
%.$[0x${d}]s
%.$[0x${c}]d
%.$[0x${b}]s
%.$[0x${a}]d\n" $w 0 $w 0 $w 0 
}|tr 01 \ \*
marcom
fuente
2

Pitón 3, 232 197 183 164 bytes

Otra respuesta más de Python. Sin embargo, no hay código de compresión aburrido. Emocionante código de compresión.

for s in map(lambda x:x+x[-2::-1],b".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&".split()):print(*((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)))

Estoy usando el número mágico 35 porque de esa manera, no ocurren caracteres de control, espacios o cosas que tendrían que escapar. Es triste que tenga que procesar los espacios y las estrellas por separado, eso me cuesta un poco.

Sin golf:

for s in map(lambda x:x+x[-2::-1],   # map a list to the list and itself reversed,
                                     # minus the last (center) element
# magic string:
".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&"
.split()):                           # split on whitespace to divide into lines
 print(*(                            # unpack generator expression
(ord(s[i])-35)*" "                   # convert character to int, -25, times space
+(ord(s[i+1])-35)*"*"                # same thing with "*"
for i in range(0,len(s)-1,2)))       # for every pair in the list
L3viatán
fuente
Ese método de codificación es mejor que la base 36. Espero que no te importe que lo haya adaptado para mi última solución. ;) Hay algunas cosas que puede hacer para reducir su conteo de bytes. 1 Puede guardar un byte poniendo la printllamada en la misma línea que el for. 2 Si usa una bytescadena, puede deshacerse de esas ordllamadas. 3 Puede reemplazarlo rangecomprimiendo un par de iteradores. Aquí hay un generador que combina ambas esas ideas: ((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)). Esos cambios reducirán su cuenta a 164.
PM 2Ring
@ PM2Ring No me importa en absoluto. Te vas de vacaciones por unas semanas, así que no dudes en editar tus cambios.
L3viathan
Oh ok Pero te dejaré hacer la nueva versión sin golf.
PM 2Ring
@ PM2Ring en un autobús ya, así que solo espero que alguien más lo apruebe
L3viathan
2

PowerShell, 305 bytes, 307 bytes , 316 bytes

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Tal vez alguien más pueda ayudarme a acortarlo aún más, aunque no puedo entender cómo a menos que haya una forma más concisa de definir un acelerador de tipo personalizado.

Editar: versión acortada (gracias @root). La cadena codificada (codificación previa a base64) puede recortarse en ocho posiciones de matriz y, por lo tanto, el rango puede reducirse. No estoy seguro de por qué StreamWriter está introduciendo esta hinchazón en MemoryStream. Se apreciaría una idea del comportamiento subyacente.

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg')),0,94),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Sin golf:

#Read decoded stream 
[IO.StreamReader]::new(
    (
        #Reverse GZip encoding
        [IO.Compression.GZipStream]::new(
            #Load GZip encoded string into a memory stream
            [IO.MemoryStream]::new(
                (
                    # Convert Base64 back to GZip encoded string
                    [Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')
                ),
                #Start of range
                0,
                #End of range. Stick the Memory Stream into a variable and use .Length here for non golf code
                102
            ),
            #Specify that we are decompressing
            [IO.Compression.CompressionMode]::Decompress
        )
    )
).ReadToEnd()

Código de compresión:

$s = '           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **'

#Create Memory Stream
$ms = [IO.MemoryStream]::new()
#Initialize a stream
$sw = [IO.StreamWriter]::new(
    #Create GZip Compression stream
    [IO.Compression.GZipStream]::new(
        #Reference Memory Stream
        $ms,
        #Set mode to compress
        [IO.Compression.CompressionMode]::Compress
    )
)
#Write input into stream
$sw.Write($s)
#Close the stream
$sw.Close()

#Convert Array to Base64 string
[Convert]::ToBase64String(
    #Retrieve Memory Stream as an array
    ($ms.ToArray() | select -SkipLast 8)
)
Chirishman
fuente
1
¿Por qué 102? 99 funciona de la misma,[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()
la raíz
@root sí, supongo, pero no estoy seguro de por qué funciona. En realidad, puede disminuirlo de ocho a 94 y soltar los últimos ocho caracteres de la cadena de entrada codificada. Me cuesta entender por qué esto funciona y no quiero agregarlo a mi respuesta hasta que lo haga. ¿Mi función de compresión agrega erróneamente algún relleno extraño de alguna manera?
Chirishman
1
Desde su código de compresión, los dos últimos valores $ms.ToArray()son ambos 0. ¿Son necesarios?
raíz
No. Y al probar diferentes cadenas de entrada, parece coherente que sean exactamente dos posiciones de matriz innecesarias al final. Agregaré una cláusula para omitir los dos últimos en mi script de compresión. Todavía desearía saber por qué el escritor de secuencias estaba agregando los nulos al final
Chirishman
1
Tienes razón, es más que solo los 2 caracteres de cola, son 8. Las últimas 8 posiciones en la matriz ('225','193','82','192','106','2','0','0'), se pueden eliminar para crear H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg==. No entiendo de dónde vienen.
raíz
2

Perl 5, 168 bytes

$_="11 *25 
7 4*10 *5 *10 4
5 4*12 7*12 4
3 6*12 7*12 6
2 9*9 9*9 9
 47
49
49
49
 47
  5*7 21*7 5
4 4*7 3*4 5*4 3*7 4
7 **7 *6 3*6 *7 *";s/$/*/gm;say s/\d+(.)/$1x$&/ger

Tenga en cuenta el espacio final al final de solo la primera línea. Requiere -M5.01, que es gratis.

Probablemente se pueda jugar al golf un poco más.

msh210
fuente
2

LaTeX, 314 bytes

\documentclass{book}\begin{document}\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}\catcode`.13\catcode`!13\catcode`-13\def!#1{\r*{`#1}}\def-#1{\r~{`#1}}\let.\par\tt-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B\enddocument

La versión no golfista con explicaciones:

\documentclass{book}
\begin{document}
% Macro for repeating #1 (#2-64) times
\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}
% Prepare '.', '!' and '-' for usage as macro names
\catcode`.13\catcode`!13\catcode`-13
% The ASCII code of #1 (a character) is used as the number of how often '*' will be printed with \r
\def!#1{\r*{`#1}}
% Same as ! but for spaces
\def-#1{\r~{`#1}}
% . becomes a line break
\let.\par
% Set monospace font
\tt
% And finally print the whole thing
-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.
!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B
\enddocument
siracusa
fuente
2

C # (.NET Core) , 342 333 328 185 175 bytes

_=>{var r="";for(int i=0,j,k=0;i<63;i++)for(j=0;j++<"-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)"[i]-34;){r+=i%2<1?' ':'*';if(++k%49<1)r+='\n';}return r;}

Pruébalo en línea!

Muchos bytes guardados después de cambiar el enfoque. Tomando el dibujo como una matriz 2D, calculé la codificación RLE por archivos:

{ 11, 1, 25, 1, 18, 4, 10, 1, 5, 1, 10, 4, 12, 4, 12, 7, 12, 4, 8, 6, 12, 7, 12, 6, 5, 9, 9, 9, 9, 9, 3, 47, 1, 147, 1, 47, 3, 5, 7, 21, 7, 5, 6, 4, 7, 3, 4, 5, 4, 3, 7, 4, 11, 2, 7, 1, 6, 3, 6, 1, 7, 2, 7 }

Los índices impares representan sy los índices pares representan *s. Luego sustituí cada número por una representación ASCII imprimible (tomando el carácter '#' como 1), y obtuve:

-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)

Entonces, el algoritmo simplemente calcula el dibujo descomprimiendo esta cadena y agregando nuevas líneas en los lugares adecuados.

Charlie
fuente
1
No es necesario establecer luna variable, simplemente úsela directamente en el bucle. .ToString(i, 2)-> .ToString(i,2)es decir, eliminar el espacio en blanco.
TheLethalCoder
¿Se pueden guardar bytes con representaciones decimales o científicas ( 1e10) para esos números? Este desafío es realmente útil aquí.
TheLethalCoder
@TheLethalCoder no. Acabo de marcar (desafío impresionante, por cierto) y ya uso la representación más pequeña, así que no tuve suerte. Incluso intenté encontrar el máximo divisor común entre ellos para ver si podía dividir los números entre una constante, pero obviamente es 1.
Charlie
2

PowerShell , 129 128 bytes

-join('5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% t*y|%{(' ','*')[$i++%2]*($_-42)})-split'(.{49})'-ne''

Pruébalo en línea!

Sin golf:

-join(
    '5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% toCharArray|%{
        (' ','*')[$i++%2]*($_-42)
    }
)-split'(.{49})'-ne''

Salida:

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **

La idea principal es muy simple.

La codificación del emblema:

  1. Concatenar todas las líneas de emblema en una cadena
  2. Cuenta espacios y asteriscos
  3. Codifique la longitud de cada segmento + 42 como un carácter

Decodificación (este script):

  1. Obtenga el código del char menos 42 para cada char del cripto-string. Esta es una longitud de un segmento
  2. Agregar segmento, que consiste en un espacio o asterisco repetido Length veces
  3. Inserte una nueva línea cada 49 símbolos para dividir líneas

Algunas cosas inteligentes

  1. El algoritmo de codificación sugiere un símbolo con el código 189 para mostrar 3 líneas de asterisco en el medio. Este símbolo no es ASCII. Funciona normalmente con entornos modernos, pero existen ambigüedades con la longitud del script. Por lo tanto, puedo reemplazar la no-ascii-símbolo ½a s*t(73 asteriscos, 0, 74 espacios asteriscos).
  2. Corté los espacios correctos en la última línea para ahorrar 1 byte. Lo siento, Batman.
  3. ¿Por qué el desplazamiento es 42? Solo quería :) Y cripto-string se ve bien.

Extra: Scipt para codificar el emblema

(@"
           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       
"@ -replace"`n"-split'( +|\*+)'-ne''|%{[char]($_.Length+42)})-join''
mazzy
fuente
1

Mathematica, 271 bytes

T=Table;f[x_]:=""<>T["*",x];m={f@49};n={f@47};g[y_]:=""<>T[" ",y];k[a_,b_,c_,d_,e_]:={(s=f@a<>g@b<>f@c<>g@d<>f@e)<>StringDrop[StringReverse@s,1]};Grid@{k[1,13,0,0,0],k[4,10,1,3,0],k[4,12,0,0,4],k[6,12,0,0,4],k[9,9,0,0,5],n,m,m,m,n,k[5,7,0,0,11],k[4,7,3,4,3],k[2,7,1,6,2]}
J42161217
fuente
1

Braingolf , 590 580 579 577 428 423 312 bytes

-111 bytes porque LeakyNun es un dios del golf

14#
46*6394943[92+.6,5][8]#.[# ]#*[# ]#*#
[# ][#*][# ]#*[# ]#*[# ]#*...#
[# ][#*][# ][#*][# ]#*...#
# ..[#*][# ][#*][# ][#*]#
# .[#*][# ][#*][# ][#*]#
# [#*]#
&@#0[#*]#
!&@!&@# &@#.[#*]"
  "&@4645*643646366556[#*][# ][#*][# ][#*]"
    "[#*][# ]#*..# ...[#*]# ...#*..[# ][#*]#
[# ]#*.[# ]#*[# ]#*..[# ]#*[# ]#*.&@

Pruébalo en línea!

Braingolf no es bueno en el arte ASCII, pero maldita sea, lo intenté.

De ninguna manera estoy explicando este grupo ** k

Skidsdev
fuente
1

/// , 171 166 bytes

5 bytes guardados porque estaba usando \r\n en la fuente, lol.

/-/  //,/!!//'/**//&/*"//%/--//#/,,,,,!*//"/%-//!/''/"% &""" *
" !"%*% &%!
% !""!'&"!
- !*&"!'&"!'
-,&- ,&- ,*
 #'
!#
!#
!#
 #'
-!& ,,!& !*
%!" '*%!*%'& !
" *& &'&& '

Pruébalo en línea!

Comprimido mediante el uso de sucesivas iteraciones de reemplazar las subcadenas "más económicas" con un solo carácter. Esto es casi óptimo, aunque una de dos cosas podría ser el caso:

  1. Podría evitar el uso de algunos reemplazos meta (por ejemplo, insertar expresiones regulares dinámicamente)
  2. De alguna manera, es más beneficioso reemplazar primero las subcadenas menos económicas (poco probable).
Conor O'Brien
fuente