Mam nadzieję, że to zdjęcie wygląda znajomo.

Jest to jeden z duchów Pacmana w jego „wrażliwym” stanie , po tym jak Pacman zjadł pigułkę mocy.

Wyzwanie

Wyobraź sobie naszego ducha w małej ramce, używając grafiki ASCII. W normalnej skali (więcej o tym później) każdy kwadrat na powyższym obrazku powinien odpowiadać jednemu znakowi, a ramka powinna mieć jednoznakowy rozdział w górę i w dół oraz dwuznakowy rozdział po lewej i prawej stronie ducha :

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

Ale to nie wygląda bardzo ładnie. #może nie być najlepszym wyborem dla aktywnych pikseli. Poza tym komórki postaci nie są kwadratowe, co sprawia, że ​​nasz przyjaciel wygląda bardziej upiornie niż on już jest.

Aby mieć większą elastyczność, obraz zmieni się zgodnie z trzema parametrami wejściowymi:

• Znak używany dla aktywnych pikseli;
• Współczynnik skali poziomej;
• Współczynnik skali pionowej.

Na przykład, z %, 4, 2ouput byłoby lepiej wygląda obraz

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

Zasady

Wszystkie wbudowane dozwolone.

Dane wejściowe są pobierane w dowolnym rozsądnym formacie i dowolnej kolejności. Pierwsze wejście powyżej (znak dla aktywnych pikseli) jest gwarantowanym drukowalnym znakiem ASCII (kody od 32 do 126).

Dopuszczalne są końcowe spacje po każdej linii lub końcowe nowe linie po ostatniej linii.

Code golf, najmniej bajtów wygrywa.

CJam, 53 51 49 bajtów

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

Pamiętaj, że trzech znaków nie można wydrukować. Wypróbuj online!

tło

Prawa połowa nieskalowanego wyjścia jest identyczna z lewym, więc wystarczy zakodować jedno z nich. Jeśli zamienimy spacje na zera, a spacje na jedynki, otrzymamy

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

gdzie każdą linię można interpretować jako liczbę binarną. To daje

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

Najprostszym sposobem na zakodowanie tych informacji jest zastąpienie każdej liczby całkowitej znakiem Unicode w tym punkcie kodowym, ale wszystkie one wymagają kodowania dwóch bajtów za pomocą UTF-8.

XORując liczby całkowite za pomocą 544, utrzymujemy wszystkie liczby całkowite oprócz dwóch poniżej 128 i unikamy bajtów zerowych.

Wynik to

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

jako liczby całkowite lub

ǟ #/?\x1f\x1f\x19Y__Fy_Nf ǟ

jako łańcuch znaków ucieczki.

Jak to działa

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

Dodano +2 do -ap

Sugestie dev-null save 9 bytes Naprawiono złą liczbę, jak zauważył Dennis

Uruchom za pomocą 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

z wyjątkiem tego, że ciąg "\xff\x00\x03\x0f\x1f\x3f\x3f\x39\x79\x7f\x7f\x66\x59\x7f\x6e\x46\x00\xff"powinien być zapisany w formie binarnej z pojedynczymi cudzysłowami

Spacja jako znak zastępujący staje się pustym ciągiem i prowadzi do krótkich linii. Ale i tak wszystko będzie puste

Dyalog APL, 64 bajty

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

To przyjmuje współczynnik skali jako lewy argument, a znak jako prawy argument, tj .:

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

Wyjaśnienie:

• ⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒': Lewa połowa ducha, bez granicy. (Jest symetryczny.) Każdy znak ma ustawiony wysoki bit, aby zapobiec wybieraniu znaków niedrukowalnych ⎕AV, ale używane są tylko pierwsze 7 bajtów.

• 0,⍪⍨0⍪0,0,: dodaj ramkę odstępów po lewej, u góry i na dole

• 1⍪⍨1⍪1,: dodaj ramkę po lewej, u góry i na dole
• ,∘⌽⍨: połącz z pionowym lustrem
• 1+: dodaj 1, ponieważ tablice są domyślnie indeksowane 1
• ' '⍵[... ]: użyj tej macierzy jako indeksu w ciągu ' '⍵, więc każde 0 zostanie zamapowane na puste, a każde 1 zostanie zamapowane na ⍵.
• ⍺,⊂: dołącz macierz i dołącz ją do współczynników skali
• /: składanie w prawo z następującą funkcją:
• /∘⍉: transponuj i skaluj w poziomie

MATL , 71 bajtów

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

Wypróbuj online!

Wyjaśnienie

Obraz jest symetryczny poziomo, więc należy zakodować tylko lewą połowę. Każdy wiersz 10-pikselowy jest kodowany binarnie jako liczba od 0 do 1023. Aktywne piksele są kodowane jako 0 zamiast 1, więc pierwszy wiersz ma liczbę 0 zamiast 1023.

Ponieważ kolejne wiersze różnią się tylko kilkoma pikselami, liczby są dalej kodowane w różny sposób. Tak więc każdy wiersz zostanie zdekodowany jako skumulowana suma wszystkich liczb aż do tego wiersza, a następnie nastąpi konwersja do wartości binarnej.

Potrzebne są wtedy liczby

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

0 wprowadza się w MATL-u za pomocą Ofunkcji, która pozwala uniknąć separatora z sąsiednimi liczbami. Ponadto znaki ujemne nie oznaczają dodatkowych bajtów, ponieważ służą jako separatory.

