Ich hoffe, dieses Bild kommt Ihnen bekannt vor.

Es ist einer von Pacmans Geistern in seinem "verletzlichen" Zustand , nachdem Pacman eine Kraftpille gegessen hat.

Die Herausforderung

Stellen Sie sich unseren Geist in einem kleinen Rahmen mit ASCII-Kunst vor. Bei normaler Skalierung (dazu später mehr) sollte jedes Quadrat im obigen Bild einem Zeichen entsprechen, und der Rahmen sollte links und rechts vom Geist einen Abstand von einem Zeichen nach oben und unten sowie einen Abstand von zwei Zeichen aufweisen :

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

Aber das sieht nicht sehr hübsch aus. #ist möglicherweise nicht die beste Wahl für die aktiven Pixel. Außerdem sind die Zeichenzellen nicht quadratisch, wodurch unser Freund geisterhafter aussieht, als er es bereits ist.

Um mehr Flexibilität zu erhalten, ändert sich das Bild entsprechend drei Eingabeparametern:

• Zeichen, das für aktive Pixel verwendet werden soll;
• Horizontaler Skalierungsfaktor;
• Vertikaler Skalierungsfaktor.

Zum Beispiel mit %, 4, 2wäre die ouput desto besser aussehendes Bild

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

Regeln

Alle eingebauten erlaubt.

Eingaben werden in jedem vernünftigen Format und in jeder Reihenfolge vorgenommen. Bei der obigen ersten Eingabe (Zeichen für aktive Pixel) handelt es sich garantiert um ein druckbares ASCII-Zeichen (Codes 32 bis 126).

Leerzeichen nach jeder Zeile oder Zeilenumbrüche nach der letzten Zeile sind zulässig.

Code Golf, gewinnt die wenigsten Bytes.

CJam, 53 51 49 Bytes

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

Beachten Sie, dass drei der Zeichen nicht druckbar sind. Probieren Sie es online!

Hintergrund

Die rechte Hälfte der nicht skalierten Ausgabe ist identisch mit der linken, daher ist es ausreichend, eine davon zu codieren. Wenn wir Leerzeichen durch Nullen und Nicht-Leerzeichen durch Einsen ersetzen, erhalten wir

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

Dabei kann jede Zeile als Binärzahl interpretiert werden. Dies ergibt

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

Die einfachste Methode zum Codieren dieser Informationen besteht darin, jede Ganzzahl an diesem Codepunkt durch das Unicode-Zeichen zu ersetzen. Für die Codierung mit UTF-8 sind jedoch zwei Byte erforderlich.

Durch XOR-Verknüpfung der Ganzzahlen mit 544 halten wir alle bis auf zwei Ganzzahlen unter 128 und vermeiden Nullbytes.

Das Ergebnis ist

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

als ganze Zahlen oder

ǟ #/?\x1f\x1f\x19Y__Fy_Nf ǟ

als entkommene Zeichenfolge.

Wie es funktioniert

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

+2 für hinzugefügt -ap

Vorschläge von dev-null speichern 9 Bytes Fehler behoben, der von Dennis bemerkt wurde

Führen Sie mit 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

mit der Ausnahme, dass die Zeichenfolge "\xff\x00\x03\x0f\x1f\x3f\x3f\x39\x79\x7f\x7f\x66\x59\x7f\x6e\x46\x00\xff"in binärer Form mit einfachen Anführungszeichen geschrieben werden sollte

Leerzeichen als Ersatzzeichen wird zur leeren Zeichenkette und führt zu kurzen Zeilen. Aber es wird sowieso alles leer aussehen

Dyalog APL, 64 Bytes

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

Dies nimmt den Skalierungsfaktor als linkes Argument und das Zeichen als rechtes Argument, dh:

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

Erläuterung:

• ⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒': Die linke Hälfte des Geistes, ohne Rand. (Es ist symmetrisch.) Für jedes Zeichen ist ein hohes Bit festgelegt, um zu verhindern, dass nicht druckbare Zeichen ausgewählt ⎕AVwerden. Es werden jedoch nur die ersten 7 Bytes verwendet.

