Adam West đã qua đời và tôi muốn tôn vinh trí nhớ của anh ấy ở đây trên PPCG, mặc dù tôi nghi ngờ anh ấy biết về sự tồn tại của chúng tôi. Trong khi có rất nhiều, rất nhiều điều khác nhau mà người đàn ông này được biết đến, không có gì nổi bật hơn vai trò của anh ta là người dơi ban đầu . Tôi sẽ luôn nhớ cha dượng của tôi vẫn theo dõi Batman và Robin trường học cũ cho đến ngày nay. Thử thách này có bản chất đơn giản, hoàn toàn không phù hợp với người đàn ông phức tạp là Adam West. Tuy nhiên, đó là điều tốt nhất tôi có thể nghĩ ra, vì đây là hình ảnh mang tính biểu tượng nhất trong sự nghiệp của người đàn ông.

Tôi muốn đăng bài này sớm hơn, nhưng tôi đang chờ đợi ai đó nghĩ ra thứ gì đó tốt hơn.

Xuất ra các mục sau (có hoặc không có dấu cách / dòng mới):

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

Đây là mã golf , số byte thấp nhất sẽ giành chiến thắng.

Thạch , 44 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đây là một chữ số. Tất cả các ký tự được thay thế bằng các chỉ số dựa trên 1 của chúng trong trang mã của Jelly, kết quả được hiểu là số nguyên cơ bản 250, mang lại kết quả

58616171447449697510361193418481584558895594063391402

Tiếp theo, b25chuyển đổi số nguyên đó thành cơ sở 25 và o99thay thế 0 bằng 99 , mang lại

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$thay thế cơ sở ^thứ j -25 chữ số n bằng n bản sao của j , mang lại

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

Bây giờ, ị⁾ *lập chỉ mục vào cặp nhân vật. Lập chỉ mục là dựa trên 1 và mô-đun, vì vậy các số lẻ được thay thế bằng khoảng trắng, thậm chí cả số có dấu hoa thị. Sản lượng này

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

s25cắt kết quả thành các đoạn có độ dài 25 . Nếu chúng ta viết mỗi đoạn trên dòng riêng của mình, chúng ta sẽ nhận được

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

Nguyên tử nảy phản ứng lạiŒB từng đoạn bằng cách nối thêm một bản sao đảo ngược mà không có ký tự đầu tiên, mang lại

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

Cuối cùng, Ygiới thiệu các dòng thực tế.

Wordfuck , 5761 2686 byte

Tôi đoán sử dụng tên của anh ấy làm mã nguồn giúp Adam West có chút vinh dự.

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!

Hãy thử trực tuyến! _{(transfiled brainfuck)}

Hát Adam West _{(cảm ơn @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))

Bản giới thiệu

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 được lưu nhờ @ 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)

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Điều này sử dụng các kỹ thuật tiêu chuẩn sau đây:

• Vì hình ảnh đối xứng theo chiều ngang , chỉ có nửa bên trái (bao gồm cột giữa) được mã hóa.
• Hình ảnh được tuyến tính hóa theo thứ tự chính cột (xuống, sau đó qua) và chuỗi kết quả được mã hóa theo chiều dài chạy .
• Độ dài chạy kết quả lấy các giá trị từ 1đến 11, do đó, chuỗi độ dài chạy được nén bằng chuyển đổi cơ sở , từ cơ sở 11sang cơ sở 94(ký tự ASCII có thể in được ngoại trừ trích dẫn đơn, cần thoát ra).

05AB1E , 47 byte

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

Hãy thử trực tuyến!

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

Điều này giả định một môi trường Unix, cho rev. Tôi sử dụng mã hóa khá đơn giản (đếm, ký tự), với N và A nối thêm a và *tương ứng, và B thực hiện sao chép và đảo ngược.

Trong tệp thực tế, các mục được đặt trong ngoặc được thay thế bằng các byte bằng chữ mà chúng đại diện. <C-v>là 0x16, <ESC>là 0x1b và <CR>là 0x0d.

Dùng thử trực tuyến

Than , 69 54 52 48 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Chỉnh sửa: Nhờ chỉ có @ ASCII, đã lưu 4 byte bằng cách chuyển từ một cờ riêng sang lặp qua các chỉ số, 7 byte bằng cách sử dụng ⸿ký tự (không có tài liệu?) Và thêm 4 byte bằng cách sử dụng bảng chữ cái để mã hóa độ dài chạy. Đã lưu thêm 2 byte vì AtIndextự động lấy modulo. Đã lưu thêm 4 byte vì Maptự động tạo một biến chỉ mục. Giải trình:

Print(Map(

Bên ngoài Maptrả về một mảng. Printxử lý việc này bằng cách in từng phần tử trên dòng riêng của nó, do đó tránh phải tự làm thủ công Joinchúng \n.

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

Chuỗi mã hóa tất cả nửa hàng của đầu ra. Các chữ cái xen kẽ đề cập đến số lượng *s và dấu cách ( a=0được sử dụng để xử lý một hàng bắt đầu bằng khoảng trắng ). Không gian là một sự lựa chọn thuận tiện của dấu phân cách, nhưng cũng hóa ra là nén tốt (x cũng nén tổng cộng 55 byte). Mỗi hàng được xử lý riêng. (Lưu ý: Deverbosifier không thể loại bỏ dải phân cách giữa một chuỗi được nén và không nén, nếu không, mã sẽ có ,khả năng đọc.)

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

Lặp lại trên mỗi chữ cái, mở rộng đến số *s hoặc dấu cách thích hợp . Biến mlà chỉ số vòng lặp bên trong cho điều này Map, trong khi lgiữ chữ cái. Kết quả sau đó được Joined thành một chuỗi bằng cách sử dụng chuỗi rỗng được xác định trước w.

ReflectOverlap(:Left);

Khi tất cả các hàng được in, phản ánh mọi thứ ở bên trái, chồng lên cột giữa.

Tôi đã thử xử lý tất cả các dòng mới, dấu cách và dấu sao trong một vòng lặp nhưng thực sự phải mất thêm hai byte theo cách này:

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

Gần như theo định nghĩa, Clojure sẽ không bao giờ giành được bất kỳ giải thưởng nào cho sự ngắn gọn, nhưng khi tôi mong chờ MỌI TUẦN ĐẾN các tập phim HAI (đếm - em - TWO ) của Người Dơi (cùng thời gian Bat, cùng kênh Bat!) không con thơi gian để lang phi!

Nhanh lên, Robin - tới 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)))

Phiên bản chưa chơi gôn:

(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. Cho dù những chương trình đó có kỳ cục đến mức nào, những người trong chúng ta là những đứa trẻ chào bạn.

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

Hãy thử trực tuyến!

Các giải pháp khác nhau, tất cả đều sử dụng Mã hóa chiều dài chạy, với nhiều kỹ thuật để mã hóa dữ liệu RLE.

Python 3, 125 121 byte

Phiên bản này sử dụng một byteschuỗi để lưu trữ dữ liệu.

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

Hãy slà một chuỗi các ngôi sao hoặc không gian. Sau đó, nmã hóa byte sđược đưa ra bởi

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

Python 2, 133 126 byte

Phiên bản này sử dụng mã hóa chữ cái. Giá trị chữ cái xác định độ dài của chuỗi đầu ra, trường hợp của chữ cái xác định xem nó bao gồm các khoảng trắng hay dấu sao.

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

Giải pháp Python 2 133 byte ban đầu của tôi.

Phiên bản này sử dụng các chuỗi có độ dài bằng không để nó có thể dễ dàng xen kẽ giữa các chuỗi sao và chuỗi không gian.

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

Để cho vui, đây là một lớp lót sử dụng mã hóa chữ cái.

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

Để vui hơn nữa, đây là một mô hình trong Trò chơi cuộc sống của Conway tạo ra một phiên bản của logo Người Dơi. Tôi đã phải tăng gấp đôi mỗi dòng để giữ tỷ lệ khung hình gần giống với phiên bản văn bản. Mô hình này không thực sự tính biểu tượng (mặc dù nó là có thể làm phép tính trong cuộc sống - đó là Turing hoàn tất), nó chỉ replay nó từ vòng bộ nhớ, vì vậy tôi đoán tôi không thể gửi nó như là một nhập mã chơi golf (mặc dù Tôi đã tạo nó bằng cách sử dụng tập lệnh Python mà tôi đã viết vài năm trước). ;)

Nó được mã hóa theo định dạng RLE khá chuẩn mà hầu hết các động cơ Life có thể tải. Nếu bạn không có chương trình GoL (ví dụ Golly ), bạn có thể xem nó trực tuyến bằng công cụ Life trực tuyến này , có thể nhập các tệp Life RLE. Đây là phiên bản PNG của mẫu Life đó , một số chương trình Life (bao gồm Golly) có thể tải các mẫu Life từ PNG và nhiều định dạng tệp hình ảnh khác.

