Espero que esta imagen te resulte familiar.

Es uno de los fantasmas de Pacman en su estado "vulnerable" , después de que Pacman ha comido una píldora de poder.

El reto

Imagina a nuestro fantasma en un pequeño marco, usando el arte ASCII. A escala normal (más sobre esto más adelante), cada cuadrado en la imagen de arriba debe corresponder a un carácter, y el marco debe tener una separación de un carácter hacia arriba y hacia abajo, y una separación de dos caracteres a la izquierda y derecha del fantasma :

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

Pero esto no se ve muy bonito. #puede no ser la mejor opción para los píxeles activos. Además, las celdas de los personajes no son cuadradas, lo que hace que nuestro amigo se vea más fantasmal de lo que ya es.

Entonces, para tener más flexibilidad, la imagen cambiará de acuerdo con tres parámetros de entrada:

• Carácter que se utilizará para píxeles activos;
• Factor de escala horizontal;
• Factor de escala vertical.

Por ejemplo, la %, 4, 2que la salida sería la mejor imagen en busca

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

Reglas

Todas las construcciones permitidas.

Las entradas se toman en cualquier formato razonable y en cualquier orden. Se garantiza que la primera entrada anterior (carácter para píxeles activos) será un carácter ASCII imprimible (códigos 32 a 126).

Los espacios finales después de cada línea o las nuevas líneas posteriores a la última línea son aceptables.

Código de golf, menos bytes gana.

CJam, 53 51 49 bytes

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

Tenga en cuenta que tres de los caracteres no se pueden imprimir. Pruébalo en línea!

Fondo

La mitad derecha de la salida sin escala es idéntica a la izquierda, por lo que es suficiente codificar una de ellas. Si reemplazamos espacios con ceros y no espacios con unos, obtenemos

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

donde cada línea se puede interpretar como un número binario. Esto produce

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

La forma más fácil de codificar esta información es reemplazar cada número entero con el carácter Unicode en ese punto de código, pero todos requerirían dos bytes para codificarse con UTF-8.

Al XORingar los enteros con 544, mantenemos todos menos dos enteros por debajo de 128 y evitamos bytes nulos.

El resultado es

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

como enteros o

ǟ #/?\x1f\x1f\x19Y__Fy_Nf ǟ

como una cuerda escapada

Cómo funciona

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

Se agregó +2 por -ap

Sugerencias de dev-null save 9 bytes Se corrigió el conteo incorrecto según lo notó Dennis

Ejecutar usando 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

excepto que la cadena "\xff\x00\x03\x0f\x1f\x3f\x3f\x39\x79\x7f\x7f\x66\x59\x7f\x6e\x46\x00\xff"debe escribirse en forma binaria con comillas simples

El espacio como carácter de reemplazo se convierte en la cadena vacía y conduce a líneas cortas. Pero todo se verá en blanco de todos modos

Dyalog APL, 64 bytes

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

Esto toma el factor de escala como argumento izquierdo y el carácter como argumento derecho, es decir:

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

Explicación:

• ⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒': La mitad izquierda del fantasma, sin el borde. (Es simétrico). Cada carácter tiene su conjunto de bits alto, para evitar la selección de caracteres que no se imprimen ⎕AV, pero solo se utilizan los primeros 7 bytes.

• 0,⍪⍨0⍪0,0,: agrega un borde de espacios en blanco a la izquierda, arriba y abajo

• 1⍪⍨1⍪1,: agrega el marco a la izquierda, arriba y abajo
• ,∘⌽⍨: únala con su espejo vertical
• 1+: agrega 1, porque las matrices están indexadas en 1 de forma predeterminada
• ' '⍵[... ]: use esa matriz como un índice en la cadena ' '⍵, por lo que cada 0 se asigna a un espacio en blanco y cada 1 se asigna a ⍵.
• ⍺,⊂: encierra la matriz y únela a los factores de escala
• /: plegado a la derecha con la siguiente función:
• /∘⍉: transponer y escalar horizontalmente

MATL , 71 bytes

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

Pruébalo en línea!

Explicación

La imagen es simétrica horizontalmente, por lo que solo se debe codificar la mitad izquierda. Cada fila de 10 píxeles está codificada en binario como un número entre 0 y 1023. Los píxeles activos se codifican como 0 en lugar de 1, por lo que la primera fila es el número 0 en lugar de 1023.

Dado que las filas consecutivas difieren solo en unos pocos píxeles, los números se codifican de manera diferencial adicional. Por lo tanto, cada fila se decodificará como la suma acumulativa de todos los números hasta esa fila, seguido de la conversión a binario.

Los números necesarios son entonces

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

