J'espère que cette image vous semble familière.

C'est l'un des fantômes de Pacman dans son état "vulnérable" , après que Pacman a mangé une pillule de pouvoir.

Le défi

Imaginez notre fantôme dans un petit cadre, en utilisant l'art ASCII. À l’échelle normale (pour en savoir plus sur cela plus tard), chaque carré de l’image ci-dessus doit correspondre à un caractère et le cadre doit comporter une séparation d’un caractère vers le haut et le bas et une séparation de deux caractères à gauche et à droite du fantôme. :

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

Mais cela ne semble pas très joli. #peut ne pas être le meilleur choix pour les pixels actifs. De plus, les cellules de personnage ne sont pas carrées, ce qui donne à notre ami un air plus fantomatique qu'il ne l'est déjà.

Donc, pour plus de flexibilité, l’image changera en fonction de trois paramètres d’entrée:

• Caractère à utiliser pour les pixels actifs;
• Facteur d'échelle horizontale;
• Facteur d'échelle verticale.

Par exemple, avec %, 4, 2le ouput serait la meilleure image à la recherche

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

Règles

Toutes les tâches intégrées sont autorisées.

Les entrées sont prises dans n'importe quel format et dans n'importe quel ordre. La première entrée ci-dessus (caractère pour les pixels actifs) est un caractère imprimable ASCII (codes 32 à 126).

L'espace de fin après chaque ligne ou les nouvelles lignes après la dernière ligne sont acceptables.

Code golf, le moins d'octets gagne.

CJam, 53 51 49 octets

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

Notez que trois des caractères ne sont pas imprimables. Essayez-le en ligne!

Contexte

La moitié droite de la sortie non mise à l'échelle est identique à celle de gauche, il suffit donc de coder l'une d'entre elles. Si nous remplaçons les espaces par des zéros et les non-espaces par des uns, nous obtenons

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

où chaque ligne peut être interprétée comme un nombre binaire. Cela donne

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

Le moyen le plus simple de coder ces informations consiste à remplacer chaque entier par le caractère Unicode à ce point de code, mais ils nécessiteraient tous deux codages avec UTF-8.

En XORing les entiers avec 544, nous gardons tous les entiers sauf deux en dessous de 128 et évitons les octets nuls.

Le résultat est

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

sous forme d'entiers ou

ǟ #/?\x1f\x1f\x19Y__Fy_Nf ǟ

comme une chaîne échappée.

Comment ça marche

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

Ajouté +2 pour -ap

Suggestions de dev-null save 9 octets Correction du nombre incorrect corrigé tel que remarqué par Dennis

Courir en utilisant 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

sauf que la chaîne "\xff\x00\x03\x0f\x1f\x3f\x3f\x39\x79\x7f\x7f\x66\x59\x7f\x6e\x46\x00\xff"doit être écrite sous forme binaire avec des guillemets simples

L'espace en tant que caractère de remplacement devient la chaîne vide et conduit à des lignes courtes. Mais de toute façon, tout sera vide

Dyalog APL, 64 octets

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

Cela prend le facteur d'échelle comme argument de gauche et le caractère comme argument de droite, à savoir:

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

Explication:

• ⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒': La moitié gauche du fantôme, sans la frontière. (Il est symétrique.) Chaque caractère a son bit de poids fort afin d’empêcher la sélection de caractères non imprimables ⎕AV, mais seuls les 7 premiers octets sont utilisés.

• 0,⍪⍨0⍪0,0,: ajoute une bordure de blancs à gauche, en haut et en bas

• 1⍪⍨1⍪1,: ajouter le cadre à gauche, en haut et en bas
• ,∘⌽⍨: rejoignez-le avec son miroir vertical
• 1+: add 1, car les tableaux sont 1-indexés par défaut
• ' '⍵[... ]: utilisez cette matrice comme index dans la chaîne ' '⍵pour que chaque 0 soit associé à un blanc et que chaque 1 soit associé ⍵.
• ⍺,⊂: joindre la matrice et la joindre aux facteurs d'échelle
• /: pli droit avec la fonction suivante:
• /∘⍉: transposer et redimensionner horizontalement

MATL , 71 octets

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

Essayez-le en ligne!

Explication

L’image étant symétrique horizontalement, seule la moitié gauche doit être codée. Chaque ligne de 10 pixels est codée binaire comme un nombre compris entre 0 et 1023. Les pixels actifs sont codés comme 0 plutôt que 1, la première ligne est donc le numéro 0 plutôt que 1023.

Comme les lignes consécutives ne diffèrent que de quelques pixels, les nombres sont ensuite codés de manière différentielle. Ainsi, chaque ligne sera décodée en tant que somme cumulée de tous les nombres jusqu’à cette ligne, suivie de la conversion en binaire.

Les nombres nécessaires sont alors

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