• 0,⍪⍨0⍪0,0,: Fügen Sie links, oben und unten einen Rand aus Leerzeichen hinzu

• 1⍪⍨1⍪1,: Fügen Sie den Rahmen links, oben und unten hinzu
• ,∘⌽⍨: mit seinem vertikalen Spiegel verbinden
• 1+: addiere 1, da Arrays standardmäßig 1-indiziert sind
• ' '⍵[... ]: Verwenden Sie diese Matrix als Index für die Zeichenfolge ' '⍵, sodass jede 0 einer Leerstelle und jede 1 einer Leerstelle zugeordnet wird ⍵.
• ⍺,⊂: Schließe die Matrix ein und verbinde sie mit den Skalierungsfaktoren
• /: rechte Falte mit folgender Funktion:
• /∘⍉: transponieren und horizontal skalieren

MATL , 71 Bytes

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

Probieren Sie es online!

Erläuterung

Das Bild ist horizontal symmetrisch, sodass nur die linke Hälfte codiert werden muss. Jede 10-Pixel-Zeile ist als Zahl zwischen 0 und 1023 binär codiert. Aktive Pixel sind eher als 0 als als 1 codiert, sodass die erste Zeile eher als 0 als 1023 nummeriert ist.

Da sich aufeinanderfolgende Zeilen nur um wenige Pixel unterscheiden, werden die Zahlen weiter differenziell codiert. Jede Zeile wird also als kumulative Summe aller Zahlen bis zu dieser Zeile dekodiert, gefolgt von der Konvertierung in Binär.

Die benötigten Nummern sind dann

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

0 wird in MATL mit der OFunktion eingeführt, die ein Trennzeichen mit benachbarten Zahlen vermeidet. Außerdem bedeuten negative Vorzeichen keine zusätzlichen Bytes, da sie als Trennzeichen dienen.

Sobald das Array erstellt wurde, wird es kumuliert summiert, binär decodiert und horizontal gespiegelt. Das resultierende 2D-Array wird verwendet, um eine Zeichenfolge mit zwei Zeichen zu indizieren, um das Ergebnis zu erzeugen. Diese Zeichenfolge hat die Form '% ', wobei '%'es sich um ein Eingabezeichen handelt.

Wie von @Conor bemerkt, funktioniert der Code auch mit zwei Zeichen als Eingabe. In diesem Fall hat die letzte indizierte Zeichenfolge die Form '%_ ', in der die Eingabe eine Zeichenfolge mit zwei Zeichen ist '%_'. Das Leerzeichen wird einfach ignoriert, da das Indizierungsarray nur die ersten beiden Zeichen anspricht.

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 bis 197 Bytes

-2 Bytes dank @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]);}}

Probieren Sie es online!

188 Bytes (nicht druckbar)

Mit freundlicher Genehmigung von @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]);}}

Probieren Sie es online!

Nichts Spektakuläres. Wie andere bemerkt haben, ist der Geist sehr symmetrisch. Das Bild selbst ist 20 Einheiten breit, aber mit Ausnahme der oberen und unteren Zeilen sind die drei am weitesten rechts stehenden Spalten identisch. Dies ermöglicht es uns, die Hälfte des Bildes als Zeichen zu speichern, anstatt ganze Zahlen zu verwenden:

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

Die resultierende Zeichenfolge wurde umgekehrt, um bei einer absteigenden for-Schleife einige Bytes herauszuholen (was auch ein ärgerliches Problem mit hexadezimalen Escapezeichen behebt). Andere Loops können dank Symmetrie problemlos umgedreht werden.

Jedes Zeichen wird nach links verschoben und mit einem Rand versehen (mit besonderer Sorgfalt in der ersten und letzten Zeile). Dann geht es nur noch darum, den String richtig skaliert auszugeben.

All die for-Schleifen geben mir das Gefühl, dass es einen besseren Weg gibt.