Po utworzeniu tablica jest sumowana, dekodowana binarnie i dublowana poziomo. Powstała tablica 2D służy do indeksowania ciągu dwóch znaków w celu uzyskania wyniku. Ten ciąg ma postać '% ', w której '%'jest znakiem wejściowym.

Jak zauważył @Conor, kod działa również z dwoma znakami jako danymi wejściowymi. W tym przypadku końcowy ciąg indeksowany będzie miał postać '%_ ', w której wejściem jest ciąg dwóch znaków '%_'. Spacja zostanie po prostu zignorowana, ponieważ tablica indeksowania odnosi się tylko do pierwszych dwóch znaków.

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 bajtów

-2 bajty dzięki @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]);}}

Wypróbuj online!

188 bajtów (niedrukowalne)

Dzięki uprzejmości @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]);}}

Wypróbuj online!

Nie dzieje się nic spektakularnego. Jak zauważyli inni, duch jest wysoce symetryczny. Sam obraz ma szerokość 20 jednostek, ale oprócz górnego i dolnego rzędu trzy kolumny znajdujące się najbardziej po prawej stronie są identyczne. To pozwala nam przechowywać połowę obrazu jako znaki, zamiast konieczności używania liczb całkowitych:

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

Powstały ciąg został odwrócony, aby wyodrębnić kilka bajtów o posiadaniu malejącej pętli for (rozwiązując również irytujący problem z ucieczkami szesnastkowymi). Inne pętle można bez problemu odwracać dzięki symetrii.

Każda postać jest przesuwana w lewo i ma obramowanie (ze szczególną ostrożnością w pierwszym i ostatnim rzędzie). W takim razie wystarczy tylko poprawnie wyskalować łańcuch.

Wszystkie pętle for sprawiają, że mam lepszy sposób.

Poważnie, 116 bajtów

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

Ta nowa linia jest ważna. 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

Taka sama strategia jak Dennisa CJam , ale wartości są zakodowane w postaci szesnastkowej, a nie XORed w 544, a manipulowanie łańcuchem jest znacznie trudniejsze w serialu.

Wypróbuj online!

BBC BASIC, 239 236 232 214 bajtów

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

Powołanie PROCM(1,1,35) tworzy ducha złożonego z # symboli. Argumentami dla PROCM są: skala pozioma, skala pionowa, wartość znaku ASCII.

Ten program będzie działał zarówno dla Brandy Basic, jak i BASIC 2 na oryginalnym Modelu B.

Partia, 740 722 720 bajtów

@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%!

Edycja: Zapisano 18 20 bajtów, usuwając niepotrzebne spacje.

Stax , 45 bajtów

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

Uruchom i debuguj

Wyjaśnienie:

"<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 bajtów

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

Na podstawie odpowiedzi @ Dennisa. Wydaje mi się, że możesz wygolić kolejny bajt, używając dosłownie FF zamiast \f, ale wątpię, czy mógłbym wkleić tutaj jeden bajt . Podczas wypróbowania tego możesz także użyć \u01CAzamiast NJpostaci.

Niestety przygotowanie spacji do argumentu znaku kosztuje całe 6 bajtów.

Python 2, 838 828 618 bajtów

Zaoszczędziłem 210 bajtów, używając łańcucha zamiast tablicy, dzięki Dennisowi za tę sugestię, wiem, że mogę ulepszyć, ale na razie jest to dobra poprawa.

To najlepsze, co mogę zrobić, nie jestem zbyt dobry z grafiką w wierszu poleceń.

Wziąłem małego ducha jako bazę.

Domyślnie używam ascii 219, ponieważ z tym charakterem duch wygląda całkiem niesamowicie !!!

Grał w golfa

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

Przymierz to repl.it

Bez golfa

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

Test

Python 2, 244 bajty

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 bajtów

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)

Wypróbuj online!

Wyjaśnienie:

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

Tak jak w odpowiedzi Dennisa , każdy znak w tym ciągu reprezentuje binarną reprezentację jednej linii lewej połowy „obrazu”, XOR 544.

for c in <unicode string>:

Dla każdego znaku w ciągu wykonaj następujące czynności:

    bin(ord(c)^544)

Przekształć znak w jego całkowitą reprezentację, a następnie wykonaj binarny XOR za pomocą 544. Następnie przekształć tę liczbę całkowitą w ciąg znaków jego reprezentacji binarnej, na przykład „0xb1111111111”.

    for d in <string>[2:]

Dla każdej postaci w żądle, zaczynając od pozycji 2 (która pomija 0b na początku), wykonaj następujące czynności:

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

Jeśli znak == „1”, zamień go na dostarczony znak, w przeciwnym razie zastąp go spacją. Następnie skopiuj ten znak x razy. (x = 0 spowoduje powstanie pustego ciągu).

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

Połącz wszystkie ciągi w jeden długi ciąg oddzielony pustym ciągiem „”.

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

zrób ciąg b + odwrotność b, następnie utwórz tablicę zawierającą y wystąpienia tego ciągu (y = 0 spowoduje utworzenie pustej listy []), a następnie dołącz tę listę do listy z.

print"\n".join(z)

Na koniec wydrukuj, aby przeskanować każdy z wyprodukowanych ciągów, oddzielonych podziałami linii.