T-SQL, 283 276 222 byte

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

Thực hiện nén GZIP của chuỗi batman ban đầu, thông qua phương thức được đăng ở đây . Điều này chỉ hoạt động trong SQL 2016 trở lên.

Đối với các phiên bản SQL trước đó, hãy sử dụng phương thức trước của tôi ( 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(@)

Về cơ bản, tôi đang mã hóa thủ công một chuỗi khổng lồ để xác định những gì sẽ in tiếp theo, sử dụng phương pháp sau:

• #7 được thay thế bởi +REPLICATE('*',7)
• $4 được thay thế bởi +SPACE(4)
• & được thay thế bởi +CHAR(13)

Sau khi thay thế, chuỗi ký tự 958 đầy đủ trông giống như (với các ngắt dòng ở mỗi dòng trong biểu tượng 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)

Mà được thực thi như SQL động, tạo ra đầu ra sau:

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

PHP , 137 byte

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Java, 296 214 byte

Chơi gôn

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

Ung dung:

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

Bong bóng , 75

bãi rác xxd:

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

Hãy thử trực tuyến .

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

Giải thích (sử dụng ES6 đơn giản)

• Giống như những người khác đã đề cập, hình ảnh là đối xứng, vì vậy chúng ta có thể loại bỏ một nửa hình ảnh trong mã hóa
• Một số dòng cũng được lặp lại, vì vậy chúng ta có thể ném từng dòng trong bảng tra cứu để lưu một vài byte
• Chúng tôi chuyển đổi mỗi nửa dòng thành nhị phân (sử dụng 0 là khoảng trắng và 1 là *) và mã hóa nó ở cơ số cao nhất đó trong Javascript (36), dẫn đến mảng mã hóa.
• Bản đồ đầu tiên lấy từng dòng và chuyển đổi nó thành nửa dòng đầu ra cuối cùng của nó, đệm nó bằng 0s
• Bản đồ thứ hai nối mỗi dòng với một nửa đảo ngược của nó (ném cột giữa lần thứ hai) và thay thế 0 và 1 bằng dấu cách và * 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

Hãy thử trực tuyến!

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

Điều này sử dụng mã hóa độ dài chạy để tạo ra một nửa batman sau:

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

Và sau đó đảo ngược và nhân đôi từng dòng.

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]

Hãy thử trực tuyến!

Run-length mã hóa từng dòng từ nửa bên trái trong cơ sở 36. Gương nó để tạo ra dòng đầy đủ, được in. Các không gian hàng đầu không được mã hóa; thay vào đó, nửa bên trái được đệm đến chiều dài 25.

Toán học 151 byte

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

Giá rẻ và không sáng tạo. Chuỗi chỉ là từ Compresslệnh tích hợp được sử dụng trên đầu ra cần thiết.

Cập nhật:

Tôi nghĩ rằng tôi có thể làm tốt hơn với các hàm ImportString\ ExportStringtích hợp nhưng tôi không thể nhìn thấy để sao chép và dán các chuỗi kết quả từ ExportStringchính xác. Ví dụ

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

Tôi dường như không thể sao chép đầu ra văn bản từ dòng thứ hai để thay thế %trong dòng thứ ba.

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

Hãy thử trực tuyến!

thực sự khủng khiếp, cần thêm thời gian hoặc giúp đỡ để chơi nó. nó tạo ra đầu ra với 0 và 1 và phiên âm cuối cùng. Được mã hóa bằng các chữ số hexa số lượng 0 và 1, chú ý tạo chữ số 0 cuối cùng cho hai hàng đầu tiên làm cờ cho cột giữa. Sử dụng phương thức printf để chữ số hoặc chuỗi thành đầu ra 0 và 1. nghĩ rằng %.$[0x${X}]Cmô hình có thể được sử dụng để đánh gôn.

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

Một câu trả lời Python khác. Không có mã nén nhàm chán mặc dù. Mã nén thú vị.

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

Tôi đang sử dụng ma thuật số 35 bởi vì theo cách đó, không có nhân vật điều khiển, không gian hoặc những thứ cần phải thoát ra. Đáng buồn là tôi phải xử lý các không gian và các ngôi sao riêng biệt, điều đó làm tôi tốn một chút.

