Espero que esta imagem lhe pareça familiar.

É um dos fantasmas de Pacman em seu estado "vulnerável" , depois que Pacman comeu uma pílula de poder.

O desafio

Imagine nosso fantasma em um pequeno quadro, usando arte ASCII. Na escala normal (mais sobre isso posteriormente), cada quadrado na imagem acima deve corresponder a um caractere, e o quadro deve ter uma separação de um caractere para cima e para baixo, e uma separação de dois caracteres à esquerda e à direita do fantasma :

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

Mas isso não parece muito bonito. #pode não ser a melhor opção para os pixels ativos. Além disso, as células de caracteres não são quadradas, o que faz nosso amigo parecer mais fantasmagórico do que ele já é.

Portanto, para ter mais flexibilidade, a imagem mudará de acordo com três parâmetros de entrada:

• Caractere a ser usado para pixels ativos;
• Fator de escala horizontal;
• Fator de escala vertical.

Por exemplo, com %, 4, 2o ouput seria a melhor imagem olhando

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

Regras

Todos os builtins permitidos.

As entradas são obtidas em qualquer formato razoável e em qualquer ordem. A primeira entrada acima (caractere para pixels ativos) é garantida como um caractere ASCII imprimível (códigos 32 a 126).

O espaço à direita após cada linha ou as novas linhas à direita após a última linha são aceitáveis.

Código de golfe, menos bytes ganha.

CJam, 53 51 49 bytes

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

Observe que três dos caracteres não são imprimíveis. Experimente online!

fundo

A metade direita da saída sem escala é idêntica à esquerda, portanto basta codificar uma delas. Se substituirmos espaços por zeros e não espaços por uns, obteremos

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

onde cada linha pode ser interpretada como um número binário. Isso gera

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

A maneira mais fácil de codificar essas informações é substituir cada número inteiro pelo caractere Unicode nesse ponto de código, mas todos exigiriam que dois bytes fossem codificados com UTF-8.

Ao XORing dos números inteiros com 544, mantemos todos, exceto dois números inteiros, abaixo de 128 e evitamos bytes nulos.

O resultado é

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

como inteiros ou

ǟ #/?\x1f\x1f\x19Y__Fy_Nf ǟ

como uma corda escapada.

Como 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

Adicionado +2 para -ap

Sugestões por dev-null salvar 9 bytes Corrigida contagem incorreta conforme observado por Dennis

Corra 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

exceto que a string "\xff\x00\x03\x0f\x1f\x3f\x3f\x39\x79\x7f\x7f\x66\x59\x7f\x6e\x46\x00\xff"deve ser escrita em formato binário com aspas simples

O espaço como caractere de substituição se torna a cadeia vazia e leva a linhas curtas. Mas tudo ficará vazio de qualquer maneira

Dyalog APL, 64 bytes

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

Isso leva o fator de escala como argumento à esquerda e o caractere como argumento à direita, ou seja:

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

Explicação:

• ⍉(7/2)⊤⎕AV⍳'Äâ\⊥⊥∘)⍞⍞┬#⍞`⍒': A metade esquerda do fantasma, sem a borda. (É simétrico.) Cada caractere tem seu conjunto de bits alto, para impedir a seleção de caracteres não imprimíveis ⎕AV, mas apenas os primeiros 7 bytes são usados.

• 0,⍪⍨0⍪0,0,: adicione uma borda de espaços em branco à esquerda, superior e inferior

• 1⍪⍨1⍪1,: adicione o quadro à esquerda, superior e inferior
• ,∘⌽⍨: junte-se a ele com seu espelho vertical
• 1+: adicione 1, porque as matrizes são indexadas 1 por padrão
• ' '⍵[... ]: use essa matriz como um índice na string ' '⍵, para que cada 0 seja mapeado para um espaço em branco e cada 1 seja mapeado para ⍵.
• ⍺,⊂: coloque a matriz e junte-a aos fatores de escala
• /: dobre à direita com a seguinte função:
• /∘⍉: transpor e dimensionar horizontalmente

MATL , 71 bytes

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

Experimente online!

Explicação

A imagem é horizontalmente simétrica, portanto, apenas a metade esquerda precisa ser codificada. Cada linha de 10 pixels é codificada em binário como um número entre 0 e 1023. Os pixels ativos são codificados como 0 em vez de 1, portanto, a primeira linha é o número 0 em vez de 1023.

Como as linhas consecutivas diferem apenas em alguns pixels, os números são codificados ainda mais diferencialmente. Portanto, cada linha será decodificada como a soma acumulada de todos os números até essa linha, seguida pela conversão em binário.

