Aqui está um boneco de neve simples de arte ASCII :

_===_
(.,.)
( : )
( : )

Vamos fazer alguns amigos para ele. Este será o padrão geral para nossos snowpeople de arte ASCII:

 HHHHH
 HHHHH
X(LNR)Y
X(TTT)Y
 (BBB)

Os espaços à esquerda e os parênteses são sempre os mesmos para todos os snowpeople. As letras diferentes representam seções do padrão que podem ser alteradas individualmente. Cada seção possui exatamente quatro predefinições para quais caracteres ASCII podem preenchê-la. Ao misturar e combinar essas predefinições para todas as oito seções, podemos fazer uma variedade de snowpeople.

Todas as predefinições

^{(Observe que os espaços são colocados em linhas vazias, de modo que a forma da seção esteja sempre correta.)}

H é para o chapéu

1. Chapéu de palha

        
   _===_

2. Chapéu mexicano

    ___ 
   .....
   

3. Fez

     _  
    /_\ 
   

4. Chapéu russo

    ___ 
   (_*_)
   

N é para nariz / boca

1. Normal ,

2. Ponto .

3. Linha _

4. Nenhum

L é para o olho esquerdo

1. Ponto .

2. Ponto maior o

3. Maior ponto O

4. Fechadas -

R é para o olho direito

(Mesma lista do olho esquerdo.)

X é para o braço esquerdo

1. Braço normal

    
   <

2. Braço para cima

   \
    

3. Braço para baixo

    
   /

4. Nenhum

Y é para o braço direito

1. Braço normal

    
   >

2. Braço para cima

   /
    

3. Braço para baixo

    
   \

4. Nenhum

T é para torso

1. Botões :

