Adam West ist verstorben, und ich möchte seine Erinnerung hier auf PPCG ehren, obwohl ich bezweifle, dass er von unserer Existenz wusste. Während es viele, viele verschiedene Dinge gibt, für die dieser Mann bekannt ist, ist keines wichtiger als seine Rolle als der ursprüngliche Batman. Ich werde mich immer daran erinnern, dass mein Stiefvater den alten Batman und Robin bis heute beobachtet hat. Diese Herausforderung ist von Natur aus simpel und entspricht in keiner Weise dem komplizierten Mann, der Adam West war. Es ist jedoch das Beste, was ich mir einfallen lassen konnte, da dies das kultigste Bild der Karriere des Mannes ist.

Ich wollte das früher posten, aber ich habe darauf gewartet, dass sich jemand etwas Besseres einfallen lässt.

Geben Sie Folgendes aus (mit oder ohne nachfolgende Leerzeichen / Zeilenumbrüche):

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

Dies ist Code-Golf , die niedrigste Byte-Anzahl gewinnt.

Jelly , 44 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Dies ist ein numerisches Literal. Alle Zeichen werden in Jellys Codepage durch ihre 1-basierten Indizes ersetzt. Das Ergebnis wird als bijektive Basis-250-Ganzzahl interpretiert und ergibt

58616171447449697510361193418481584558895594063391402

Als nächstes b25konvertieren Sie diese ganze Zahl zur Basis 25 und o99ersetzen 0 durch 99 , was ergibt

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$Ersetzt die j- ^ten Basis-25-Stellen n durch n Kopien von j , was ergibt

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

Nun ị⁾ *Indizes in das Zeichenpaar. Die Indizierung basiert auf 1 und ist modular aufgebaut, sodass ungerade Zahlen durch Leerzeichen und gerade durch Sternchen ersetzt werden. Dies ergibt

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

s25Zerhackt das Ergebnis in Stücke mit einer Länge von 25 . Wenn wir jeden Block in eine eigene Zeile schreiben, erhalten wir

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

Das Bounce- Atom ŒBpalindromisiert jeden Chunk, indem es eine umgedrehte Kopie ohne das erste Zeichen anfügt

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

Zum Schluss werden Ydie eigentlichen Zeilenvorschübe vorgestellt.

Wordfuck , 5761 2686 Bytes

Ich denke, die Verwendung seines Namens als Quellcode bringt Adam West eine Ehre ein.

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!

Probieren Sie es online! _{(transpilierter Brainfuck)}

Adam West singt _{(danke @carusocomputing)}

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

JavaScript (ES6), 148 146 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))

Demo

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 Bytes

7 Bytes gespart dank @ 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 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Hierbei werden die folgenden Standardtechniken verwendet:

• Da das Bild horizontal symmetrisch ist , wird nur die linke Hälfte (einschließlich der mittleren Spalte) codiert.
• Das Bild wird in der Hauptreihenfolge der Spalten (abwärts, dann quer) linearisiert und die resultierende Sequenz wird lauflängencodiert .
• Die resultierenden Lauflängen nehmen Werte von 1bis an 11, sodass die Folge der Lauflängen durch Basiskonvertierung von Basis 11zu Basis komprimiert wird94 (druckbare ASCII-Zeichen mit Ausnahme von einfachen Anführungszeichen, die maskiert werden müssten).

05AB1E , 47 Bytes

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

Probieren Sie es online!

vim, 168 156 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

Dies setzt eine Unix-Umgebung voraus, z rev. Ich verwende eine ziemlich einfache Codierung (Anzahl, Zeichen), wobei N und A jeweils a und anhängen *und B die Kopie und den Rückwärtsgang ausführen.

In der eigentlichen Datei werden die Einträge in Klammern durch die Literalbytes ersetzt, die sie darstellen. <C-v>ist 0x16, <ESC>ist 0x1b und <CR>ist 0x0d.

Probieren Sie es online aus

Charcoal , 69 54 52 48 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: Dank @ ASCII-only werden 4 Bytes durch Umschalten von einem separaten Flag auf das Durchlaufen von Indizes, 7 Bytes durch Verwenden des ⸿Zeichens (undokumentiert?) Und weitere 4 Bytes durch Verwenden des Alphabets für die Lauflängencodierung gespeichert. Weitere 2 Bytes gespeichert, da AtIndexdas Modulo automatisch übernommen wird. Weitere 4 Bytes gespeichert, da Mapautomatisch eine Indexvariable erstellt wird. Erläuterung:

Print(Map(

Das äußere Mapgibt ein Array zurück. PrintBewältigt dies, indem jedes Element in einer eigenen Zeile gedruckt wird, so dass es nicht manuell Joinmit erstellt werden muss \n.

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

Die Zeichenfolge codiert alle halben Zeilen der Ausgabe. Abwechselnde Buchstaben beziehen sich auf die Anzahl von *s und Leerzeichen ( a=0wird verwendet, um eine Zeile zu behandeln, die mit einem Leerzeichen beginnt). Das Leerzeichen ist eine bequeme Wahl des Begrenzungszeichens, lässt sich aber auch gut komprimieren (x komprimiert sich auch auf insgesamt 55 Byte). Jede Zeile wird separat verarbeitet. (Hinweis: Der Deverbosifier kann das Trennzeichen zwischen einer komprimierten und einer nicht komprimierten Zeichenfolge nicht entfernen, da der Code sonst ,zur besseren Lesbarkeit eine haben würde .)

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

Durchlaufen Sie jeden Buchstaben und erweitern Sie ihn auf die entsprechende Anzahl von *s oder Leerzeichen. Die Variable mist dabei der innere Schleifenindex Map, während lder Buchstabe enthalten ist. Das Ergebnis wird dann unter JoinVerwendung der vordefinierten leeren Zeichenfolge in eine einzelne Zeichenfolge umgewandelt w.

ReflectOverlap(:Left);

Sobald alle Zeilen gedruckt sind, spiegeln Sie alles auf der linken Seite wider und überlappen die mittlere Spalte.

Ich habe versucht, die Zeilenumbrüche, Leerzeichen und Sterne in einer Schleife zu behandeln, aber es hat tatsächlich zwei weitere Bytes in dieser Weise gedauert:

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 Bytes

Fast per Definition wird Clojure niemals einen Preis für Kürze gewinnen, aber als ich JEDE VERDUNKELTE WOCHE auf die ZWEI (count 'em - TWO ) Episoden von Batman (gleiche Bat-Zeit, gleicher Bat-Kanal!) Gespannt war, war klar, dass es sie gibt keine Zeit zu verlieren!

Schnell, Robin - zum 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)))

Ungolf-Version:

(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. Egal wie lächerlich diese Shows waren, es grüßen euch diejenigen von uns, die Kinder waren.

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

Probieren Sie es online!

Verschiedene Lösungen, die alle die Lauflängencodierung verwenden, mit einer Vielzahl von Techniken zum Codieren der RLE-Daten.

Python 3, 125 121 Bytes

Diese Version verwendet eine bytesZeichenfolge zum Speichern der Daten.

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

Sei seine Kette von Sternen oder Räumen. Dann wird die Byte - nCodierung sgegeben ist durch

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

Python 2, 133 126 Bytes

Diese Version verwendet alphabetische Codierung. Der Buchstabenwert bestimmt die Länge der Ausgabezeichenfolge. Die Groß- und Kleinschreibung des Buchstabens bestimmt, ob er aus Leerzeichen oder Sternen besteht.

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

Meine ursprüngliche 133-Byte-Python-2-Lösung.

In dieser Version werden Zeichenfolgen mit der Länge Null verwendet, sodass problemlos zwischen Stern- und Leerzeichenfolgen gewechselt werden kann.

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

Nur zum Spaß, hier ist ein Einzeiler mit der alphabetischen Codierung.

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

Für noch mehr Spaß gibt es in Conways Game of Life ein Muster , das eine Version des Batman-Logos generiert. Ich musste jede Zeile verdoppeln, um das Seitenverhältnis in etwa auf dem Niveau der Textversion zu halten. Dieses Muster ist nicht wirklich das Logo berechnen (obwohl es ist möglich , Berechnungen im Leben zu tun - es ist Turing-complete), es Replays es nur aus dem Gedächtnis Loops, so dass ich glaube , ich kann es nicht als Code Golf - Eintrag schreiben (obwohl Ich habe es mit einem Python-Skript erstellt, das ich vor ein paar Jahren geschrieben habe. ;)

Es ist in einem ziemlich standardmäßigen RLE-Format codiert, das die meisten Life-Engines laden können. Wenn Sie kein GoL-Programm (z. B. Golly ) haben, können Sie es mit dieser Online-Life-Engine , die Life-RLE-Dateien importieren kann, online in Aktion anzeigen . Hier ist eine PNG-Version dieses Lebensmusters . Einige Lebensprogramme (einschließlich Golly) können Lebensmuster aus PNGs und verschiedenen anderen Bilddateiformaten laden.

T-SQL, 283 276 222 Bytes

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

Implementieren der GZIP-Komprimierung der ursprünglichen Batman-Zeichenfolge mithilfe der hier angegebenen Methode . Dies funktioniert nur in SQL 2016 und höher.

Verwenden Sie für frühere SQL-Versionen meine frühere Methode ( 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(@)

Grundsätzlich codiere ich manuell eine riesige Zeichenfolge, die bestimmt, was als Nächstes gedruckt werden soll, und zwar mithilfe der folgenden Methode:

• #7 wird ersetzt durch +REPLICATE('*',7)
• $4 wird ersetzt durch +SPACE(4)
• & wird ersetzt durch +CHAR(13)

Nach dem Ersetzen sieht die vollständige 958-Zeichenfolge wie folgt aus (mit Zeilenumbrüchen in jeder Zeile des Batman-Symbols:

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)

Was als dynamisches SQL ausgeführt wird und die folgende Ausgabe erzeugt:

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

PHP , 137 Bytes

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

Probieren Sie es online!

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

Probieren Sie es online!

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

Probieren Sie es online!

Java, 296 214 Bytes

Golf gespielt:

()->{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......

Probieren Sie es online aus .

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

Erklärung (mit plain-ol ES6)

• Wie bereits erwähnt, ist das Bild symmetrisch, sodass wir die Hälfte davon in der Codierung herauswerfen können
• Es werden auch mehrere Zeilen wiederholt, sodass wir jede Zeile in eine Nachschlagetabelle werfen können, um ein paar Bytes zu sparen
• Wir konvertieren jede halbe Zeile in ein Binärformat (wobei 0 als Leerzeichen und 1 als * verwendet wird) und codieren sie mit dem höchsten Radix in Javascript (36), woraus sich das Codierungsarray ergibt.
• Die erste Karte nimmt jede Zeile und konvertiert sie zurück in ihre endgültige Ausgabehälfte, wobei sie mit Nullen aufgefüllt wird
• Die zweite Karte verkettet jede Zeile mit ihrer umgekehrten Hälfte (wirft die mittlere Spalte zum zweiten Mal) und ersetzt die Nullen und Einsen durch Leerzeichen und * 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 Bytes

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

Probieren Sie es 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

Dies verwendet Lauflängencodierung, um die folgende Batman-Hälfte zu generieren:

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

Anschließend wird jede Zeile umgekehrt und dupliziert.

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]

Probieren Sie es online!

Die Lauflänge codiert jede Zeile von der linken Hälfte in Basis 36. Spiegelt sie, um die vollständige Zeile zu erstellen, die gedruckt wird. Die führenden Leerzeichen werden nicht codiert. Stattdessen ist die linke Hälfte auf Länge 25 gepolstert.

Mathematica 151 Bytes

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

Billig und unkreativ. Die Saite ist nur aus dem eingebautenCompress Befehl, der für die erforderliche Ausgabe verwendet wird.

Aktualisieren:

Ich denke, ich kann es mit den integrierten ImportString\ ExportStringFunktionen besser machen, aber ich kann die resultierenden Zeichenfolgen nicht ExportStringrichtig kopieren und einfügen . Z.B

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

Ich kann nicht scheinen, die Textausgabe von der zweiten Zeile zu kopieren, um die %in der dritten Zeile zu ersetzen .

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

Probieren Sie es online!

Wirklich schrecklich, brauche mehr Zeit oder helfe beim Golfen. es generiert die Ausgabe mit 0 und 1 und transliteriert am Ende. In hexadezimalen Ziffern codiert die Anzahl von 0 und 1, wobei darauf zu achten ist, dass die letzte Ziffer 0 für die ersten beiden Zeilen als Flag für die Ausgabe der mittleren Spalte verwendet wird. Verwendet printf Pressision, um entweder eine Ziffer oder eine Zeichenfolge auszugeben, um 0 und 1 auszugeben. Denken Sie, das %.$[0x${X}]CMuster könnte zum Golfen verwendet werden.

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 Bytes

Noch eine Python-Antwort. Kein langweiliger Komprimierungscode. Aufregender Kompressionscode.

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

Ich benutze die magische Zahl 35, weil auf diese Weise keine Steuerzeichen, Leerzeichen oder Dinge auftreten, die entkommen müssten. Schade, dass ich die Räume und Sterne getrennt verarbeiten muss, das kostet mich ein bisschen.

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

Vielleicht kann mir jemand anderes helfen, es weiter zu verkürzen, obwohl ich nicht herausfinden kann, wie, es sei denn, es gibt eine präzisere Möglichkeit, einen benutzerdefinierten Typ-Beschleuniger zu definieren.

Edit: Verkürzte Version (danke @root). Codierte Zeichenfolgen (Pre-Base64-Codierung) können um acht Array-Positionen gekürzt und der Bereich somit verringert werden. Ich bin nicht sicher, warum StreamWriter dieses Aufblähen in MemoryStream einführt. Einsicht in das zugrunde liegende Verhalten ist erwünscht.

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

Kompressionscode:

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

Beachten Sie das nachstehende Leerzeichen nur am Ende der ersten Zeile. Benötigt -M5.01, was kostenlos ist.

Kann wohl noch ein bisschen mehr golfen werden.

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

Die ungolfed version mit erklärungen:

\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;}

Probieren Sie es online!

Viele Bytes werden gespeichert, nachdem der Ansatz geändert wurde. Aus der Zeichnung als 2D-Array habe ich die RLE-Codierung nach Dateien berechnet:

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

Ungerade Indizes stehen für s und gerade Indizes stehen für *s. Dann habe ich jede Zahl durch eine druckbare ASCII-Darstellung ersetzt (wobei das '#' als 1 verwendet wurde) und Folgendes erhalten:

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

Der Algorithmus berechnet also nur die Zeichnung, indem er diese Zeichenfolge dekomprimiert und an den richtigen Stellen neue Zeilen hinzufügt.

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

Probieren Sie es 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''

Ausgabe:

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

Hauptidee ist sehr einfach

Die Emblem-Codierung:

1. Verketten Sie alle Emblemzeilen zu einer Zeichenfolge
2. Zähle Leerzeichen und Sternchen
3. Codieren Sie die Länge jedes Segments + 42 als Zeichen

Dekodierung (dieses Skript):

1. Holen Sie sich den Code des Zeichens minus 42 für jedes Zeichen aus dem Cripto-String. Dies ist eine Länge eines Segments
2. Segment anhängen, bestehend aus einem Leerzeichen oder einem Sternchen wiederholt Length Malen
3. Fügen Sie jeweils 49 neue Zeilen ein, um die Zeilen zu teilen

Einige kluge Dinge

1. Der Codierungsalgorithmus schlägt ein Symbol mit dem Code 189 vor, um 3 mittlere Sternchenlinien anzuzeigen. Dieses Symbol ist nicht ASCII. In modernen Umgebungen funktioniert dies normal, es gibt jedoch Unklarheiten in Bezug auf die Skriptlänge. Also ersetze ich Nicht-ASCII-Zeichen½ ums*t (73 Sternchen, 0 Leerzeichen, 74 Sternchen).
2. Ich habe in der letzten Zeile die richtigen Leerzeichen abgeschnitten, um 1 Byte zu sparen. Entschuldigung, Batman.
3. Warum ist der Offset 42? Ich wollte nur :) Und Cripto-String sieht gut aus.

Extra: Scipt zur Codierung des Emblems

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

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

Braingolf , 590 580 579 577 428 423 312 Bytes

-111 Bytes, weil LeakyNun ein Golfgott ist

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

Probieren Sie es online!

Braingolf ist nicht gut in ASCII-Kunst, aber verdammt, ich habe es versucht.

Auf keinen Fall erkläre ich diesen Clusterf ** k

/// , 171 166 Bytes

5 Bytes gespart, weil ich \r\nin der Quelle verwendet habe, lol.

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

Probieren Sie es online!

Komprimiert durch die Verwendung aufeinanderfolgender Iterationen des Ersetzens der "sparsamsten" Teilzeichenfolgen durch ein einzelnes Zeichen. Dies ist nahezu optimal, obwohl eines von zwei Dingen der Fall sein könnte:

1. Ich könnte mit einigen Meta-Ersetzungen davonkommen (zB Regex dynamisch einfügen)
2. Es ist in gewisser Weise vorteilhafter, zuerst weniger wirtschaftliche Teilzeichenfolgen zu ersetzen (unwahrscheinlich).