Adam West è deceduto e vorrei onorare la sua memoria qui su PPCG, anche se dubito che fosse a conoscenza della nostra esistenza. Mentre ci sono molte, molte cose diverse per cui quest'uomo è noto, nessuna è più importante del suo ruolo di batman originale . Ricorderò sempre il mio patrigno che ancora oggi guarda Batman e Robin della vecchia scuola. Questa sfida è di natura semplicistica, per nulla in linea con l'uomo complicato che era Adam West. Tuttavia, è il migliore che potrei inventare, poiché questa è l'immagine più iconica della carriera dell'uomo.

Volevo pubblicarlo prima, ma stavo aspettando che qualcuno inventasse qualcosa di meglio.

Output il seguente (con o senza spazi finali / newline):

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

Questo è code-golf , il conteggio dei byte più basso vincerà.

Gelatina , 44 byte

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

Provalo online!

Come funziona

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

Questo è un letterale numerico. Tutti i caratteri vengono sostituiti con i loro indici basati su 1 nella tabella codici di Jelly, il risultato viene interpretato come un intero base base 250 250, producendo

58616171447449697510361193418481584558895594063391402

Quindi, b25converti quel numero intero in base 25 e o99sostituisce 0 con 99 , cedendo

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$sostituisce il j ^esima base-25 cifre n con n copie di j , cedevole

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

Ora, ị⁾ *indicizza nella coppia di caratteri. L'indicizzazione è basata su 1 e modulare, quindi i numeri dispari vengono sostituiti con spazi, anche con asterischi. Questo cede

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

s25taglia il risultato a pezzi di lunghezza 25 . Se scriviamo ogni pezzo sulla sua stessa riga, otteniamo

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

L' atomo di rimbalzoŒB palindromizza ogni blocco aggiungendo una copia invertita senza il suo primo carattere, cedendo

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

Infine, Yintroduce gli attuali avanzamenti di riga.

Wordfuck , 5761 2686 byte

Immagino che usare il suo nome come codice sorgente dia ad Adam West qualche onore.

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!

Provalo online! _{(Brainfuck traspilato)}

Canto di Adam West _{(grazie @carusocomputing)}

Python, 530 529 528 524 byte

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)

JavaScript (ES6), 148 146 byte

_=>`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))

dimostrazione

let f =

_=>`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))

o.innerHTML = f()

<pre id=o></pre>

Python, 149 142 byte

7 byte salvati grazie 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])

MATL , 61 59 byte

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

Provalo online!

Come funziona

Questo utilizza le seguenti tecniche standard:

• Poiché l'immagine è orizzontalmente simmetrica , viene codificata solo la metà sinistra (compresa la colonna centrale).
• L'immagine viene linearizzata nell'ordine della colonna maggiore (verso il basso, quindi attraverso) e la sequenza risultante viene codificata per la lunghezza della corsa .
• Le lunghezze di esecuzione risultanti assumono valori da 1a 11, quindi la sequenza delle lunghezze della corsa viene compressa dalla conversione di base , da base 11a base 94(caratteri ASCII stampabili ad eccezione di virgolette singole, che necessitano di escape).

05AB1E , 47 byte

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

Provalo online!

vim, 168 156 byte

: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

Questo presuppone un ambiente Unix, per rev. Uso un abbastanza semplice (count, carattere) codifica, con N e A aggiungendo un e *rispettivamente, e B facendo la copia e retromarcia.

Nel file effettivo, le voci tra parentesi vengono sostituite dai byte letterali che rappresentano. <C-v>è 0x16, <ESC>è 0x1b ed <CR>è 0x0d.

Provalo online

Carbone , 69 54 52 48 byte

