Adam West vefat etti ve varlığımızı bildiğinden şüpheliyim, ancak burada PPCG'deki hafızasını onurlandırmak istiyorum. Bu adamın bildiği birçok farklı şey olsa da, hiçbiri orijinal batman rolünden daha belirgin değildir . Üvey babamın hala eski okul Batman ve Robin’i izlediğini hep hatırlayacağım. Bu zorluk, doğada basittir, hiçbir şekilde Adam West olan karmaşık adamla aynı çizgide değildir. Bununla birlikte, bulabildiğim en iyisi bu, çünkü bu adamın kariyerinin en ikonik görüntüsü.

Bunu daha önce göndermek istedim, ama daha iyi bir şey bulmak için birini bekliyordum.

Aşağıdakileri yazdırın (sondaki boşluklarla / yeni satırlarla veya olmadan):

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

Bu kod golf , en düşük bayt sayısı kazanacak.

Jöle , 44 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

Bu sayısal bir değişmezdir. Jelly'in kod sayfasındaki tüm karakterler 1-temelli indeksleri ile değiştirilir , sonuç, sonuç olarak, bir bibektif taban-250 tamsayı olarak yorumlanır.

58616171447449697510361193418481584558895594063391402

Ardından, b25bu tamsayıyı 25 tabanına dönüştürün ve 0 değerini 99 ile o99değiştirerek sonuç verin

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$yerine j ^inci baz-25 haneli n ile n kopyaları j , sonuçta

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

Şimdi, ị⁾ *karakter çiftine indeksler. İndeksleme 1 tabanlı ve modülerdir, bu yüzden tek sayılar boşluklarla, hatta yıldız işaretli olanlar ile değiştirilir. Bu verim

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

s25sonucu, uzunluğu 25 olan parçalara böler . Her bir parçayı kendi satırına yazarsak,

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

Geri dönen atomu ŒB, sonuçta ilk karakteri olmadan ters kopyasını ekleyerek her öbek palindromizes

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

Son olarak, Ygerçek satır beslemelerini tanıtır.

Wordfuck , 5761 2686 bayt

Adını kaynak kod olarak kullanmak, Adam West’e biraz onur kazandırıyor.

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!

Çevrimiçi deneyin! _{(transpillenmiş beyin krizi)}

Adam West şarkı _{(teşekkürler @carusocomputing)}

Python, 530 529 528 524 bayt

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 bayt

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

gösteri

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 bayt

@ PM2Ring sayesinde 7 bayt kaydedildi

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 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Bu, aşağıdaki standart teknikleri kullanır:

• Görüntü yatay olarak simetrik olduğundan , sadece soldaki yarım (orta sütun dahil) kodlanır.
• Görüntü sütun ana düzeninde doğrusallaştırılır (aşağı ve sonra aşağıya doğru) ve elde edilen sıra çalışma uzunluğu kodlanır .
• Sonuçta elde edilen çalışma uzunlukları 1ila arasındaki değerleri alır 11, bu nedenle çalışma uzunluklarının sırası, baz dönüşümden , bazdan baza 11kadar sıkıştırılır94 (tek tırnak işareti hariç, yazdırılması gereken ASCII karakterleri).

05AB1E , 47 bayt

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

Çevrimiçi deneyin!

vim, 168 156 bayt

: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

Bunun için bir Unix ortamı olduğu varsayılmaktadır rev. Burada N ve A eklenmesi bir ile (sayı, karakter) kodlaması, oldukça basit bir kullanımı ve *sırasıyla, ve Yatak kopya durumu ve geri.

Gerçek dosyada, köşeli ayraç girişleri temsil ettikleri değişmez baytlarla değiştirilir. <C-v>0x16, <ESC>0x1b ve <CR>0x0d'dir.

Çevrimiçi deneyin

Kömür , 69 54 52 48 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Düzenleme: Yalnızca @ ASCII sayesinde, ayrı bir bayraktan indeksler arasında döngülemeye geçerek 4 bayt , (belgelenmemiş?) ⸿Karakterini kullanarak 7 bayt ve çalışma uzunluğu kodlaması için alfabeyi kullanarak 4 bayt daha kaydedildi. 2 bayt daha kaydedildi, çünkü AtIndexotomatik olarak modulo alıyor. 4 bayt daha kaydedildi, çünkü Mapotomatik olarak bir dizin değişkeni yaratıyor. Açıklama:

