Tôi hy vọng hình ảnh này trông quen thuộc với bạn.

Đó là một trong những hồn ma của Pacman trong trạng thái "dễ bị tổn thương" của mình , sau khi Pacman ăn một viên thuốc năng lượng.

Các thách thức

Hình ảnh con ma của chúng ta trong một khung nhỏ, sử dụng nghệ thuật ASCII. Ở tỷ lệ bình thường (sẽ nói thêm về điều này sau), mỗi ô vuông trong hình trên phải tương ứng với một ký tự và khung nên có một phân tách một ký tự lên xuống và phân tách hai ký tự ở bên trái và bên phải của bóng ma :

####################
#                  #
#       ####       #
#     ########     #
#    ##########    #
#   ############   #
#   ############   #
#   ###  ##  ###   #
#  ####  ##  ####  #
#  ##############  #
#  ##############  #
#  ##  ##  ##  ##  #
#  # ##  ##  ## #  #
#  ##############  #
#  ## ###  ### ##  #
#  #   ##  ##   #  #
#                  #
####################

Nhưng điều này không có vẻ rất đẹp. #có thể không phải là lựa chọn tốt nhất cho các pixel hoạt động. Bên cạnh đó, các ô nhân vật không vuông, điều này làm cho người bạn của chúng ta trông ma quái hơn anh ta.

Vì vậy, để linh hoạt hơn, hình ảnh sẽ thay đổi theo ba thông số đầu vào:

• Ký tự được sử dụng cho các pixel hoạt động;
• Hệ số tỷ lệ ngang;
• Hệ số tỷ lệ dọc.

Ví dụ, với %, 4, 2ouput sẽ là hình ảnh nhìn tốt hơn

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%                                                                        %%%%
%%%%                                                                        %%%%
%%%%                            %%%%%%%%%%%%%%%%                            %%%%
%%%%                            %%%%%%%%%%%%%%%%                            %%%%
%%%%                    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                    %%%%
%%%%                    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                    %%%%
%%%%                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                %%%%
%%%%                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                %%%%
%%%%            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%            %%%%
%%%%            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%            %%%%
%%%%            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%            %%%%
%%%%            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%            %%%%
%%%%            %%%%%%%%%%%%        %%%%%%%%        %%%%%%%%%%%%            %%%%
%%%%            %%%%%%%%%%%%        %%%%%%%%        %%%%%%%%%%%%            %%%%
%%%%        %%%%%%%%%%%%%%%%        %%%%%%%%        %%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%%%%%%%%%        %%%%%%%%        %%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%        %%%%%%%%        %%%%%%%%        %%%%%%%%        %%%%
%%%%        %%%%%%%%        %%%%%%%%        %%%%%%%%        %%%%%%%%        %%%%
%%%%        %%%%    %%%%%%%%        %%%%%%%%        %%%%%%%%    %%%%        %%%%
%%%%        %%%%    %%%%%%%%        %%%%%%%%        %%%%%%%%    %%%%        %%%%
%%%%        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%        %%%%
%%%%        %%%%%%%%    %%%%%%%%%%%%        %%%%%%%%%%%%    %%%%%%%%        %%%%
%%%%        %%%%%%%%    %%%%%%%%%%%%        %%%%%%%%%%%%    %%%%%%%%        %%%%
%%%%        %%%%            %%%%%%%%        %%%%%%%%            %%%%        %%%%
%%%%        %%%%            %%%%%%%%        %%%%%%%%            %%%%        %%%%
%%%%                                                                        %%%%
%%%%                                                                        %%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Quy tắc

Tất cả các nội dung cho phép.

Đầu vào được thực hiện trong bất kỳ định dạng hợp lý và bất kỳ thứ tự. Đầu vào đầu tiên ở trên (ký tự cho pixel hoạt động) được đảm bảo là ký tự ASCII có thể in (mã 32 đến 126).

Không gian lưu trữ sau mỗi dòng hoặc dòng mới sau dòng cuối cùng được chấp nhận.

Mã golf, ít byte nhất thắng.

CJam, 53 51 49 byte