Os números necessários são então

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

0 é introduzido no MATL usando o O função que evita um separador com números vizinhos. Além disso, sinais negativos não implicam bytes extras, pois servem como separadores.

Depois que a matriz é criada, ela é cumulativamente somada, decodificada em binário e espelhada horizontalmente. A matriz 2D resultante é usada para indexar uma sequência de dois caracteres para produzir o resultado. Essa string é da forma '% 'em que'%' está um caractere de entrada.

Conforme observado pelo @Conor, o código também funciona com dois caracteres como entrada. Nesse caso, a sequência final indexada será no formato '%_ ', onde a entrada é uma sequência de dois caracteres '%_'. O espaço será simplesmente ignorado, porque a matriz de indexação aborda apenas os dois primeiros 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 graças 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]);}}

Experimente online!

188 bytes (não imprimíveis)

Cortesia 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]);}}

Experimente online!

Nada de espetacular acontecendo. Como outros notaram, o fantasma é altamente simétrico. A imagem em si tem 20 unidades de largura, mas, exceto nas linhas superior e inferior, as três colunas mais à direita são idênticas. Isso nos permite armazenar metade da imagem como caracteres, em vez de precisar usar números inteiros:

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

A string resultante foi revertida para obter alguns bytes ao ter um loop descendente (também resolvendo um problema irritante com escapes hexadecimais). Outros loops podem ser invertidos sem problemas, graças à simetria.

Cada caractere é deslocado para a esquerda e recebe uma borda (com cuidado especial na primeira e na última linha). Então é apenas uma questão de produzir a string corretamente dimensionada.

Todos os loops for me fazem sentir que há uma maneira melhor.

Sério, 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

Essa nova linha é 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

A mesma estratégia da resposta CJam de Dennis , mas os valores são codificados em hexadecimal, em vez de XOR com 544, e a manipulação de strings é muito mais difícil em Seriously.

Experimente 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

A chamada PROCM(1,1,35)produz o fantasma feito de # símbolos. Os argumentos para o PROCM são: escala horizontal, escala vertical, valor ASCII do caractere.

Este programa funcionará tanto para o Brandy Basic quanto para o BASIC 2 em um modelo B.

Lote, 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: salvou 18 20 bytes removendo espaços desnecessários.

Stax , 45 bytes

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

Execute e depure

Explicação:

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

Com base na resposta de @ Dennis. Eu acho que você pode cortar outro byte usando um FF literal em vez de \f, mas duvido que possa colar um aqui. Ao tentar fazer isso, você também pode querer usar \u01CAo NJpersonagem.

Infelizmente, anexar um espaço ao argumento do caractere custa 6 bytes inteiros.

Python 2, 838 828 618 bytes

Economizei 210 bytes usando uma string em vez de uma matriz. Graças a Dennis por essa sugestão, sei que posso melhorar ainda mais, mas por enquanto é uma boa melhoria.

É o melhor que posso fazer, não sou muito bom com gráficos na linha de comando.

Tomei o pequeno fantasma como base.

Estou usando o ascii 219 por padrão, porque com esse caractere, o fantasma parece bem incrível !!!

Golfe

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

Experimente em 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

Teste

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)

Experimente online!

Explicação:

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

Como na resposta de Dennis , cada caractere nesta sequência representa a representação binária de uma linha da metade esquerda da "imagem", XOR 544.

for c in <unicode string>:

Para cada caractere na sequência, faça o seguinte:

    bin(ord(c)^544)

Transforme o caractere em sua representação inteira e execute um XOR binário com 544. Em seguida, transforme esse número inteiro em uma sequência de caracteres de sua representação binária, como '0xb1111111111'.

    for d in <string>[2:]

Para cada caractere na picada, começando na posição 2 (que ignora o 0b no início), faça o seguinte:

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

Se o caractere == "1", substitua-o pelo caractere fornecido, caso contrário, substitua-o por um espaço. Em seguida, copie esse caractere x vezes. (x = 0 resultará em uma sequência vazia.)

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

Concatene todas as cadeias em uma cadeia longa, separadas por uma cadeia vazia "".

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

faça uma sequência de b + o inverso de b, crie uma matriz contendo y instâncias dessa sequência (y = 0 produzirá uma lista vazia []) e, em seguida, acrescente essa lista à lista z.

print"\n".join(z)

Por fim, imprima para rastrear cada uma das seqüências produzidas, separadas por quebras de linha.