Ｅ⪪”｜↖y{{﹪yc›o”n↗πf>T≔Ｙ¿PN｜ωπＱβ” ⪫Ｅιק* μ⌕βλω‖Ｏ←

Provalo online! Il collegamento è alla versione dettagliata del codice. Edit: Grazie a @ ASCII sola, salvato 4 byte passando da un flag separato per ciclo su indici, 7 byte utilizzando il (non documentato?) ⸿Carattere, e altri 4 byte utilizzando la scrittura del rispettivo run-length encoding. Salvati altri 2 byte perché AtIndexaccetta automaticamente il modulo. Salvati altri 4 byte perché Mapcrea automaticamente una variabile indice. Spiegazione:

Print(Map(

L'esterno Maprestituisce un array. Printgestisce questo stampando ogni elemento sulla propria linea, evitando così di dover manualmente Joinloro \n.

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

La stringa codifica tutte le mezze file dell'output. Le lettere alternate si riferiscono al numero di se *spazi ( a=0viene utilizzato per gestire una riga che inizia con uno spazio). Lo spazio è una scelta conveniente del delimitatore, ma risulta anche comprimere bene (x comprime anche a 55 byte complessivi). Ogni riga viene elaborata separatamente. (Nota: il deverbosificatore non riesce a rimuovere il separatore tra una stringa compressa e non compressa, altrimenti il ​​codice avrebbe una ,leggibilità.)

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

Passa il cursore sopra ogni lettera, espandendoti al numero appropriato di *se spazi. La variabile mè l'indice del ciclo interno per questo Map, mentre lcontiene la lettera. Il risultato viene quindi Joininserito in una singola stringa utilizzando la stringa vuota predefinita w.

ReflectOverlap(:Left);

Una volta stampate tutte le righe, rifletti tutto a sinistra, sovrapponendo la colonna centrale.

Ho provato a gestire le nuove linee, gli spazi e le stelle in un ciclo, ma in realtà ci sono voluti altri due byte in questo modo:

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

Clojure, 833 437 byte

Quasi per definizione Clojure non vincerà mai alcun premio per brevità, ma mentre guardavo avanti OGNI SETTIMANA DARN per i DUE (contali - DUE ) episodi di Batman (stesso Bat-time, stesso Bat-channel!) È chiaro che c'è non c'è tempo da perdere!

Svelto, 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)))

Versione senza 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. Non importa quanto fossero ridicoli quegli spettacoli, quelli di noi che erano bambini ti salutano.

C (gcc) , 191 byte

#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];}

Provalo online!

Varie soluzioni, tutte che utilizzano la codifica Run Length, con una varietà di tecniche per codificare i dati RLE.

Python 3, 125 121 byte

Questa versione utilizza una bytesstringa per archiviare i dati.

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

Lascia che ssia una stringa di stelle o di spazi. Quindi la ncodifica byte sè data da

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

Python 2, 133 126 byte

Questa versione utilizza la codifica alfabetica. Il valore della lettera determina la lunghezza della stringa di output, il caso della lettera determina se è composto da spazi o stelle.

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

La mia originale soluzione Python 2 da 133 byte.

Questa versione utilizza stringhe di lunghezza zero in modo da poter alternare facilmente tra stringhe a stella e spaziali.

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

Solo per divertimento, ecco un one-liner che usa la codifica alfabetica.

Python 2, 148 byte

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

Per divertirti ancora di più, ecco uno schema nel gioco della vita di Conway che genera una versione del logo Batman. Ho dovuto raddoppiare ogni riga per mantenere le proporzioni più o meno le stesse della versione di testo. Questo modello non calcola davvero il logo (anche se è possibile eseguire calcoli in Life - è Turing-completo), lo riproduce solo dai loop di memoria, quindi immagino di non poterlo pubblicare come una voce di golf (anche se ho fatto crearlo usando uno script Python che ho scritto qualche anno fa). ;)

È codificato in un formato RLE abbastanza standard che può caricare la maggior parte dei motori Life. Se non si dispone di un programma GoL (ad esempio Golly ), è possibile visualizzarlo in azione online con questo motore Life online , che può importare file Life RLE. Ecco una versione PNG di quel modello di vita , alcuni programmi di vita (incluso Golly) possono caricare modelli di vita da PNG e vari altri formati di file immagine.

T-SQL, 283 276 222 byte

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

Implementazione della compressione GZIP della stringa batman originale, tramite il metodo pubblicato qui . Funziona solo in SQL 2016 e versioni successive.

Per le versioni precedenti di SQL, utilizzare il mio metodo precedente ( 276 byte ):

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

Fondamentalmente sto codificando manualmente una stringa gigante che determina cosa stampare dopo, usando il seguente metodo:

• #7 viene sostituito da +REPLICATE('*',7)
• $4 viene sostituito da +SPACE(4)
• & viene sostituito da +CHAR(13)

Dopo la sostituzione, appare l'intera stringa di caratteri 958 (con interruzioni di riga su ciascuna riga del simbolo 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)

Che viene eseguito come SQL dinamico, producendo il seguente output:

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

PHP , 137 byte

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

Provalo online!

PHP , 177 byte

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";

Provalo online!

PHP , 179 byte

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," *");

Provalo online!

Java, 296 214 byte

golfed:

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

Ungolfed:

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

Bubblegum , 75

xxd dump:

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

Provalo online .

Coffeescript (282 byte)

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,'*')

Spiegazione (usando ES6 semplice)

• Come altri citati, l'immagine è simmetrica, quindi possiamo eliminarne metà nella codifica
• Vengono inoltre ripetute più righe, quindi è possibile eseguire il lancio di ciascuna riga in una tabella di ricerca per salvare alcuni byte
• Convertiamo ogni semiretta in binario (usando 0 come spazio e 1 come *), e lo codifichiamo alla radice più alta in Javascript (36), risultando nell'array di codifica.
• La prima mappa prende ogni linea e la converte nella sua semiretta di output finale, riempiendola con 0s
• La seconda mappa concatena ogni linea con la sua metà invertita (lanciando la colonna centrale la seconda volta) e sostituisce gli 0 e 1 con spazi e * 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, '*'));
});

V , 102 byte

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

Provalo online!

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

Questo utilizza la codifica run-length per generare la seguente metà di batman:

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

E quindi inverte e duplica ogni riga.

Python 2 , 134 byte

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]

Provalo online!

La lunghezza di esecuzione codifica ogni riga dalla metà sinistra nella base 36. Si specchia per creare la linea intera, che viene stampata. Gli spazi iniziali non sono codificati; invece, la metà sinistra è imbottita per la lunghezza 25.