q~"ǟ #/?Y__Fy_Nf ǟ"f{'Ƞ^2b_W%+S@+f=}fe*e*N*

Lưu ý rằng ba trong số các ký tự là không thể in được. Hãy thử trực tuyến!

Lý lịch

Nửa bên phải của đầu ra không được tính giống hệt với đầu ra bên trái, do đó, nó đủ để mã hóa một trong số chúng. Nếu chúng ta thay thế không gian bằng số không và không gian bằng không gian, chúng ta sẽ nhận được

1111111111
1000000000
1000000011
1000001111
1000011111
1000111111
1000111111
1000111001
1001111001
1001111111
1001111111
1001100110
1001011001
1001111111
1001101110
1001000110
1000000000
1111111111

trong đó mỗi dòng có thể được hiểu là một số nhị phân. Sản lượng này

1023 512 515 527 543 575 575 569 633 639 639 614 601 639 622 582 512 1023

Cách dễ nhất để mã hóa thông tin này là thay thế từng số nguyên bằng ký tự Unicode tại điểm mã đó, nhưng tất cả chúng đều yêu cầu hai byte được mã hóa bằng UTF-8.

Bằng cách XOR các số nguyên với 544, chúng tôi giữ tất cả trừ hai số nguyên dưới 128 và tránh các byte rỗng.

Kết quả là

479 32 35 47 63 31 31 25 89 95 95 70 121 95 78 102 32 479

dưới dạng số nguyên hoặc

ǟ #/?\x1f\x1f\x19Y__Fy_Nf ǟ

như một chuỗi thoát.

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

q~                e# Read and evaluate all input. This pushes the vscale factor V,
                  e# the hscale factor H, and the character C.
"ǟ #/?Y__Fy_Nf ǟ" e# Push that string.
f{                e# For each character, push C and the character; then:
'Ƞ^               e#   XOR the character with '\u0220' (544), casting to integer.
 2b               e#   Convert from integer to base 2.
 _W%              e#   Push a reversed copy of the binary digits.
 +                e#   Concatenate.
 S@+              e#   Append C to " ".
 f=               e#   Replace each binary digit with ' ' or C.
}                 e#
fe*               e# Repeat each character in each string H times.
e*                e# Repeat each string V times.
N                 e# Join the strings, separating by linefeeds.

Perl, 113 105 104 100 97 96

Đã thêm +2 cho -ap

Gợi ý của dev-null lưu 9 byte Đã sửa lỗi đếm sai như nhận thấy của Dennis

Chạy bằng cách sử dụng echo "2 4 %" | perl -ap pacman.pl

pacman.pl:

}for(map+(unpack(aXBXB8Xb8XBXa),$/)x"@F","\xff\x00\x03\x0f\x1f\x3f\x3f\x39\x79\x7f\x7f\x66\x59\x7f\x6e\x46\x00\xff"=~/./g){s%%($&?$F[2]:$")x$F[1]%ge

ngoại trừ chuỗi "\xff\x00\x03\x0f\x1f\x3f\x3f\x39\x79\x7f\x7f\x66\x59\x7f\x6e\x46\x00\xff"nên được viết ở dạng nhị phân với dấu ngoặc đơn

Không gian là ký tự thay thế trở thành chuỗi trống và dẫn đến các dòng ngắn. Nhưng tất cả sẽ trông trống rỗng

APL Dyalog, 64 byte

{/∘⍉/⍺,⊂' '⍵[1+,∘⌽⍨1⍪⍨1⍪1,0⍪⍨0⍪0,0,⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒']}

Điều này lấy yếu tố tỷ lệ làm đối số bên trái và ký tự làm đối số bên phải, nghĩa là:

      2 1{/∘⍉/⍺,⊂' '⍵[1+,∘⌽⍨1⍪⍨1⍪1,0⍪⍨0⍪0,0,⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒']}'%'
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
 %%                                    %% 
 %%              %%%%%%%%              %% 
 %%          %%%%%%%%%%%%%%%%          %% 
 %%        %%%%%%%%%%%%%%%%%%%%        %% 
 %%      %%%%%%%%%%%%%%%%%%%%%%%%      %% 
 %%      %%%%%%%%%%%%%%%%%%%%%%%%      %% 
 %%      %%%%%%    %%%%    %%%%%%      %% 
 %%    %%%%%%%%    %%%%    %%%%%%%%    %% 
 %%    %%%%%%%%%%%%%%%%%%%%%%%%%%%%    %% 
 %%    %%%%%%%%%%%%%%%%%%%%%%%%%%%%    %% 
 %%    %%%%    %%%%    %%%%    %%%%    %% 
 %%    %%  %%%%    %%%%    %%%%  %%    %% 
 %%    %%%%%%%%%%%%%%%%%%%%%%%%%%%%    %% 
 %%    %%%%  %%%%%%    %%%%%%  %%%%    %% 
 %%    %%      %%%%    %%%%      %%    %% 
 %%                                    %% 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 

Giải trình:

• ⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒': Nửa trái của ma, không có viền. (Nó là đối xứng.) Mỗi ​​ký tự có tập bit cao, để ngăn việc chọn các ký tự không in ⎕AV, nhưng chỉ 7 byte đầu tiên được sử dụng.

• 0,⍪⍨0⍪0,0,: thêm đường viền của các khoảng trống ở bên trái, trên và dưới

• 1⍪⍨1⍪1,: thêm khung ở bên trái, trên cùng và dưới cùng
• ,∘⌽⍨: tham gia với gương dọc
• 1+: thêm 1, vì các mảng được lập chỉ mục 1 theo mặc định
• ' '⍵[... ]: sử dụng ma trận đó làm chỉ mục vào chuỗi ' '⍵, vì vậy mỗi 0 được ánh xạ thành một khoảng trống và mỗi 1 được ánh xạ tới ⍵.
• ⍺,⊂: kèm theo ma trận và nối nó với các yếu tố tỷ lệ
• /: nếp gấp bên phải với chức năng sau:
• /∘⍉: hoán vị và tỷ lệ theo chiều ngang

MATL , 71 byte

32hO511-3-12-16-32O6-64-6O25 13-38 17 40 70-511Nq$hYs10H$Bt!P!hi1$lX*Q)

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

Giải trình

Hình ảnh đối xứng theo chiều ngang, vì vậy chỉ cần nửa trái cần được mã hóa. Mỗi hàng 10 pixel được mã hóa nhị phân thành một số trong khoảng từ 0 đến 1023. Các pixel hoạt động được mã hóa thành 0 thay vì 1, vì vậy hàng đầu tiên là số 0 thay vì 1023.

Do các hàng liên tiếp chỉ khác nhau một vài pixel, nên các số được mã hóa thêm. Vì vậy, mỗi hàng sẽ được giải mã dưới dạng tổng tích lũy của tất cả các số cho đến hàng đó, theo sau là chuyển đổi thành nhị phân.

Các số cần thiết là sau đó

0 511 -3 -12 -16 -32 0 6 -64 -6 0 25 13 -38 17 40 70 -511

0 được giới thiệu trong MATL bằng cách sử dụng Ohàm, giúp tránh một dấu phân cách với các số lân cận. Ngoài ra, các dấu âm không ngụ ý thêm byte vì chúng đóng vai trò là dấu phân cách.

Khi mảng đã được tạo, nó được cộng gộp, giải mã nhị phân và nhân đôi theo chiều ngang. Mảng 2D kết quả được sử dụng để lập chỉ mục chuỗi hai char để tạo kết quả. Chuỗi này có dạng '% ', trong đó '%'là một char đầu vào.

Theo ghi nhận của @Conor, mã cũng hoạt động với hai ký tự làm đầu vào. Trong trường hợp này, chuỗi cuối cùng được lập chỉ mục sẽ có dạng '%_ ', trong đó đầu vào là một chuỗi hai char '%_'. Không gian đơn giản sẽ bị bỏ qua, bởi vì mảng lập chỉ mục chỉ giải quyết hai ký tự đầu tiên.

32                                             % space (ASCII)
h                                              % concat horizontally with 1st input: char
O511-3-12-16-32O6-64-6O25 13-38 17 40 70-511   % push these numbers
Nq$h                                           % concat all those numbers
Ys                                             % cumulative sum
10H$B                                          % convert to 10-digit binary numbers
                                               % gives 2D array, each number in one row
t                                              % duplicate
!P!                                            % flip horizontally
h                                              % concat horizontally
i                                              % take 2nd input: array [V H]
1$l                                            % matrix oh V×H ones  
X*                                             % Kronecker product to increase vertical
                                               % and horizontal scales by V and H resp.
Q                                              % add 1. Converts array of 0,1 into 1,2
)                                              % uses those 1,2 as indices into string

C (gcc) , 199 197 byte

-2 byte nhờ @JonathanFrech

n,j;f(c,h,v){for(char t[20],i=18;i--;){for(n=10;n--;)t[n]=t[19-n]=((("\xff\0""1;\x7fM3\x7f\x7fON~~|x`\0\xff"[i]<<3)|(i&&i^17?1:7))>>n)&1?c:32;for(j=v;j--;puts(""))for(n=20*h;n--;)putchar(t[n/h]);}}

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

188 byte (không thể in)

Phép lịch sự của @JonathanFrech.

n,j;f(c,h,v){for(char t[20],i=18;i--;){for(n=10;n--;)t[n]=t[19-n]=((("\xff\0001;M3ON~~|x`\0\xff"[i]<<3)|(i&&i^17?1:7))>>n)&1?c:32;for(j=v;j--;puts(""))for(n=20*h;n--;)putchar(t[n/h]);}}

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

Không có gì ngoạn mục đang diễn ra. Giống như những người khác nhận thấy, con ma có tính đối xứng cao. Hình ảnh có chiều rộng 20 đơn vị, nhưng ngoại trừ các hàng trên cùng và dưới cùng, ba cột ngoài cùng bên phải giống hệt nhau. Điều này cho phép chúng tôi lưu trữ một nửa hình ảnh dưới dạng ký tự thay vì phải sử dụng số nguyên:

#######  127     \x7f
           0     \0
##        96     `
####     120     x
#####    124     |
######   126     ~
######   126     ~
#  ###    78     N
#  ####   79     O
#######  127     \x7f
#######  127     \x7f
 ##  ##   51     3
#  ## #   77     M
#######  127     \x7f
 ### ##   59     ;
 ##   #   49     1
           0     \0
#######  127     \x7f

Chuỗi kết quả đã được đảo ngược để tạo ra một vài byte khi có vòng lặp giảm dần (cũng giải quyết được một vấn đề khó chịu với các thoát thập lục phân). Các vòng lặp khác có thể được lật mà không có vấn đề nhờ tính đối xứng.

Mỗi nhân vật được dịch chuyển sang trái và được cung cấp một đường viền (với sự chăm sóc đặc biệt ở hàng đầu tiên và hàng cuối cùng). Sau đó, nó chỉ là vấn đề xuất ra chuỗi được chia tỷ lệ chính xác.

Tất cả các vòng lặp làm cho tôi cảm thấy có một cách tốt hơn.

Nghiêm túc, 116 byte

╩' "3ff 200 203 20f 21f 23f 23f 239 279 27f 27f 266 259 27f 26e 246 200 3ff"s`24╙(¿¡╜'1(Æ' '0(Æ"╛*"£M;R@+εj2└@n`M'
j

Dòng mới đó rất quan trọng. Hexdump:

00000000: ca27 2022 3366 6620 3230 3020 3230 3320  .' "3ff 200 203
00000010: 3230 6620 3231 6620 3233 6620 3233 6620  20f 21f 23f 23f
00000020: 3233 3920 3237 3920 3237 6620 3237 6620  239 279 27f 27f
00000030: 3236 3620 3235 3920 3237 6620 3236 6520  266 259 27f 26e
00000040: 3234 3620 3230 3020 3366 6622 7360 3234  246 200 3ff"s`24
00000050: d328 a8ad bd27 3128 9227 2027 3028 9222  .(...'1(.' '0(."
00000060: be2a 229c 4d3b 5240 2bee 6a32 c040 6e60  .*".M;R@+.j2.@n`
00000070: 4d27 0d0a 6a                             M'..j

Chiến lược tương tự như câu trả lời CJam của Dennis , nhưng các giá trị được mã hóa dưới dạng hex, thay vì XORed với 544 và thao tác chuỗi khó hơn rất nhiều trong Nghiêm túc.

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

BBC BASIC, 239 236 232 214 byte

0DEFPROCM(A,B,C)C=C-32:FORU=0TO18*A-1:FORV=0TO20*B-1:Y=U DIVA:X=V DIVB:V.32-C*FNC((X<10)*-X-(X>9)*(19-X),Y):N.:P.:N.:E.
1DEFFNC(X,Y)Z=Y*10+X:=((ASCMI."#Cb^2aC*[#1CF<;)C$;I9I$;EYLb&#",Z/6+1)-35)AND(2^(Z MOD6)))=0

Gọi điện PROCM(1,1,35)tạo ra bóng ma làm bằng các ký hiệu #. Các đối số cho PROCM là: tỷ lệ ngang, tỷ lệ dọc, giá trị ASCII của ký tự.

Chương trình này sẽ hoạt động cho cả Brandy Basic và BASIC 2 trên Model B. ban đầu

Batch, 740 722 720 byte

@echo off
setlocal enabledelayedexpansion
set h=%3
set w=
set s=
for /l %%a in (1,1,%2)do set w=%1!w!&set s= !s!
call:l ####################
call:l #                  #
call:l #       ####       #
call:l #     ########     #
call:l #    ##########    #
call:l #   ############   #
call:l #   ############   #
call:l #   ###  ##  ###   #
call:l #  ####  ##  ####  #
call:l #  ##############  #
call:l #  ##############  #
call:l #  ##  ##  ##  ##  #
call:l #  # ##  ##  ## #  #
call:l #  ##############  #
call:l #  ## ###  ### ##  #
call:l #  #   ##  ##   #  #
call:l #                  #
call:l ####################
exit/b
:l
set l=%*
set l=!l: =%s%!
for /l %%a in (1,1,%h%)do echo !l:#=%w%!

Chỉnh sửa: Đã lưu 18 20 byte bằng cách xóa các khoảng trống không cần thiết.

Stax , 45 byte

àÄÅ╣>u°↨2ö|dτÅbn╦─▀:ΣFúÇz?⌂É\!n▄§V0Ncó╤½8|δò_

Chạy và gỡ lỗi nó

Giải trình:

"<long string>"!E' x+:BA/s|*mn|*:m Full program, implicit input.
"<long string>"!E                  Push 1531747987795407832964332490922049710271411270772589567
                 ' x+              Push a space plus the given character
                     :B            Interpret the number in binary, replacing 0 with ' ' and 1 with the given char
                       A/          Group into pieces of length 10.
                                   Gives the first half of each line.
                         s|*       Repeat each line <vertical scale factor> times
                            m      For each line:
                             n|*     Repeat each character <horizontal scale factor> times
                                :m   Mirror
                                     Implicit output with newline

JavaScript (ES6), 167 byte

(s,w,h)=>[...`NJ56:*

\fLJJSlJ[s5NJ`].map(c=>`${t=(c.charCodeAt()^565).toString(2)}${[...t].reverse().join``}
`.replace(/./g,b=>` ${s}`[b].repeat(w)).repeat(h)).join``

Dựa trên câu trả lời của @ Dennis. Tôi đoán bạn có thể loại bỏ một byte khác bằng cách sử dụng FF bằng chữ thay vì \f, nhưng tôi nghi ngờ tôi có thể dán một byte vào đây. Khi dùng thử, bạn cũng có thể muốn sử dụng \u01CAthay vìNJ nhân vật.

Đáng buồn là việc chuẩn bị một khoảng trắng cho đối số ký tự tốn toàn bộ 6 byte.

Python 2, 838 828 618 byte

Đã lưu 210 byte bằng cách sử dụng một chuỗi thay vì một mảng, nhờ Dennis cho đề xuất đó, tôi biết tôi có thể làm tốt hơn nữa, nhưng bây giờ nó là một cải tiến tốt.

Đây là điều tốt nhất tôi có thể làm, tôi không giỏi lắm với đồ họa trong dòng lệnh.

Tôi lấy con ma nhỏ làm căn cứ.

Tôi đang sử dụng ascii 219 theo mặc định, bởi vì với char đó, con ma trông khá tuyệt vời !!!

Chơi gôn

def g(c,s,w,h,l=""):
 x="c-20,c-1,s-18,c-1,c-1,s-7,c-4,s-7,c-1,c-1,s-5,c-8,s-5,c-1,c-1,s-4,c-10,s-4,c-1,c-1,s-3,c-12,s-3,c-1,c-1,s-3,c-12,s-3,c-1,c-1,s-3,c-3,s-2,c-2,s-2,c-3,s-3,c-1,c-1,s-2,c-4,s-2,c-2,s-2,c-4,s-2,c-1,c-1,s-2,c-14,s-2,c-1,c-1,s-2,c-14,s-2,c-1,c-1,s-2,c-2,s-2,c-2,s-2,c-2,s-2,c-2,s-2,c-1,c-1,s-2,c-1,s-1,c-2,s-2,c-2,s-2,c-2,s-1,c-1,s-2,c-1,c-1,s-2,c-14,s-2,c-1,c-1,s-2,c-2,s-1,c-3,s-2,c-3,s-1,c-2,s-2,c-1,c-1,s-2,c-1,s-3,c-2,s-2,c-2,s-3,c-1,s-2,c-1,c-1,s-18,c-1,c-20"
 for r in x.split(","):
  d=r.split("-");l+=d[0].replace("s",s).replace("c",c)*int(d[1])*w
  if len(l)==20*w:print(l+"\n")*h,;l=""

Hãy thử nó trên repl.it

Ung dung

def pacmanGhost(char = "█", sep = " ", width = 1, height = 1):
    coords = [[[char, 20]], [[char, 1], [sep, 18], [char, 1]],[[char, 1], [sep, 7], [char, 4], [sep, 7], [char, 1]], [[char, 1], [sep, 5], [char, 8], [sep, 5],
         [char, 1]], [[char, 1], [sep, 4], [char, 10], [sep, 4], [char, 1]], [[char, 1], [sep, 3], [char, 12], [sep, 3], [char, 1]], [[char, 1], [sep, 3],
         [char, 12], [sep, 3], [char, 1]], [[char, 1], [sep, 3], [char, 3], [sep, 2], [char, 2], [sep, 2], [char, 3], [sep, 3], [char, 1]], [[char, 1],
         [sep, 2], [char, 4], [sep, 2], [char, 2], [sep, 2], [char, 4], [sep, 2], [char, 1]], [[char, 1], [sep, 2], [char, 14], [sep, 2], [char, 1]],
         [[char, 1], [sep, 2], [char, 14], [sep, 2], [char, 1]], [[char, 1], [sep, 2], [char, 2], [sep, 2], [char, 2], [sep, 2], [char, 2], [sep, 2],
         [char, 2], [sep, 2], [char, 1]], [[char, 1], [sep, 2], [char, 1], [sep, 1], [char, 2], [sep, 2], [char, 2], [sep, 2], [char, 2], [sep, 1], [char, 1],
         [sep, 2], [char, 1]], [[char, 1], [sep, 2], [char, 14], [sep, 2], [char, 1]], [[char, 1], [sep, 2], [char, 2], [sep, 1], [char, 3], [sep, 2],
         [char, 3], [sep, 1], [char, 2], [sep, 2], [char, 1]], [[char, 1], [sep, 2], [char, 1], [sep, 3], [char, 2], [sep, 2], [char, 2], [sep, 3],
         [char, 1], [sep, 2], [char, 1]], [[char, 1], [sep, 18], [char, 1]], [[char, 20]]]
    for coord in coords:
        line = ""
        for element in coord:
            line = "{}{}".format(line, element[0] * element[1] * width)
        for i in range(height):
            print(line)
    return

Kiểm tra

Python 2, 244 byte

p,w,h=raw_input().split()
for i in range(18): mystr=''.join([(p if i=='1'else' ')*int(w)for i in str(10+(i%17==0))+format(ord('\xff\x00\x03\x0f\x1f??9y\x7f\x7ffY\x7fnF\x00\xff'[i]),'08b')]);print'\n'.join([mystr+mystr[::-1]for j in[1]*int(h)])

Python 2, 169 byte

def a(s,x,y):
    z=[]
    for c in u'\u01df #/?\x1f\x1f\x19Y__Fy_Nf \u01df':
        b="".join((s if d=="1"else" ")*x for d in bin(ord(c)^544)[2:]);z+=[b+b[::-1]]*y
    print"\n".join(z)

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

Giải trình:

u'\u01df #/?\x1f\x1f\x19Y__Fy_Nf \u01df'

Như trong câu trả lời của Dennis , mỗi ký tự trong chuỗi này đại diện cho biểu diễn nhị phân của một dòng của nửa bên trái của "hình ảnh", XOR 544.

for c in <unicode string>:

Đối với mỗi ký tự trong chuỗi, hãy làm như sau:

    bin(ord(c)^544)

Chuyển đổi ký tự thành biểu diễn số nguyên của nó, sau đó thực hiện XOR nhị phân với 544. Sau đó chuyển đổi số nguyên này thành một chuỗi ký tự của biểu diễn nhị phân của nó, như '0xb1111111111'.

    for d in <string>[2:]

Đối với mỗi ký tự trong sting, bắt đầu từ vị trí 2 (bỏ qua 0b ở đầu), hãy làm như sau:

    (s if d=="1"else" ")*x

Nếu ký tự == "1", thay thế nó bằng ký tự được cung cấp, nếu không thì thay thế nó bằng khoảng trắng. Sau đó sao chép ký tự này x lần. (x = 0 sẽ dẫn đến một chuỗi trống.)

    b="".join(<previously generated list of strings>)

Nối tất cả các chuỗi thành một chuỗi dài, cách nhau bởi một chuỗi rỗng "".

    z+=[b+b[::-1]]*y

tạo một chuỗi b + ngược lại của b, sau đó tạo một mảng chứa y thể hiện của chuỗi này (y = 0 sẽ tạo ra một danh sách trống []), sau đó nối danh sách này vào danh sách z.

print"\n".join(z)

Cuối cùng, in để sàng lọc từng chuỗi được sản xuất, cách nhau bởi các ngắt dòng.