Im Ernst, 116 Bytes

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

Diese Zeilenumbruch ist wichtig. 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

Dieselbe Strategie wie Dennis ' CJam-Antwort , aber die Werte sind hexadezimal codiert und nicht mit 544 XOR-verknüpft, und die Manipulation von Zeichenfolgen ist in Seriously viel schwieriger.

Probieren Sie es online!

BBC BASIC, 239 236 232 214 Bytes

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

Das Aufrufen PROCM(1,1,35)erzeugt den Geist, der aus # Symbolen besteht. Die Argumente für PROCM sind: horizontale Skala, vertikale Skala, ASCII-Zeichenwert.

Dieses Programm funktioniert sowohl für Brandy Basic als auch für BASIC 2 auf einem Originalmodell B.

Batch, 740 722 720 Bytes

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

Bearbeiten: 18 bis 20 Byte durch Entfernen unnötiger Leerzeichen gespeichert .

Stax , 45 Bytes

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

Führen Sie es aus und debuggen Sie es

Erläuterung:

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

Basierend auf der Antwort von @ Dennis. Ich schätze, Sie könnten ein anderes Byte abschneiden, indem Sie stattdessen einen wörtlichen FF verwenden \f, aber ich bezweifle, dass ich hier einen einfügen kann. Wenn Sie dies ausprobieren, möchten Sie möglicherweise auch \u01CAanstelle des NJZeichens verwenden.

Das Voranstellen eines Leerzeichens vor dem Zeichenargument kostet leider ganze 6 Bytes.

Python 2, 838 828 618 Bytes

Durch die Verwendung eines Strings anstelle eines Arrays wurden 210 Bytes eingespart. Dank Dennis für diesen Vorschlag weiß ich, dass ich noch bessere Ergebnisse erzielen kann, aber im Moment ist dies eine gute Verbesserung.

Dies ist das Beste, was ich tun kann, ich bin nicht sehr gut mit Grafiken in der Kommandozeile.

Ich nahm den kleinen Geist als Basis.

Ich benutze standardmäßig den ASCII 219, da mit diesem Char der Geist ziemlich genial aussieht !!!

Golf gespielt

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

Probieren Sie es auf repl.it

Ungolfed

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

Prüfung

Python 2, 244 Bytes

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 Bytes

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)

Probieren Sie es online!

Erläuterung:

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

Wie in Dennis 'Antwort repräsentiert jedes Zeichen in dieser Zeichenkette die binäre Darstellung einer Zeile der linken Hälfte des "Bildes", XOR 544.

for c in <unicode string>:

Führen Sie für jedes Zeichen in der Zeichenfolge die folgenden Schritte aus:

    bin(ord(c)^544)

Transformiere das Zeichen in seine Ganzzahldarstellung und führe dann ein binäres XOR mit 544 durch. Dann transformiere diese Ganzzahl in eine Zeichenkette seiner Binärdarstellung, wie '0xb1111111111'.

    for d in <string>[2:]

Führen Sie für jedes Zeichen im Stich beginnend bei Position 2 (wobei die 0b am Anfang übersprungen wird) die folgenden Schritte aus:

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

Wenn das Zeichen == "1" ist, ersetzen Sie es durch das angegebene Zeichen, andernfalls durch ein Leerzeichen. Dann kopiere dieses Zeichen x mal. (x = 0 führt zu einer leeren Zeichenfolge.)

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

Verketten Sie alle Zeichenfolgen zu einer langen Zeichenfolge, die durch eine leere Zeichenfolge "" getrennt ist.

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

Machen Sie eine Zeichenkette aus b + der Umkehrung von b, erstellen Sie dann ein Array mit y Instanzen dieser Zeichenkette (y = 0 erzeugt eine leere Liste []) und fügen Sie diese Liste an die Liste z an.

print"\n".join(z)

Zum Schluss drucken Sie, um jede der produzierten Zeichenfolgen durch Zeilenumbrüche getrennt zu prüfen.