Ung dung:

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

Có lẽ ai đó khác có thể giúp tôi rút ngắn hơn nữa, mặc dù tôi không thể tìm ra cách trừ khi có cách ngắn gọn hơn để xác định máy gia tốc loại tùy chỉnh.

Chỉnh sửa: Phiên bản rút gọn (cảm ơn @root). Chuỗi được mã hóa (mã hóa cơ sở trước64) có thể được cắt bởi tám vị trí mảng và do đó phạm vi có thể bị giảm. Không chắc chắn tại sao StreamWriter lại giới thiệu sự phình to này vào MemoryStream. Cái nhìn sâu sắc về hành vi cơ bản sẽ được đánh giá cao.

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

Ung dung:

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

Mã nén:

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

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

#Convert Array to Base64 string
[Convert]::ToBase64String(
    #Retrieve Memory Stream as an array
    ($ms.ToArray() | select -SkipLast 8)
)

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

Lưu ý khoảng trống ở cuối dòng đầu tiên. Yêu cầu -M5.01, đó là miễn phí.

Có lẽ có thể được chơi golf hơn một chút.

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

Phiên bản vô văn hóa với lời giải thích:

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

Hãy thử trực tuyến!

Rất nhiều byte được lưu sau khi thay đổi cách tiếp cận. Lấy bản vẽ dưới dạng mảng 2D, tôi đã tính toán mã hóa RLE theo các tệp:

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

Chỉ số lẻ đại diện cho s và thậm chí chỉ số đứng cho *s. Sau đó, tôi thay thế mọi số cho một đại diện ASCII có thể in được (lấy ký tự '#' là 1) và tôi đã nhận được:

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

Vì vậy, thuật toán chỉ tính toán bản vẽ bằng cách giải nén chuỗi này và thêm dòng mới vào vị trí thích hợp.

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

Hãy thử trực tuyến!

Ung dung:

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

Đầu ra:

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

Ý chính rất đơn giản

Mã hóa biểu tượng:

1. Nối tất cả các dòng biểu tượng thành một chuỗi
2. Đếm không gian và dấu sao
3. Độ dài mã hóa của mỗi phân đoạn + 42 dưới dạng char

Giải mã (tập lệnh này):

1. Nhận mã của char trừ 42 cho mỗi char từ chuỗi cripto. Đây là chiều dài của một đoạn
2. Nối phân khúc, bao gồm một không gian hoặc dấu hoa thị lặp lại Lengthlần
3. Chèn dòng mới mỗi 49 ký hiệu để phân chia dòng

Một số điều thông minh

1. Thuật toán mã hóa gợi ý một ký hiệu có mã 189 để hiển thị 3 dòng dấu sao ở giữa. Biểu tượng này không phải là ASCII. Nó hoạt động bình thường với môi trường hiện đại, nhưng có sự mơ hồ với độ dài kịch bản. Vì vậy, tôi thay thế biểu tượng không ascii ½thành s*t(73 dấu sao, 0 dấu cách, 74 dấu sao).
2. Tôi cắt bỏ khoảng trắng bên phải trong dòng cuối cùng để tiết kiệm 1 byte. Xin lỗi, Người Dơi.
3. Tại sao độ lệch là 42? Chỉ muốn :) Và chuỗi cripto trông thật tuyệt.

Thêm: Scipt để mã hóa biểu tượng

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

Toán học, 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 vì LeakyNun là một vị thần chơi gôn

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

Hãy thử trực tuyến!

Braingolf không giỏi về nghệ thuật ASCII, nhưng tôi đã thử.

Không có cách nào trong địa ngục tôi đang giải thích cụm này ** k

/// , 171 166 byte

5 byte được lưu bởi vì tôi đang sử dụng \r\ntrong nguồn, lol.

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

Hãy thử trực tuyến!

Được nén bằng cách sử dụng các lần lặp liên tiếp để thay thế các chuỗi con "kinh tế nhất" bằng một ký tự duy nhất. Điều này gần như tối ưu, mặc dù một trong hai điều có thể là trường hợp:

1. Tôi có thể thoát khỏi việc sử dụng một số thay thế meta (ví dụ: tự động chèn biểu thức chính quy)
2. Trước tiên, việc thay thế các chất nền ít kinh tế hơn (không chắc) sẽ có lợi hơn.