Print(Map(

Dış Mapbir dizi döndürür. Printbunu her bir elemanı kendi satırına yazdırarak idare eder, böylece Joinonları elle yapmak zorunda kalmazlar \n.

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

Dize, çıktının tüm yarım satırlarını kodlar. Alternatif harfler, *s ve boşluk sayısını belirtir (boşlukla a=0başlayan bir satırı işlemek için kullanılır). Alan uygun bir sınırlayıcı seçimidir, ancak aynı zamanda iyi sıkıştırıldığı ortaya çıkar (x ayrıca toplam 55 bayta da sıkıştırılır). Her satır ayrı olarak işlenir. (Not: Sıkıştırıcı, sıkıştırılmış ve sıkıştırılmamış bir dize arasındaki ayırıcıyı çıkartamaz, aksi takdirde kodun ,okunabilirliği vardır.)

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

Her harfin üzerinde ilmekleyin, uygun sayıda *s veya boşluğa genişletin . Değişken mbunun için iç döngü endeksidir Mapiken, lmektup tutar. Sonuç daha sonra Joinönceden tanımlanmış boş dizgiyi kullanarak tek bir dizge haline getirilir w.

ReflectOverlap(:Left);

Tüm satırlar yazdırıldıktan sonra, her şeyi sola yansıtın, ortadaki sütun üst üste gelecek.

Yeni çizgileri, boşlukları ve yıldızları tek bir döngüde işlemeyi denedim, ancak aslında bu şekilde iki bayt daha aldı:

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 bayt

Neredeyse tanımı gereği Clojure hiçbir zaman kısalık ödülü kazanmayacak, ama ben HER DARN HAFTA’yı Batman’ın İKİ (sayar - İKİ ) bölümlerine (aynı Yarasa zamanı, aynı Yarasa kanalı! kaybedecek zaman yok!

Çabuk, Robin - Bat-REPL'e !!!

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

Golfsüz versiyon:

(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. Bu gösteriler ne kadar saçma olursa olsun, bizler çocuk olanları selamlıyoruz.

C (gcc) , 191 bayt

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

Çevrimiçi deneyin!

Hepsi RLE verilerini kodlamak için çeşitli tekniklerle Run Length Encoding kullanan çeşitli çözümler.

Python 3, 125 121 bayt

Bu sürüm bytesverileri depolamak için bir dize kullanır .

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

sBir yıldız veya boşluk dizisi olsun . Daha sonra bayt nkodlama sile verilir

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

Python 2, 133 126 bayt

Bu sürüm alfabetik kodlama kullanır. Harf değeri çıktı dizesinin uzunluğunu, harfin durumu boşluklardan mı yoksa yıldızlardan mı oluşacağını belirler.

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

Orijinal 133 bayt Python 2 çözümü.

Bu sürüm sıfır uzunluklu dizeler kullanır, böylece yıldız ve boşluk dizeleri arasında kolayca geçiş yapabilir.

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

Sadece eğlence için, işte alfabetik kodlamayı kullanan bir astar.

Python 2, 148 bayt

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

Daha da fazla eğlence için, Conway'in Yaşam Oyunda , Batman logosunun bir versiyonunu oluşturan bir kalıp . En boy oranını kabaca metin sürümüyle aynı tutmak için her satırı ikiye katlamak zorunda kaldım. Bu desen değil gerçekten logosu hesaplamak (o her ne kadar olduğunu -, sadece bellek döngüler onu tekrar oynatacak Yaşamda hesaplamaları yapmak mümkün bunun Turing-Tamamlandığı), bu yüzden (her ne kadar ben bir kod golf girişi olarak yayınlamayın sanırım Ben yaptım ben birkaç yıl önce yazdığı bir Python komut dosyası) kullanarak oluşturun. ;)

Life motorlarının çoğunun yükleyebileceği oldukça standart bir RLE formatında kodlanmıştır. Bir GoL programınız yoksa (örn. Golly ), Life RLE dosyalarını içe aktarabilen bu çevrimiçi Life motoruyla çevrimiçi olarak çalışmasını görebilirsiniz. İşte o Yaşam modelinin bir PNG versiyonu , bazı Yaşam programları (Golly dahil), PNG'lerden ve çeşitli diğer görüntü dosyası formatlarından Yaşam modellerini yükleyebilir.

T-SQL, 283 276 222 bayt

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

Orijinal batman dizgisinin GZIP sıkıştırmasını buraya gönderilen yöntemle uygulamak . Bu yalnızca SQL 2016 ve sonrasında çalışır.

Önceki SQL sürümleri için önceki yöntemimi kullan ( 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(@)

Temel olarak, aşağıdaki yöntemi kullanarak, sonra ne yazdırılacağını belirleyen dev bir dize olarak el ile kodlama yapıyorum:

• #7 ile değiştirilir +REPLICATE('*',7)
• $4 ile değiştirilir +SPACE(4)
• & ile değiştirilir +CHAR(13)

Değişimden sonra 958 karakter dizisinin tamamı (Batman sembolündeki her satırda satır kesilmesiyle) görünür:

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)

Aşağıdaki çıktıları üreten dinamik SQL olarak çalıştırılır:

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

PHP , 137 bayt

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

Çevrimiçi deneyin!

PHP , 177 bayt

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

Çevrimiçi deneyin!

PHP , 179 bayt

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

Çevrimiçi deneyin!

Java, 296 214 bayt

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

Ciklet , 75

xxd dökümü:

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

Çevrimiçi deneyin .

Kahve yazısı (282 Bayt)

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

Açıklama (plain-ol ES6 kullanarak)

• Diğerlerinin de söylediği gibi, görüntü simetriktir, bu yüzden kodlamanın yarısını çıkarabiliriz
• Birkaç satır da tekrarlanır, böylece bir kaç bayttan tasarruf etmek için her satırı arama tablosuna atabiliriz
• Her yarım çizgiyi ikiliye dönüştürürüz (boşluk olarak 0 ve * olarak 1 kullanarak) ve Javascript'teki (36) en yüksek yarıçapta kodlayarak kodlama dizisini oluştururuz.
• İlk harita her bir çizgiyi alır ve tekrar 0 nolu dolguyla son çıkışa dönüştürür.
• İkinci harita, her satırı ters yarım ile birleştirir (orta sütunu ikinci kez atar), ve 0s ve 1'leri boşluklar ve * s ile değiştirir

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 bayt

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

Çevrimiçi deneyin!

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

Bu, aşağıdaki batman yarısını oluşturmak için çalışma uzunluğu kodlamasını kullanır:

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

Ve sonra her satırı tersine çevirir ve çoğaltır.

Python 2 , 134 bayt

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]

Çevrimiçi deneyin!

Çalışma uzunluğu, her bir satırı soldaki tabandan (36) kodlar. Yazdırılan tam çizgiyi elde etmek için yansıtır. Baştaki boşluklar kodlanmamış; bunun yerine, sol yarı uzunluk 25'e kadar yastıklıdır.

Mathematica 151 Bayt

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

Ucuz ve yaratıcı değil. Dize, yalnızca Compressistenen çıktıda kullanılan yerleşik komuttan gelir.

Güncelleme:

Yerleşik ImportString\ ExportStringişlevleriyle daha iyisini yapabileceğimi düşünüyorum ancak elde edilen dizeleri ExportStringdoğru kopyalayıp yapıştıramıyorum . Örneğin

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

Metin satırını %üçüncü satırda değiştirmek için ikinci satırdan kopyalayamıyorum .

Bash ,407 322 bayt

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

Çevrimiçi deneyin!

Gerçekten korkunç, daha fazla zamana ihtiyacım var veya golf oynamak için yardıma ihtiyacınız var. 0 0 ile çıkış üretir ve sonunda çevrilir. Heksaa kodlanmış, ilk iki satır için ortadaki sütunu çıkarmak üzere bayrak olarak son haneyi 0 yapmaya özen göstererek, 0 ve 1 miktarını gösterir. 0 ve 1 çıkışlarını yazdırmak için basamağı ya da basamağa yazdırır. Desenin golf oynamak için %.$[0x${X}]Ckullanılabileceğini düşünür .

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 bayt

Yine bir Python Cevabı. Sıkıcı sıkıştırma kodu olsa da. Heyecan verici sıkıştırma kodu.

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

35 numaralı büyüyü kullanıyorum çünkü bu şekilde kontrol karakterleri, boşluklar veya kaçılması gereken şeyler meydana gelmiyor. Boşlukları ve yıldızları ayrı ayrı işlemek zorunda olduğum için üzgünüm, bu bana biraz pahalı.

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 bayt, 307 bayt , 316 bayt

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

Belki başka biri daha da kısaltmamda bana yardımcı olabilir, ancak özel tipte bir hızlandırıcıyı tanımlamanın daha özlü bir yolu olmadıkça nasıl çözeceğimi bilemiyorum.

Düzenleme: Kısaltılmış versiyonu (teşekkürler @ root). Kodlanmış dize (base64 öncesi kodlama) sekiz dizi pozisyonu ile kırpılabilir ve böylece aralık azaltılabilir. StreamWriter'ın bu şişirmeyi neden MemoryStream'e eklediğinden emin değilim. Altta yatan davranışa dair içgörü takdir edilecektir.

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

Sıkıştırma kodu:

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

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

Yalnızca ilk satırın sonundaki sondaki boşluğa dikkat edin. Gerektiren -M5.01, ücretsizdir.

Muhtemelen biraz daha golf oynayabilir.

LaTeX, 314 bayt

\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

Açıklamaları ile ungolfed versiyonu:

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

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

Çevrimiçi deneyin!

Yaklaşım değiştirildikten sonra bir çok bayt kaydedildi. Çizimi 2D dizisi olarak alarak, RLE kodlamasını dosyalara göre hesapladım:

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

Tek endeksler s, hatta endeksler *s anlamına gelir. Sonra, yazdırılabilir bir ASCII gösterimi için her sayıyı değiştirdim ('#' karakterini 1 olarak alarak) ve aldım:

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

Bu yüzden algoritma, sadece bu dizgiyi açarak ve uygun yerlere yeni çizgiler ekleyerek çizimi hesaplar.

PowerShell , 129 128 bayt

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

Çevrimiçi deneyin!

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

Çıktı:

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

Ana fikir çok basit

Amblem Kodlaması:

1. Tüm amblem çizgilerini bir dizgeyle birleştirin
2. Boşlukları ve yıldızları say
3. Her bölümün uzunluğu + 42'yi karakter olarak kodlayın

Kod çözme (bu komut dosyası):

1. Her karakter için char eksi 42 kodunu kod dizisinden alın. Bu bir segmentin uzunluğu
2. Tekrarlanan Lengthzaman aralıklarından veya boşluklardan oluşan segmenti ekle
3. Her 49 sembolden her birine yeni çizgiler ekleyin.

Bazı akıllı şeyler

1. Kodlama algoritması, 3 orta yıldız çizgisini görüntülemek için 189 kodlu bir sembol önerir. Bu sembol ASCII değil. Modern ortamlarda normal çalışır, ancak senaryo uzunluğundaki belirsizlikler vardır. Böylece, ascii olmayan sembolü ½değiştiririm s*t(73 yıldız, 0 boşluk, 74 yıldız).
2. Son satırda 1 byte tasarruf etmek için doğru boşlukları kestim. Üzgünüm Batman.
3. Ofset neden 42? Sadece istedim :) Ve kripto teli güzel görünüyor.

Ekstra: Amblemin kodlanması için kod

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

Mathematica, 271 bayt

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 bayt

-111 bayt, çünkü LeakyNun golf tanrısı.

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

Çevrimiçi deneyin!

Braingolf ASCII sanatında iyi değil ama denedim kahretsin.

Cehenneme imkân yok ben bu kümeyi açıklıyorum

/// , 171 166 bayt

\r\nKaynakta kullandığım için 5 bayt kaydedildi , lol.

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

Çevrimiçi deneyin!

"En ekonomik" alt dizeleri tek bir karakterle değiştirmek için art arda yineleme kullanarak sıkıştırılır. Bu neredeyse optimal, ancak iki şeyden biri böyle olabilir:

1. Bazı meta değiştirmeleri kullanarak kurtulabilirdim (örneğin, dinamik olarak regex'ler yerleştir)
2. Bir şekilde ilk önce daha az ekonomik alt tabakaları değiştirmek daha olasıdır (pek mümkün değildir).