Mathematica 151 byte

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

Economico e poco creativo. La stringa proviene solo dal Compresscomando integrato utilizzato sull'output richiesto.

Aggiornare:

Penso di poter fare meglio con le funzioni ImportString\ ExportStringintegrate, ma non riesco a vedere e copiare ExportStringcorrettamente le stringhe risultanti . Per esempio

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

Non riesco a copiare l'output del testo dalla seconda riga per sostituire il %nella terza riga.

Bash ,407 322 byte

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 \ \*

Provalo online!

davvero orribile, ho bisogno di più tempo o aiuto per giocare a golf. genera l'output con 0 un 1 e alla fine traslittera. Codificato in hexa, digita la quantità di 0 e 1, avendo cura di rendere l'ultima cifra 0 per le prime due righe come un flag per l'output della colonna centrale. Usa la pressione di stampa per digitare o stringa per produrre 0 e 1. pensa che il %.$[0x${X}]Cmodello possa essere usato per golfarlo .

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 \ \*

Python 3, 232 197 183 164 byte

Ancora un'altra risposta Python. Nessun codice di compressione noioso però. Codice di compressione emozionante.

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

Sto usando il numero magico 35 perché in questo modo non si verificano caratteri di controllo, spazi o cose che dovrebbero essere evasi. Triste che devo elaborare gli spazi e le stelle separatamente, il che mi costa un po '.

Ungolfed:

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

PowerShell, 305 byte, 307 byte , 316 byte

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

Forse qualcun altro può aiutarmi ad accorciarlo ulteriormente, anche se non riesco a capire come, a meno che non ci sia un modo più conciso per definire un acceleratore di tipo personalizzato.

Modifica: versione abbreviata (grazie @root). La stringa codificata (codifica pre base64) può essere tagliata da otto posizioni dell'array e l'intervallo può essere così ridotto. Non sono sicuro del motivo per cui StreamWriter sta introducendo questo gonfio in MemoryStream. La comprensione del comportamento di base sarebbe apprezzata.

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

Ungolfed:

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

Codice di compressione:

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

Perl 5, 168 byte

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

Nota lo spazio finale alla fine della prima riga. Richiede -M5.01, che è gratuito.

Probabilmente si può giocare a golf un po 'di più.

LaTeX, 314 byte

\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 versione non golfata con spiegazioni:

\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

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

_=>{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;}

Provalo online!

Molti byte salvati dopo aver cambiato l'approccio. Prendendo il disegno come un array 2D, ho calcolato la codifica RLE per file:

{ 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 }

Gli indici dispari indicano s e gli indici pari indicano *s. Quindi ho sostituito ogni numero con una rappresentazione ASCII stampabile (prendendo il carattere '#' come 1), e ho ottenuto:

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

Quindi l'algoritmo calcola semplicemente il disegno decomprimendo questa stringa e aggiungendo nuove righe nei punti corretti.

PowerShell , 129 128 byte

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

Provalo online!

Ungolfed:

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

Produzione:

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

L'idea principale è molto semplice

The Emblem Coding:

1. Concatena tutte le linee dell'emblema su una stringa
2. Conta spazi e asterischi
3. Codifica la lunghezza di ogni segmento + 42 come carattere

Decodifica (questo script):

1. Ottieni il codice del carattere meno 42 per ciascun carattere dalla stringa di crittografia. Questa è una lunghezza di un segmento
2. Aggiunge il segmento, costituito da uno spazio o da un asterisco ripetuto Lengthvolte
3. Inserire una nuova riga ogni 49 simboli per dividere le linee

Alcune cose intelligenti

1. L'algoritmo di codifica suggerisce un simbolo con il codice 189 per visualizzare 3 linee di asterisco centrali. Questo simbolo non è ASCII. Funziona normalmente con ambienti moderni, ma ci sono ambiguità con la lunghezza della sceneggiatura. Quindi, sostituisco il simbolo non ascii ½in s*t(73 asterischi, 0 spazi, 74 asterischi).
2. Ho tagliato gli spazi giusti nell'ultima riga per salvare 1 byte. Mi dispiace, Batman.
3. Perché l'offset è 42? Volevo solo :) E la cripto-stringa sembra carina.

Extra: Scipt per la codifica dell'emblema

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

Mathematica, 271 byte

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

Braingolf , 590 580 579 577 428 423 312 byte

-111 byte perché LeakyNun è un dio del golf

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

Provalo online!

Braingolf non è bravo nell'arte ASCII, ma dannazione, ci ho provato.

In nessun caso sto spiegando questo clusterf ** k

/// , 171 166 byte

5 byte salvati perché stavo usando \r\nnel sorgente, lol.

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

Provalo online!

Compresso utilizzando successive iterazioni di sostituzione delle sottostringhe "più economiche" con un singolo carattere. Questo è quasi ottimale, anche se una delle due cose potrebbe essere il caso:

1. Potrei cavarmela usando alcuni meta-sostituti (ad es. Inserire dinamicamente regex)
2. È in qualche modo più vantaggioso sostituire prima le sottostringhe meno economiche (improbabili).