2. Colete ] [

3. Braços Internos > <

4. Nenhum

B é para Base

1. Botões :

2. Pés " "

3. Plano ___

4. Nenhum

Desafio

Escreva um programa que HNLRXYTButilize uma cadeia de oito caracteres (via stdin ou linha de comando) no formato , onde cada letra é um dígito de 1 a 4 que indica qual predefinição usar para a seção correspondente do snowperson. Imprima o snowperson completo no stdout.

Por exemplo, a entrada 11114411é o boneco de neve na parte superior da página. (Primeiro 1: ele tem um chapéu de palha, segundo 1: ele tem um nariz normal, etc.)

Outro exemplo, o snowperson para entrada 33232124:

   _
  /_\
\(o_O)
 (] [)>
 (   )

Detalhes

• Quaisquer quantidades e combinações de espaços à esquerda / à direita e de novas linhas à esquerda / à direita são permitidas desde que ...

  • o boneco de neve tem todas as suas seções organizadas corretamente uma em relação à outra, e
  • nunca há mais de 64 caracteres de espaço em branco total (o padrão geral é de apenas 7 × 5, portanto, você provavelmente não atingirá esse limite).

  Você não precisa imprimir linhas / colunas do padrão se elas contiverem apenas espaços em branco. por exemplo, a linha vazia do chapéu de palha não é necessária.

• Você deve usar a ordem das peças, conforme indicado acima.

• Em vez de um programa, você pode escrever uma função que aceita a sequência de dígitos como argumento. A saída deve ser impressa normalmente ou retornada como uma sequência.

• Você pode tratar a entrada como um número inteiro em vez de uma sequência, se preferir.

Pontuação

O código mais curto em bytes vence.

Pergunta bônus: Qual das 65536 pessoas distintas de neve é ​​a sua favorita?

CJam, 135 134 132 130 130 125 125 bytes

0000000: 4e22285b200a5c225f2a295c2d2e2f6f2c3e4f3a3c3d5d225f  N"([ .\"_*)\-./o,>O:<=]"_
0000019: 2422dd7382d6bfab28707190992f240c362ee510262bd07a77  $".s....(pq../$.6...&+.zw
0000032: 08556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07  .Um...Vlgh....^....]...n.
000004b: 22323536624b623224663d4e2f7b5f2c342f2f7d25723a7e2e  "256bKb2$f=N/{_,4//}%r:~.
0000064: 3d2828342423346222205f0a20222e2a6f6f736572372f4e2a  =((4$#4b" _. ".*ooser7/N*

Para criar o arquivo em sua máquina, execute xxd -r > snowman.cjam , cole o hexdump reversível de cima, pressione Entere finalmente Ctrl+ D.

Como alternativa, você pode tentar o código online usando o intérprete CJam .

Bônus

Meu boneco de neve favorito é Olaf:

$ LANG=en_US cjam snowman.cjam <<< 12222212

 _===_
\(o.o)/
 ( : ) 
 (" ")

O inverno é um bom momento para ficar e abraçar, mas me coloque no verão e eu serei um ... feliz boneco de neve!

Idéia

A cadeia hexadecimal

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

codifica as opções possíveis para todas as partes do boneco de neve, incluindo as fixas. Vamos chamar essa string P .

Para decodificá-lo, convertemos P (aqui tratado como uma matriz de números inteiros) da base 256 para a base 20 e substituímos cada um dos números inteiros resultantes pelo caractere correspondente da string M :

([ 
"_*)\-./o,>O:<=]

Isso resulta na cadeia T :

/(_*_)"_===_/....., /_\ 
 ,._
-.oO
-.oO
   <\  /
   >/  \
    : ] [> <
    : " "___
 ((()

A primeira linha codifica todas as opções de chapéu, a última todas as partes do corpo fixas. As outras linhas contêm as 28 partes variáveis ​​do corpo.

Nós dividimos T em feeds de linha e dividimos as cadeias de caracteres da matriz resultante em quatro partes de igual comprimento. Em seguida, lemos a entrada de STDIN, pressionamos a matriz de seus dígitos na base 10 e selecionamos os elementos correspondentes das seqüências de caracteres divididas. Aproveitamos o fato de que as matrizes são agrupadas em CJam; portanto, o elemento no índice 4 de uma matriz de comprimento 4 é realmente o primeiro elemento. A última string dividida não corresponde a nenhuma entrada; portanto, ela será selecionada totalmente.

Lidamos com o chapéu deslocando o primeiro elemento da matriz resultante. O índice em M do primeiro caractere, lido como um número base 4, revela o número de espaços e sublinhados na primeira linha do chapéu. Imprimimos esses caracteres, um avanço de linha, um espaço e o restante da sequência deslocada. Em seguida, pressionamos um avanço de linha adicional na parte inferior da pilha.

Para as partes do corpo, concatenamos a string correspondente a todas elas. Vamos chamar essa string S . Para montar as partes do corpo, realizamos transliteração: tomarmos cada carácter da cadeia H , calcular o índice de tipo (M) e substituí-lo pelo carácter correspondente de S . Aproveitamos o fato de o operador de transliteração preencher automaticamente S para corresponder ao tamanho da classificação (M) repetindo o último caractere de S quantas vezes for necessário.

Finalmente, dividimos a string resultante em substrings de comprimento 7 e colocamos um avanço de linha entre cada par de substrings.

Código

Suponha-se que as variáveis Me Pconter as cadeias H e P .

N        e# Push a linefeed.
M_$      e# Push M and a sorted copy.
P256bKb  e# Push P and convert it from base 256 to base 20.
2$       e# Push a copy of M.
f=       e# Compute T by retrieving the proper chars from M.
N/       e# Split T at linefeeds.
{_,4//}% e# Divide each string into four substrings of equal length.
r:~      e# Read a number from STDIN and push the array of its digits in base 10.
.=       e# Get the corresponding chunks from T.
((       e# Shift out the first string and that string's first character.
4$#      e# Find its index in M.
4b       e# Compute its digits in base 4.
" _
 ".*     e# Repeat the space and underscore that many times in place.
oo       e# Print the result and the shifted string.
s        e# Flatten the remainder of the array. This pushes S.
er       e# Perform transliteration.
7/       e# Split into chunks of length 7.
N*       e# Join using linefeeds.

JavaScript ES6, 210 208 202 bytes

s=>` 0
8(213)9
4(6)5
 (7)`.replace(/\d/g,p=>`_===_1 ___
 .....1  _
  /_\\1 ___
 (_*_)1,1.1_11.1o101-1.1o101-1<11/11>11\\11 : 1] [1> <1   1 : 1" "1___1   11\\11 11/11 `.split(1)[s[p>7?p-4:p]-1+p*4]||' ')

Esta é uma função anônima; você o usa executando ([function code])('42232124'). A parte mais irritante disso foram os braços, que ocupam duas linhas, então eu tive que incluir o código para cima e para baixo.

O Snippet de pilha abaixo possui código de comentário não-golfado, sem ES6. E você pode usá-lo para testar facilmente o código e experimentar diferentes combinações. Edit: Estou me divertindo muito com isso. Eu adicionei vários novos recursos, incluindo uma maneira de gerar um boneco de neve aleatório.

Agradecemos a Yair Rand por salvar seis bytes.

var f=function(s){
  return' 0\n8(213)9\n4(6)5\n (7)' // Start with a placeholder string with all the static components
    .replace(/\d/g,function(p){ // Go through each placeholder number to replace it with its value
    // The massive string below holds all the possible body parts, separated by 1 for easy splitting.
    // The two at the end are for the top of the arms
    return'_===_1 ___\n .....1  _\n  /_\\1 ___\n (_*_)1,1.1_11.1o101-1.1o101\
-1<11/11>11\\11 : 1] [1> <1   1 : 1" "1___1   11\\11 11/11 '.split(1)
    [s[p>7?p-4:p]-1 // Get the value from the input string. If the current body part
                    // is the top of the two-line arms (8 or 9), drop it down to 4 or 5
                    // Subtract 1 to account for the 0-indexed array.
     +p*4] // multiply by 4 to skip to the relevant code
     ||' ' // To save bytes in the above string, spaces are empty strings, so replace them here
  })
}

// Code for the interactive version follows
// http://codepen.io/hsl/pen/bdEgej
function updateRadios(){$('input[type="radio"]').each(function(){if($(this).is(":checked")){var t=$(this).data("p"),i=$(this).data("v");input[t]=i}}),inputS=input.join(""),update()}var input=[],inputS=$("#code").val(),update=function(){$("#p").text(f(inputS)),$("#code").val(inputS)};$('input[type="radio"]').change(updateRadios),$("#code").keyup(function(){inputS=$(this).val(),update()}),updateRadios(),$("#random").click(function(){for(var t=0;8>t;t++)$("div:eq("+t+") input:eq("+Math.floor(4*Math.random())+")").prop("checked",!0);updateRadios()});

body{font-family:sans-serif}h2{font-size:18px;font-weight:400}label{display:block}div{display:inline-block;margin:0 10px}#code{width:70px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><div><h2>Hat</h2><label><input type="radio" name="p1" data-p="1" data-v="1"> Straw hat</label><label><input type="radio" name="p1" data-p="1" data-v="2"> Mexican hat</label><label><input type="radio" name="p1" data-p="1" data-v="3"> Fez</label><label><input type="radio" name="p1" data-p="1" data-v="4" checked> Russian hat</label></div><div><h2>Nose/mouth</h2><label><input type="radio" name="p2" data-p="2" data-v="1"> Normal</label><label><input type="radio" name="p2" data-p="2" data-v="2" checked> Dot</label><label><input type="radio" name="p2" data-p="2" data-v="3"> Line</label><label><input type="radio" name="p2" data-p="2" data-v="4"> None</label></div><div><h2>Left eye</h2><label><input type="radio" name="p3" data-p="3" data-v="1"> Dot</label><label><input type="radio" name="p3" data-p="3" data-v="2" checked> Bigger dot</label><label><input type="radio" name="p3" data-p="3" data-v="3"> Biggest dot</label><label><input type="radio" name="p3" data-p="3" data-v="4"> Closed</label></div><div><h2>Right eye</h2><label><input type="radio" name="p4" data-p="4" data-v="1"> Dot</label><label><input type="radio" name="p4" data-p="4" data-v="2"> Bigger dot</label><label><input type="radio" name="p4" data-p="4" data-v="3" checked> Biggest dot</label><label><input type="radio" name="p4" data-p="4" data-v="4"> Closed</label></div><div><h2>Left arm</h2><label><input type="radio" name="p5" data-p="5" data-v="1"> Normal</label><label><input type="radio" name="p5" data-p="5" data-v="2" checked> Upwards</label><label><input type="radio" name="p5" data-p="5" data-v="3"> Downwards</label><label><input type="radio" name="p5" data-p="5" data-v="4"> None</label></div><div><h2>Right arm</h2><label><input type="radio" name="p6" data-p="6" data-v="1" checked> Normal</label><label><input type="radio" name="p6" data-p="6" data-v="2"> Upwards</label><label><input type="radio" name="p6" data-p="6" data-v="3"> Downwards</label><label><input type="radio" name="p6" data-p="6" data-v="4"> None</label></div><div><h2>Torso</h2><label><input type="radio" name="p7" data-p="7" data-v="1"> Buttons</label><label><input type="radio" name="p7" data-p="7" data-v="2" checked> Vest</label><label><input type="radio" name="p7" data-p="7" data-v="3"> Inward arms</label><label><input type="radio" name="p7" data-p="7" data-v="4"> None</label></div><div><h2>Base</h2><label><input type="radio" name="p8" data-p="8" data-v="1"> Buttons</label><label><input type="radio" name="p8" data-p="8" data-v="2"> Feet</label><label><input type="radio" name="p8" data-p="8" data-v="3"> Flat</label><label><input type="radio" name="p8" data-p="8" data-v="4" checked> None</label></div><br><button id="random">Randomize</button><pre id="p"></pre><input type="text" id="code">

CJam, 164 bytes

Gera o boneco de neve da esquerda para a direita, de cima para baixo. Isso elimina a necessidade de qualquer tipo de operação de união ou reposicionamento de cordas, pois deixo cada pedaço do boneco de neve na pilha. E então, devido ao despejo automático de pilha no final dos programas:

♫ CJam quer construir um boneco de neve! ♫

q:Q;SS"
 _===_,___
 ....., _
  /_\,___
 (_*_)"',/0{Q=~(=}:G~N" \ "4G'(".oO-"_2G",._ "1G@3G')" / "5GN"< / "4G'(" : ] [> <   "3/6G')"> \ "5GNS'(" : \" \"___   "3/7G')

Experimente online.

Bônus

Pensando fora da caixa! 32443333dá uma noiva (wo) homem da neve. Você precisa tentar um pouco para vê-lo, mas existem os braços para dentro, fez + braços para baixo = véu, e a cabeça está realmente no fez / véu. A forma geralmente grande é o vestido ondulado, e os "olhos" e "nariz" são dobras no vestido.

   _
  /_\
 (-.-) 
/(> <)\
 (___)

Outras opções de "olho" são um pouco ousadas ...

Python, 276 289 bytes

V='.oO-'
def F(d):
 D=lambda i:int(d[i])-1
 print"  "+("","___"," _ ","___")[D(0)]+"\n "+\
"_. (=./_=._*=.\\__. )"[D(0)::4]+"\n"+\
" \\  "[D(4)]+"("+V[D(2)]+',._ '[D(1)]+V[D(3)]+")"+" /  "[D(5)]+'\n'+\
"< / "[D(4)]+"("+" ]> :    [< "[D(6)::4]+")"+"> \\ "[D(5)]+"\n ("+\
' "_ : _  "_ '[D(7)::4]+")"

Este código possui 8 bytes extras ( \* 4) para facilitar a leitura.

Constrói o boneco de neve pouco a pouco.

Bônus

F("44444432") dá "urso russo sonolento":

  ___    
 (_*_)
 (- -)
 (> <)
 (" ")

Python 2, 354 280 241 261 bytes

def s(g):H,N,L,R,X,Y,T,B=[int(c)-1for c in g];e='.oO-';print(' '*9+'_ _ ___ _ _\n\n\n\n    _. (=./_=._*=.\\__. )')[H::4]+'\n'+' \\  '[X]+'('+e[L]+',._ '[N]+e[R]+')'+' /  '[Y]+'\n'+'< / '[X]+"("+' ]> :    [< '[T::4]+')'+'> \\ '[Y]+'\n ('+' "_ : _  "_ '[B::4]+")"

A chamada s('33232124')fornece:

   _ 
  /_\ 
\(o_O) 
 (] [)>
 (   )

Mas meus favoritos são 44242123e 41341144:

  ___      ___
 (_*_)    (_*_)
\(o -)    (O,-) 
 (] [)>  <(   )>
 (___)    (   )

CJam, 150 145 bytes

Base converter todas as coisas!

"b8li'
U9gN;|"125:Kb8bl:~f="r  pL|P3{cR`@L1iT"Kb21b"G.HMtNY7VM=BM@$^$dX8a665V"KbFb"=_./ <[(*-oO,\":"f=_"/<[(""\>])"er+4/f=.=7/N*

O SE controla os imprimíveis, então aqui está uma cópia no Pastebin. Certifique-se de copiar a parte "RAW Paste Data", não a parte ao lado dos números das linhas. Você pode experimentá-lo online , mas o link permanente pode não funcionar em alguns navegadores.

Explicação

A "b8li'U9gN;|"125:Kb8bpparte gera a matriz

[1 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0 2 1 3 0 5 4 0 6 6 6 0 5 0 0 7 7 7 0]

que mapeia cada dígito da entrada para onde o dígito é usado. Qualquer coisa que seja comum a todas as entradas (por exemplo, espaços à esquerda e ()) recebe arbitrariamente um 0, exceto o primeiro que é atribuído 1, para que a conversão base possa funcionar.

l:~f=depois converte cada dígito em int e mapeia de acordo, por exemplo, para 14441133obtermos

[2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 3 2 4 1 2 1 1 3 3 3 1 2 1 1 4 4 4 1]

"G.HMtNY7VM=BM@$^$dX8a665V"KbFb"=_./ <[(*-oO,\":"f= dá a string

"_=./  /  < /  [<(((((_. _ _     _ __*=._-.oO ,._  \"_ :   : _"

após o que duplicamos, substitua /<[(por \>])e acrescente para fornecer uma sequência longa. Em seguida, dividimos a sequência em grupos de 4 e mapeamos de acordo com outra matriz "r pL|P3{cR`@L1iT"Kb21b, obtendo uma matriz de sequências de comprimento-4 descrevendo todas as opções possíveis em cada célula (por exemplo, _=./são todas as opções possíveis para o segundo caractere na segunda linha, começando pela Chapéu russo).

Finalmente, mapeamos as opções para as entradas de acordo .=, divididas em linhas de comprimento 7 7/e riffle em algumas novas linhas N*.

Execuções de teste

11111111

 _===_ 
 (.,.) 
<( : )>
 ( : )

22222222
  ___  
 ..... 
\(o.o)/
 (] [) 
 (" ")

33333333
   _   
  /_\  
 (O_O) 
/(> <)\
 (___)

44444444
  ___  
 (_*_) 
 (- -) 
 (   ) 
 (   )

TI-BASIC, 397 bytes

Importante: Se você quiser testar isso, faça o download aqui e envie esse arquivo para sua calculadora. Faz não tentar copiar o código abaixo em editor de programa da TI-Connect CE ou SourceCoder 3 ou algo para construir e enviá-lo para a calculadora; no caso do TI-Connect, ele diz que possui um token inválido. O SC3 usa a barra invertida como delimitador de comentários ( //inicia um comentário no SC3; no /\/entanto, exportará como// ) e, portanto, não exportará os braços e o chapéu corretamente, fazendo com que o programa exiba as partes incorretas do corpo e jogue um ERRO: DOMÍNIO de vez em quando. Coisas divertidas!

Importante # 2: Estou com preguiça de corrigir o download no momento. Portanto, quando você transferi-lo para o seu calc, altere o 7na terceira linha, de baixo para X+6. O código abaixo é corrigido se você precisar comparar.

Input Str9
seq(inString("1234",sub(Str9,I,1)),I,1,length(Ans→L1
"      ___   _   ___ →Str1
"_===_..... /_\ (_*_)→Str2
",._ →Str3
"•oO-→Str4
"<\/ →Str5
">/\ →Str6
" : ] [> <   →Str7
" : ¨ ¨___   →Str8
"Str1Str2Str3Str4Str5Str6Str7Str8→Str0
For(X,3,5
Output(X,2,"(   )
End
L1
Output(3,3,sub(Str4,Ans(3),1)+sub(Str3,Ans(2),1)+sub(Str4,Ans(4),1
Ans(5
Output(4-(Ans=2),1,sub(Str5,Ans,1
L1(6
Output(4-(Ans=2),7,sub(Str6,Ans,1
L1-1
For(X,1,2
Output(X+3,3,sub(expr(sub(Str0,X+6,1)),1+3Ans(X+6),3
Output(X,2,sub(expr(sub(Str0,X,1)),1+5Ans(1),5
End

Bônus: Gosto particularmente 12341214.

 _===_
 (O.-)/
<( : )
 (   )

Algumas notas:

• Definitivamente, pode ser jogado mais, sem dúvida. Estou quase certo de que posso combinar a maioria, se não todos, da saída em um único loop For (. Além disso, tenho certeza de que posso mesclar algumas strings.
• No Str4 (os olhos) eu uso o "ponto da trama" ([2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct) ) em oposição a um ponto para que os olhos não se alinhem à vírgula, porque isso parece estranho como o inferno.
• No Str8 (base), tive que usar uma diérese (¨) em vez de aspas duplas, porque não há como escapar de caracteres no TI-BASIC, e aspas duplas são usadas para iniciar / finalizar seqüências de caracteres.
• No TI-BASIC, não há necessidade de fechar parênteses e colchetes se forem seguidos por dois pontos, nova linha ou → (usados ​​para atribuição de var), e aspas duplas (cadeias) podem permanecer não fechadas quando seguidas por uma nova linha ou →.

C, 280 272 264 bytes

Apenas parcialmente jogou golfe neste momento, mas este é um desafio divertido.

#define P(n)[s[n]&3],
f(char*s){printf("  %.3s\n %.5s\n%c(%c%c%c)%c\n%c(%.3s)%c\n (%.3s)",
"___   ___ _"+*s%4*3,"(_*_)_===_..... /_\\"+*s%4*5,"  \\ "P(4)"-.o0"P(2)    
" ,._"P(1)"-.o0"P(3)"  /"P(5)" < /"P(4)"    : ] [> <"+s[6]%4*3," > \\"P(5)
"    : \" \"___"+s[7]%4*3);}

(Com alguns \ n extras para facilitar a leitura.) Espero que o define desapareça com mais golfe.

Uma versão mais legível é

#define P(n)[s[n]&3],
f(char *s) {
  printf("  %.3s\n"
         " %.5s\n"
         "%c(%c%c%c)%c\n"
         "%c(%.3s)%c\n"
         " (%.3s)",
         "___   ___ _"+*s%4*3,                  /* Top of hat. */
         "(_*_)_===_..... /_\\"+*s%4*5,         /* Lower hat. */
         "  \\ "P(4)                            /* Upper left arm. */
         "-.o0"P(2)                             /* Left eye. */
         " ,._"P(1)                             /* Nose. */
         "-.o0"P(3)                             /* Right eye. */
         "  /"P(5)                              /* Upper right arm. */
         " < /"P(4)                             /* Lower left arm. */
         "    : ] [> <"+s[6]%4*3,               /* Torso. */
         " > \\"P(5)                            /* Lower right arm. */
         "    : \" \"___"+s[7]%4*3              /* Base. */
         );
}

C, 212 bytes

d;main(){char*t="##3#b#b3#bbb3#b#b##\r#3b1#+3@12b3@1b-3@1_b3b1#,#\r7#_##+51rR04/1b#61rR0,8#2##\r7?#2#+9#`A#9=###9#^?#,8A#_#\r#+:#%b#:=#b#:#%b#,#",p[9];for(gets(p);d=*t++;putchar(d-3))d=d<51?d:(p[d-51]-53)[t+=4];}

Uma versão legível:

d;
main()
{
    char *t = "##3#b#b3#bbb3#b#b##\r"
              "#3b1#+3@12b3@1b-3@1_b3b1#,#\r"
              "7#_##+51rR04/1b#61rR0,8#2##\r"
              "7?#2#+9#`A#9=###9#^?#,8A#_#\r"
              "#+:#%b#:=#b#:#%b#,#",
        p[9]; // 9 bytes is just enough for the input string of length 8

    for (gets(p); d = *t++; putchar(d-3))
        d = d < 51 ? d : (p[d - 51] - 53)[t += 4];
}

Tirei a ideia da resposta de Reto Koradi . Houve várias melhorias divertidas que fiz, que podem justificar a publicação de uma resposta separada:

• Convertido de função em programa (+10)
• Novas linhas movidas para a cadeia de controle (-7)
• Adicionado 3 a todos os códigos de caracteres para ter menos caracteres de escape como \"(-3)
• Leitura da string com incremento automático; também substituiut[i++] por *t++(-4)
• Substituído whileporfor ; removido {}(-4)
• Terminação de loop simplificada: leitura até \0 (-9)
• Transformado t[...],t+=4para(...)[t+=4] eliminar o operador de vírgula (-1)

Por que todo esse problema? Para compartilhar meu favorito, fantasma da neve:

   _
  /_\
\(. .)/
 (   )
 (___)

JavaScript, 489 (sem novas linhas e guias)

x=' ';
d="   ";
h=['\n_===_',' ___ \n.....','  _  \n /_\\ ',' ___ \n(_*-)'];
n=[',','.','_',x];
e=['.','o','O','-'];
y=['>',,'\\',x];
u=['<',,'/',x];
t=[' : ','[ ]','> <',d;
b=[' : ','" "',"___",d];

j=process.argv[2].split('').map(function(k){return parseInt(k)-1});
q=j[4]==1;
w=j[5]==1;

console.log([
    h[j[0]].replace(/(.*)\n(.*)/g, " $1\n $2"),
    (q?'\\':x)+'('+e[j[2]]+n[j[1]]+e[j[3]]+')'+(w?'/':x),
    (!q?u[j[4]]:x)+'('+t[j[6]]+')'+(!w?y[j[5]]:x),
    x+'('+b[j[7]]+')'].join('\n'));

correr com node snowman.js 33232124

Pitão, 203 bytes

M@GCHgc"  ___

  ___
   _"bhzgc" (_*_)
 _===_
 .....
  /_\\"bhzs[g"  \ "@z4\(g"-.oO"@z2g" ,._"@z1g"-.oO"@z3\)g"  / "@z5)s[g" < /"@z4\(gc"   
 : 
] [
> <"b@z6\)g" > \\"@z5)++" ("gc"   
 : 
\" \"
___"bez\)

Ri muito. Experimente online: Pyth Compiler / Executor

Explicação

Primeiro, defino uma função auxiliar g, que recebe uma lista e um caractere como entrada, converte o caractere em seu valor ASCII e leva o elemento correspondente (disposição modular).

M@GCH  def g(G,H): return G[ord(H)]

O outro é apenas imprimir linha por linha. Por exemplo, a primeira linha é:

 c"  ___\n\n  ___\n   _"b     split the string "  ___\n\n  ___\n   _" at "\n"
                         hz   first char in input
g                             apply g and print

Btw. Eu experimentei um pouco .F"{:^7}", o que centraliza uma corda. Com ele, pude salvar alguns espaços no meu código, mas ele não salva bytes no final.

R, 436 437 bytes

Aqui está minha primeira tentativa no code-golf , usando R, que não é o mais curto, mas ainda divertido. Pelo menos eu estou batendo JavaScript (por enquanto) ...

H=c("_===_"," ___\n .....","  _\n  /_\\"," ___\n (_*_)")
N=c(",",".","_"," ")
L=c(".","o","O","-")
X=c(" ","\\"," "," ")
S=c("<"," ","/"," ")
Y=c(" ","/"," ","")
U=c(">"," ","\\","")
T=c(" : ","] [","> <","   ")
B=c(" : ","\" \"","___","   ")
f=function(x){i=as.integer(strsplit(x,"")[[1]]);cat(" ",H[i[1]],"\n",X[i[5]],"(",L[i[3]],N[i[2]],L[i[4]],")",Y[i[6]],"\n",S[i[5]],"(",T[i[7]],")",U[i[6]],"\n"," (",B[i[8]], ")",sep="")}

Testando:

> f("12344321")
 _===_
 (O.-) 
 (] [)\
 ( : )

Na verdade, eu lutei Xe fui Ymultilinha, mas com coisas no meio, acabei separando cada linha em ( X, S) e ( Y, U).

function e a conversão de string para inteiro também são muito detalhadas.

Editar 436 => 437

Tinha que consertar um espaço vazio ausente observado pelo @OganM

Eu poderia reduzir para 428 substituindo as quebras de linha entre variáveis ​​por ;, mas o código "de uma linha" parece tão ruim e ilegível que não serei tão ganancioso.

Haskell, 361 306 289 bytes

o l a b=take a$drop((b-1)*a)l
n="\n"
p i=id=<<["  ",o"    \n _===____ \n ..... _  \n  /_\\ ___ \n (_*_)"11a,n,o" \\  "1e,o"(.(o(O(-"2c,o",._ "1 b,o".)o)O)-)"2d,o" /  "1f,n,o"< / "1e,o"( : )(] [)(> <)(   )"5g,o"> \\ "1f,n," (",o" : )\" \")___)   )"4h]where[a,b,c,d,e,f,g,h]=map(read.(:[]))i

Uso:

putStrLn $ p "12333321"

 _===_
 (O.O) 
/(] [)\
 ( : )

Como funciona: indexe todos os elementos da lista [hat options, left upper arm options, left eye options, ..., base options]com o número de entrada correspondente e concatená-lo em uma única lista. Dividi o braço esquerdo e direito em uma parte superior e inferior, para poder construir o boneco de neve linha por linha.

O meu favorito é o clássico 11112211.

Editar: alternado da lista de cadeias de caracteres para as partes (chapéu, olho, ...). Precisa de um segundo parâmetro, o comprimento da substring a ser utilizada.

Edit II: substrings comuns extraídos

C, 233 230 bytes

char*t="  0 _ _0 ___0 _ _   0_. (0=./_0=._*0=.\\_0_. ) 4 \\  (2.oO-1,._ 3.oO-)5 /  4< / (6 ]> 6:   6 [< )5> \\  (7 \"_ 7: _ 7 \"_ ) ";i,r,d;f(char*p){while(r++<35){d=t[i]-48;putchar(t[d<0?i:i+p[d]-48]);i+=d<0?1:5;r%7?0:puts("");}}

Com novas linhas e espaços em branco para melhor legibilidade:

char* t = "  0 _ _0 ___0 _ _   0_. (0=./_0=._*0=.\\_0_. ) 4 \\  (2.oO-1,._ 3.oO-)5 /  4< / (6 ]> 6:   6 [< )5> \\  (7 \"_ 7: _ 7 \"_ ) ";
i, r, d;
f(char* p)
{
    while (r++ < 35)
    {
        d = t[i] - 48;
        putchar(t[d < 0 ? i : i + p[d] - 48]);
        i += d < 0 ? 1 : 5;
        r % 7 ? 0 : puts("");
    }
}

A coisa toda é uma força bastante bruta. Ele usa uma tabela que contém uma entrada para cada um dos 35 (5 linhas com comprimento 7) caracteres. Cada entrada na tabela é:

• Um personagem constante: , (, ). O comprimento da entrada da tabela é de 1 caractere.
• Índice da parte do corpo, seguido pelos 4 caracteres possíveis, dependendo da seleção da parte na entrada. O comprimento da entrada da tabela é de 5 caracteres.

O código, em seguida, passa os 35 caracteres e procura o valor na tabela.

R 414 bytes

Versão ligeiramente modificada da versão de Molx

W =c("_===_"," ___\n .....","  _\n  /_\\"," ___\n (_*_)",",",".","_"," ",".","o","O","-"," ","\\"," "," ","<"," ","/"," "," ","/"," ","",">"," ","\\",""," : ","] [","> <","   "," : ","\" \"","___","   ")
f=function(x){i=as.integer(strsplit(x,"")[[1]]);cat(" ",W[i[1]],"\n",W[i[5]+12],"(",W[i[3]+8],W[i[2]+4],W[i[4]+8],")",W[i[6]+20],"\n",W[i[5]+16],"(",W[i[7]+28],")",W[i[6]+24],"\n"," (",W[i[8]+32], ")",sep="")}

Apenas fundiu as variáveis ​​separadas em uma. Shawing de algum espaço que foi usado para X=c(rotina.

CJam, 200 191 bytes

Isso certamente pode ser muito praticado. (Especialmente se eu codificá-lo). Mas aqui vai para iniciantes:

7S*"_===_  ___  .....   _    /_\   ___  (_*_)"+6/2/Nf*",._ "1/".oO-"1/_" <\  /   >/  \  "2/4/~" : ] [> <    : \" \"___   "3/4/~]l~Ab:(]z::=:L0=N4{L=}:K~0='(2K1K3K')5K0=N4K1='(6K')5K1=NS'(7K')

A entrada entra no STDIN. Por exemplo, a entrada 23232223fornece:

  ___ 
 .....
\(o_O)/
 (] [) 
 (___)

Experimente online aqui

Haskell, 333 bytes

Minha primeira submissão! Constrói o boneco de neve de cima para baixo, da esquerda para a direita. Dividi os braços em duas funções para cada braço, a parte ao lado da cabeça e a parte ao lado do corpo.

A função s pega uma lista de números inteiros e concatena a saída das funções que produzem as partes do corpo dadas sublistas corretas da entrada.

a=y["\n _===_\n","  ___ \n .....\n","   _  \n  /_\\ \n","  ___ \n (_*_)\n"]
d=y",._ "
c=y".oO-"
e=y"< / "
j=y" \\  "
f=y"> \\ "
k=y" /  "
y w n=w!!(n-1)
h=y[" : ","] [","> <","   "]
b=y[" ( : ) \n"," (\" \") \n"," (___) \n"," (   ) \n"]
s(m:x:o:p:n:q:t:l:_)=putStr$a m++j x:'(':c o:d n:c p:')':k q:'\n':e x:'(':h t++')':f q:'\n':b l

Depende da função

y :: [a] -> Int -> a
y w n=w!!(n-1)

que retorna o enésimo elemento da lista fornecida. Isso permite a lista de chapéus em um, bem como coisas como

k=y" /  "

todas essas funções usam uma redução beta para que seu argumento seja passado como índice para a função y.

Resultado:

λ> s $ repeat 1

 _===_
 (.,.) 
<( : )>
 ( : ) 

λ> s $ repeat 2
  ___ 
 .....
\(o.o)/
 (] [) 
 (" ") 

λ> s $ repeat 3
   _  
  /_\ 
 (O_O) 
/(> <)\
 (___) 

λ> s $ repeat 4
  ___ 
 (_*_)
 (- -) 
 (   ) 
 (   ) 

Python 3, 349 336 254 251 bytes

Tanta coisa para fazer minha tese.

Aqui está o conteúdo do arquivo snowman.py :

l='_===_| ___\n .....|  _\n  /_\| ___\n (_*_)| : |] [|> <|   |>| |\| | : |" "|___|   '.split('|')
l[4:4]=' \  .oO-,._ .oO- /  < / '
def s(a):print(' {}\n{}({}{}{}){}\n{}({}){}\n ({})'.format(*[l[4*m+int(a[int('0421354657'[m])])-1]for m in range(10)]))

E é assim que eu conjuro meu boneco de neve favorito:

s('11112311')

 _===_ 
\(.,.) 
 ( : )\
 ( : ) 

Explicação

# Create a list containing the 4 * 10 body parts of the snowman in order of drawing:
#   hats,
#   upper left arms, left eyes, noses, right eyes, upper right arms,
#   lower left arms, torso's, lower right arms,
#   bases
l='_===_| ___\n .....|  _\n  /_\| ___\n (_*_)| : |] [|> <|   |>| |\| | : |" "|___|   '.split('|')
l[4:4]=' \  .oO-,._ .oO- /  < / '
# This is the function that draws the snowman
# All the lines of this function are golfed in a single statement, but seperated here for clearity
def s(a):
    # In this list comprehension I put the elements of l that are chosen according to the parameters
    list_comprehension = []
    # m is the number of the body part to draw
    for m in range(10):
        # Get the index for the choice of the m-th bodypart
        # (example: the 2nd bodypart (m = 1: the upper left arm) is in the 4th place of the arguments list)
        choice_index = int('0421354657'[m])
        # n is the parameter of the current bodypart
        n = int(a[choice_index]) - 1
        # Add the body part from list l to the list comprehenseion
        list_comprehension.append( l[4 * m + n] )
    # Print the list comprehension with the static parts
    print(' {}\n{}({}{}{}){}\n{}({}){}\n ({})'.format(*list_comprehension))

PowerShell , 199 bytes

Inspirado por Reto Koradi e anatolyg .

for($t='  0 _ _0 ___0 _ _
 0_. (0=./_0=._*0=.\_0_. )
4 \  (2.oO-1,._ 3.oO-)5 /  
4< / (6 ]> 6:   6 [< )5> \ 
 (7 "_ 7: _ 7 "_ )';$d=$t[$i++];$r+="$d"){if($d-ge48){$d=$t[$i+"$args"["$d"]-49]
$i+=4}}$r

Experimente online!

Nota: A linha 3 possui 2 espaços para trilhas, a linha 4 possui um espaço para trilhas.

Meu favorito é 44444444"guarda russa sonolenta":

 ___
(_*_)
(- -)
(   )
(   )

JavaScript (ES6), 247

Anúncio não tão bom @ NinjaBearMonkey's :(

Teste no snippet (com Firefox)

S=p=>([h,n,c,d,l,r,t,b,e,x]=[...p,' .oO-',`1_===_1 ___
 .....1  _
  /_\\1 ___
 (_*_)1 : 1] [1> <1   1 : 1" "1___1   `.split(1)],` ${x[h]}
${'  \\  '[l]}(${e[c]+' ,._ '[n]+e[d]})${'  /  '[r]}
${' < / '[l]}(${x[3-~t]})${' > \\ '[r]}
 (${x[7-~b]})`)

// TEST // 

function go()
{
  var n=N.value
  if (/^[1-8]{8}$/.test(n)) {
    s=S(n)
    OUT.innerHTML = s+'\n'+n+'\n\n'+ OUT.innerHTML
  }
  else N.focus()
}
  

<input id=N maxlength=8><button onclick="go()">Test</button>
<pre id=OUT></pre>

05AB1E , 137 135 128 122 bytes

…( )7ÝJ»•αγʒδÓ₂©8¥ŽQxΣxêÿ•12вèJIvN”</[(
._-=:"ÆŸ,*”º•DùÙÂ+;Èγтáì³ÓW©ÎÂ_`ƒ≠îj*ΓçÊ~ÞÒ¸β¦oåb/õ47/vÎΓ”›≠øØZµλݺ•20в趡Nè4äyè.;

-6 bytes graças a @Grimy .

Experimente online ou verifique mais alguns casos de teste .

Explicação:

Primeiro, criamos a string do modelo:

…( )         # Push string "( )"
7ÝJ          # Push a list in the range [0,7] joined together: "01234567"
»            # Join both by a newline: "( )\n01234567"
•αγʒδÓ₂©2°ćì₂òη₆½•
             # Push compressed integer 80545642885242518310229085147411483894
 12в         # Convert it to Base-12 as list: [1,4,4,4,4,4,3,1,4,4,4,4,4,3,8,0,6,5,7,2,9,3,8,0,10,10,10,2,9,3,1,0,11,11,11,2]
    è        # Index each into the string: [" ","0","0","0","0","0","\n"," ","0","0","0","0","0","\n","4","(","2","1","3",")","5","\n","4","(","6","6","6",")","5","\n"," ","(","7","7","7",")"]
     J       # And join it to a single string: " 00000\n 00000\n4(213)5\n4(666)5\n (777)"

Que se parece com isso:

 00000
 00000
4(213)5
4(666)5
 (777)

Então eu faço um loop sobre os dígitos da entrada:

I            # Get the input
 v           # Loop `y` over each of its digits:

E faça o seguinte:
Pressione o índice (indexado 0) Nda lista:

  N          # Push the index of the loop

Empurre todas as partes possíveis como uma lista de listas de caracteres:

  ”</[(
  ._-=:"ÆŸ,*”
            "# Push dictionary string "</[(\n._-=:" Oo,*"
   º         # Mirror each line: "</[()]\>\n._-=:" Oo,**,oO ":=-_."
  •DùÙÂ+;Èγтáì³ÓW©ÎÂ_`ƒ≠îj*ΓçÊ~ÞÒ¸β¦oåb/õ47/vÎΓ”›≠øØZµλݺ•
             # Push compressed integer 492049509496347122906361438631265789982480759119518961177677313610613993948059787418619722816092858096158180892708001681647316210
   20в       # Convert it to Base-20 as list: [15,10,10,10,15,3,10,19,10,4,15,15,15,15,15,10,12,12,12,10,15,10,10,10,15,9,9,9,9,9,15,15,10,15,15,15,1,10,6,15,8,15,18,9,10,8,11,9,17,16,8,11,9,17,16,8,15,15,15,0,6,15,15,1,8,15,15,15,7,1,15,15,6,8,15,15,15,15,13,15,5,15,2,7,15,0,8,15,15,15,15,13,15,14,15,14,10,10,10]
      è      # Index each into the string: [" ","_","_","_"," ","(","_","*","_",")"," "," "," "," "," ","_","=","=","=","_"," ","_","_","_"," ",".",".",".",".","."," "," ","_"," "," "," ","/","_","\"," ","\n"," ",",",".","_","\n","-",".","o","O","\n","-",".","o","O","\n"," "," "," ","<","\"," "," ","/","\n"," "," "," ",">","/"," "," ","\","\n"," "," "," "," ",":"," ","]"," ","[",">"," ","<","\n"," "," "," "," ",":"," ","""," ",""","_","_","_"]
       ¶¡    # Split it by the newline character: [[" ","_","_","_"," ","(","_","*","_",")"," "," "," "," "," ","_","=","=","=","_"," ","_","_","_"," ",".",".",".",".","."," "," ","_"," "," "," ","/","_","\"," "],[" ",",",".","_"],["-",".","o","O"],["-",".","o","O"],[" "," "," ","<","\"," "," ","/"],[" "," "," ",">","/"," "," ","\"],[" "," "," "," ",":"," ","]"," ","[",">"," ","<"],[" "," "," "," ",":"," ","""," ",""","_","_","_"]]

Use o índice de loop N para obter a lista de caracteres da parte com a qual estamos trabalhando atualmente:

  Nè         # Index the loop index into it
             #  i.e. 6 → [" "," "," "," ",":"," ","]"," ","[",">"," ","<"]

Em seguida, divida a lista de caracteres em quatro partes iguais e use o dígito de entrada y(que é indexado 1) para indexá-lo. (NOTA: Como 05AB1E é indexado em 0, mas a entrada é indexada em 1, seria lógico diminuir o dígito em 1 antes da indexação. No entanto, como 05AB1E possui envolvimento automático (ou seja, a indexação 3na lista [1,3,5]resultará em1 ), eu simplesmente girou as peças uma vez, para que as partes com o nº 4 na descrição do desafio estejam na frente das listas.)

    4ä       # Split it into 4 equal parts
             #  i.e. [[" "," "," "],[" ",":"," "],["]"," ","["],[">"," ","<"]]
      yè     # Index the input-digit `y` into it (with automatic wraparound)
             #  i.e. 4 → [" "," "," "]

E, em seguida, substitua o índice indexado 0 do loop que pressionamos primeiro, um por um pelos caracteres de parte:

  .;         # Replace first; every index of the loop `N` in the template-string
             # is replaced one by one with the characters

E, no final, o resultado é gerado implicitamente.

Consulte esta minha dica 05AB1E (seção Como compactar números inteiros grandes? E Como compactar listas de números inteiros? ) Para entender como as peças de compressão funcionam.

Quanto ao meu favorito, ainda é o mesmo 'coelho da neve' de 1,5 ano atrás quando publiquei minha solução Java :

44114432:
   _  
 (_*_)
 (. .) 
 (> <) 
 (" ")

Java 8, 548 545 432 401 399 bytes

a->{int q=50,H=a[0]-49,N=a[1],L=a[2],R=a[3],X=a[4],Y=a[5];return"".format(" %s%n %s%n%c(%c%c%c)%c%n%c(%s)%c%n (%s)",H<1?"":H%2<1?" ___":"  _","_===_s.....s /_\\s(_*_)".split("s")[H],X==q?92:32,L<q?46:L<51?111:L<52?79:45,N<q?44:N<51?46:N<52?95:32,R<q?46:R<51?111:R<52?79:45,Y==q?47:32,X<q?60:X%2<1?32:47,"   s : s] [s> <".split("s")[a[6]%4],92-(Y%3+Y%6/4)*30,"   s : s\" \"s___".split("s")[a[7]%4]);}

Experimente aqui.

Explicação:

a->{             // Method with character-array parameter and String return-type
  int q=50,      //  Temp integer with value 50 to reduce the byte-count
      H=a[0]-49, //  The hat-character as unicode value minus 49: 1=0; 2=1; 3=2; 4=3
      N=a[1],L=a[2],R=a[3],X=a[4],Y=a[5];
                 //  Most of the other characters as unicode values: 1=49; 2=50; 3=51; 4=52
  return"".format(" %s%n %s%n%c(%c%c%c)%c%n%c(%s)%c%n (%s)",
                                               // Return the snowman with:
    H<1?"":H%2<1?" ___":"  _",                 //  The top of the hat
    "_===_s.....s /_\\s(_*_)".split("s")[H],   //  + the bottom of the hat
    X==q?92:32,                                //  + the top of the left arm
    L<q?46:L<51?111:L<52?79:45,                //  + the left eye
    N<q?44:N<51?46:N<52?95:32,                 //  + the nose
    R<q?46:R<51?111:R<52?79:45,                //  + the right eye
    Y==q?47:32,                                //  + the top of the right arm
    X<q?60:X%2<1?32:47,                        //  + the bottom of the left arm
    "   s : s] [s> <".split("s")[a[6]%4],      //  + the torso
    92-(Y%3+Y%6/4)*30,                         //  + the bottom of the right arm
    "   s : s\" \"s___".split("s")[a[7]%4]);}  //  + the feet

Meu favorito:

44114432:
   _  
 (_*_)
 (. .) 
 (> <) 
 (" ")

Não sei por que, mas parece meio fofo. Como um coelho com um chapéu russo em vez de orelhas.

F #, 369 bytes

let f(g:string)=
 let b=" "
 let p=printfn
 let i x=int(g.[x])-49
 p"  %s  "["";"___";" _ ";"___"].[i 0]
 p" %s "["_===_";".....";" /_\ ";"(_*_)"].[i 0]
 p"%s(%c%c%c)%s"[b;"\\";b;b].[i 4]".oO-".[i 2]",._ ".[i 1]".oO-".[i 3][b;"/";b;b;b].[i 5]
 p"%s(%s)%s"["<";b;"/";b].[i 4][" : ";"] [";"> <";"   "].[i 6][">";b;"\\";b].[i 5]
 p" (%s) "[" : ";"\" \"";"___";"   "].[i 7]

Experimente online!

Como gusa um acessador de matriz, preciso especificar explicitamente o tipo na definição da função como a string, e é por isso que a definição da função possui (g:string).

Além disso, geralmente é uma matriz stringsacessada por um índice. O chapéu, os braços esquerdo e direito, que entrariam em linhas separadas, são divididos em matrizes superior e inferior separadas. A ifunção altera um número no argumento gpara o índice da matriz. E a letra bsubstitui as cadeias de espaço único nas matrizes.

Grande desafio! Meu boneco de neve favorito é provavelmente 242244113:

  ___  
 ..... 
 (o o) 
 ( : ) 
 ( : ) 

Estou te observando

PHP, 378 bytes

<?$f=str_split;$r=$f($argv[1]);$p=[H=>'   _===____..... _  /_\ ___(_*_)',N=>',._ ',L=>'.oO-',R=>'.oO-',X=>' <\  /  ',Y=>' >/  \  ',T=>' : ] [> <   ',B=>' : " "___   '];echo preg_replace_callback("/[A-Z]/",function($m){global$A,$p,$r,$f;$g=$m[0];return$f($f($p[$g],strlen($p[$g])/4)[$r[array_search($g,array_keys($p))]-1])[(int)$A[$g]++];},'  HHH
 HHHHH
X(LNR)Y
X(TTT)Y
 (BBB)');

Experimente online!

Eu gosto do sábio Sr. Coruja 31333342

   _ 
  /_\ 
 (O,O) 
/(   )\
 (" ")

Python 2.7, 257 bytes (eu acho)

H,N,L,R,X,Y,T,B=map(int,i)
l='\n'
s=' '
e=' .o0-'
F='  \  / '
S=' < / \ >'
o,c='()'
print s+'      _ _ ___ _ _\n\n\n\n    _. (=./_=._*=.\__. )'[H::4]+l+F[X]+o+e[L]+' ,._ '[N]+e[R]+c+F[-Y]+l+S[X]+o+'  ]> :    [< '[T::4]+c+S[-Y]+l+s+o+'  "_ : _  "_ '[B::4]+c

onde 'i' é a entrada como uma sequência (por exemplo, "13243213")

Dardo , 307 bytes

f(i,{r='.o0-',s=' : '}){i=i.split('').map((j)=>int.parse(j)-1).toList();return' ${['_===_',' ___ \n.....',' /_\\ ',' ___ \n (_*_)'][i[0]]}\n${' \\  '[i[4]]}(${r[i[2]]+',._ '[i[1]]+r[i[3]]})${' /  '[i[5]]}\n${'< /  '[i[4]]}(${[s,'] [','> <','  '][i[6]]})${'> \\ '[i[5]]}\n (${[s,'" "','___','   '][i[7]]})';}

Experimente online!

Zsh, 247 bytes

experimente online !!

(){H='_===_h ___
 .....h  _
  /_\h ___
 (_*_)'
W=' \  ' L=.oO- N=,._\  Y=' /  '
X='< / ' T=' : ] [> <   ' Z='> \ '
B=' : " "___   '
<<<" ${H[(ws:h:)$1]}
$W[$5]($L[$3]$N[$2]$L[$4])$Y[$6]
$X[$5](${T:3*($7-1):3})$Z[$6]
 (${B:3*($8-1):3})"
} ${(s::)1}

fav boneco de neve:

43232122 Cossack dancer
  ___
 (_*_)
\(o_O) 
 (] [)>
 (" ")