0 se introduce en MATL usando la Ofunción, que evita un separador con números vecinos. Además, los signos negativos no implican bytes adicionales, ya que sirven como separadores.

Una vez que se ha creado la matriz, se suma acumulativamente, se decodifica binariamente y se refleja horizontalmente. La matriz 2D resultante se usa para indexar una cadena de dos caracteres para producir el resultado. Esta cadena tiene la forma '% ', donde '%'es un carácter de entrada.

Como señaló @Conor, el código también funciona con dos caracteres como entrada. En este caso, la cadena final indexada será de la forma '%_ ', donde la entrada es una cadena de dos caracteres '%_'. El espacio simplemente se ignorará, porque la matriz de indexación solo aborda los dos primeros caracteres.

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 bytes

-2 bytes gracias 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\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]);}}

Pruébalo en línea!

188 bytes (no imprimibles)

Cortesía 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]);}}

Pruébalo en línea!

Nada espectacular pasando. Como otros notaron, el fantasma es muy simétrico. La imagen en sí tiene 20 unidades de ancho, pero a excepción de las filas superior e inferior, las tres columnas más a la derecha son idénticas. Esto nos permite almacenar la mitad de la imagen como caracteres en lugar de tener que usar números enteros:

#######  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 cadena resultante se invirtió para obtener unos pocos bytes al tener un bucle descendente (también resolviendo un problema molesto con escapes hexadecimales). Otros bucles podrían invertirse sin problemas gracias a la simetría.

Cada personaje se desplaza hacia la izquierda y se le asigna un borde (con especial cuidado en la primera y última fila). Entonces es solo cuestión de generar la cadena correctamente escalada.

Todos los bucles for me hacen sentir que hay una mejor manera.

En serio, 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

Esa nueva línea es 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

La misma estrategia que la respuesta CJam de Dennis , pero los valores están codificados en hexadecimal, en lugar de XOR con 544, y la manipulación de cadenas es mucho más difícil en serio.

Pruébalo en línea!

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

Llamar PROCM(1,1,35)produce el fantasma hecho de # símbolos. Los argumentos para PROCM son: escala horizontal, escala vertical, valor ASCII del carácter.

Este programa funcionará tanto para Brandy Basic como para BASIC 2 en un Modelo B original.

Lotes, 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%!

Editar: ahorró 18 20 bytes eliminando espacios innecesarios.

Stax , 45 bytes

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

Ejecutar y depurarlo

Explicación:

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

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

Basado en la respuesta de @ Dennis. Supongo que podría eliminar otro byte usando un FF literal en lugar de \f, pero dudo que pueda pegar uno aquí. Al probar esto, es posible que también desee usar en \u01CAlugar del NJpersonaje.

Lamentablemente, anteponer un espacio al argumento del personaje cuesta un total de 6 bytes.

Python 2, 838 828 618 bytes

Ahorré 210 bytes usando una cadena en lugar de una matriz, gracias a Dennis por esa sugerencia, sé que puedo mejorar aún más, pero por ahora es una buena mejora.

Esto es lo mejor que puedo hacer, no soy muy bueno con los gráficos en la línea de comandos.

Tomé el pequeño fantasma como base.

Estoy usando el ascii 219 por defecto, porque con ese personaje, ¡el fantasma se ve increíble!

Golfed

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

Pruébalo en repl.it

Sin golf

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

Prueba

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)

Pruébalo en línea!

Explicación:

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

Como en la respuesta de Dennis , cada carácter en esta cadena representa la representación binaria de una línea de la mitad izquierda de la "imagen", XOR 544.

for c in <unicode string>:

Para cada carácter en la cadena, haga lo siguiente:

    bin(ord(c)^544)

Transforme el carácter en su representación entera, luego realice un XOR binario con 544. Luego transforme este entero en una cadena de caracteres de su representación binaria, como '0xb1111111111'.

    for d in <string>[2:]

Para cada personaje en la picadura, comenzando en la posición 2 (que omite el 0b al principio), haga lo siguiente:

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

Si el carácter == "1", reemplácelo con el carácter proporcionado; de lo contrario, sustitúyalo por un espacio. Luego copia este personaje x veces. (x = 0 dará como resultado una cadena vacía).

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

Concatene todas las cadenas en una cadena larga, separada por una cadena vacía "".

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

haga una cadena de b + el reverso de b, luego cree una matriz que contenga y instancias de esta cadena (y = 0 producirá una lista vacía []), luego agregue esta lista a la lista z.

print"\n".join(z)

Finalmente, imprima en pantalla cada una de las cadenas producidas, separadas por saltos de línea.