0 est introduit dans MATL à l'aide de la Ofonction, ce qui évite un séparateur avec des nombres voisins. De plus, les signes négatifs n'impliquent pas d'octets supplémentaires car ils servent de séparateurs.

Une fois le tableau créé, il est cumulé, décodé en binaire et mis en miroir horizontalement. Le tableau 2D résultant est utilisé pour indexer une chaîne de deux caractères afin de produire le résultat. Cette chaîne est de la forme '% ', où'%' est un caractère en entrée.

Comme noté par @Conor, le code fonctionne également avec deux caractères en entrée. Dans ce cas, la dernière chaîne indexée sera de la forme '%_ 'où l'entrée est une chaîne à deux caractères '%_'. L'espace sera simplement ignoré, car le tableau d'indexation ne traite que les deux premiers caractères.

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 octets

-2 octets grâce à @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]);}}

Essayez-le en ligne!

188 octets (non imprimables)

Gracieuseté de @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]);}}

Essayez-le en ligne!

Rien de spectaculaire ne se passe. Comme d'autres remarqués, le fantôme est très symétrique. L'image elle-même a une largeur de 20 unités, mais à l'exception des lignes du haut et du bas, les trois colonnes les plus à droite sont identiques. Cela nous permet de stocker la moitié de l'image sous forme de caractères au lieu d'utiliser des entiers:

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

La chaîne résultante a été inversée afin de gagner quelques octets lorsqu’une boucle for décroissante (résolvant également un problème gênant lié aux échappements hexadécimaux). D'autres boucles peuvent être retournées sans problème grâce à la symétrie.

Chaque personnage est décalé à gauche et se voit attribuer une bordure (avec un soin particulier sur les première et dernière rangées). Ensuite, il suffit de sortir la chaîne correctement mise à l'échelle.

Toutes les boucles for me font penser qu'il existe un meilleur moyen.

Sérieusement, 116 octets

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

Cette nouvelle ligne est importante. 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

Même stratégie que celle de Dennis dans CJam , mais les valeurs sont codées en hexa, plutôt qu'en XOR avec 544, et la manipulation des chaînes est beaucoup plus difficile dans Seriously.

Essayez-le en ligne!

BBC BASIC, 239 236 232 214 octets

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

L'appel PROCM(1,1,35)produit le fantôme composé de # symboles. Les arguments de PROCM sont les suivants: échelle horizontale, échelle verticale, valeur ASCII du caractère.

Ce programme fonctionnera à la fois pour Brandy Basic et BASIC 2 sur un modèle B. original.

Lot, 740 722 720 octets

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

Edit: Sauvegardé 18 20 octets en supprimant les espaces inutiles.

Stax , 45 octets

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

Exécuter et déboguer

Explication:

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

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

Basé sur la réponse de @ Dennis. J'imagine que vous pourriez supprimer un octet en utilisant un FF littéral au lieu de \f, mais je doute que je puisse en coller un ici. En essayant cela, vous voudrez peut-être aussi utiliser à la \u01CAplace duNJ personnage à la place.

Malheureusement, ajouter un espace à l'argument de caractère coûte 6 octets entiers.

Python 2, 838 828 618 octets

Sauvegardé 210 octets en utilisant une chaîne au lieu d'un tableau, merci à Dennis pour cette suggestion, je sais que je peux faire encore mieux, mais pour l'instant c'est une bonne amélioration.

C'est le mieux que je puisse faire, je ne suis pas très bon avec les graphiques en ligne de commande.

J'ai pris le petit fantôme comme base.

J'utilise l'asci 219 par défaut, car avec ce personnage, le fantôme a l'air génial !!!

Golfé

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

Essayez-le sur 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

Tester

Python 2, 244 octets

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 octets

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)

Essayez-le en ligne!

Explication:

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

Comme dans la réponse de Dennis , chaque caractère de cette chaîne représente la représentation binaire d'une ligne de la moitié gauche de "l'image", XOR 544.

for c in <unicode string>:

Pour chaque caractère de la chaîne, procédez comme suit:

    bin(ord(c)^544)

Transformez le caractère en sa représentation entière, puis effectuez un XOR binaire avec 544. Puis transformez cet entier en une chaîne de caractères de sa représentation binaire, telle que '0xb1111111111'.

    for d in <string>[2:]

Pour chaque caractère de la piqûre, en partant de la position 2 (qui saute le 0b au début), procédez comme suit:

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

Si le caractère == "1", remplacez-le par le caractère fourni, sinon remplacez-le par un espace. Copiez ensuite ce caractère x fois. (x = 0 donnera une chaîne vide.)

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

Concaténez toutes les chaînes en une seule chaîne longue, séparée par une chaîne vide "".

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

créez une chaîne de b + l'inverse de b, puis créez un tableau contenant y instances de cette chaîne (y = 0 produira une liste vide []), puis ajoutera cette liste à la liste z.

print"\n".join(z)

Enfin, imprimez sur chacune des chaînes produites, en les séparant par des sauts de ligne.