Aquí hay un simple muñeco de nieve de arte ASCII :

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

Hagámosle algunos amigos. Este será el patrón general para nuestra gente de nieve de arte ASCII:

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

Los espacios iniciales y los paréntesis son siempre los mismos para todas las personas de nieve. Las diferentes letras representan secciones del patrón que pueden cambiar individualmente. Cada sección tiene exactamente cuatro preajustes para lo que los caracteres ASCII pueden llenar. Al mezclar y combinar estos ajustes preestablecidos para las ocho secciones, podemos hacer una variedad de personas de nieve.

Todos los preajustes

^{(Observe que los espacios se colocan en líneas vacías, por lo que la forma de la sección siempre es correcta).}

H es para sombrero

1. Sombrero de copa

        
   _===_

2. Sombrero mexicano

    ___ 
   .....
   

3. Fez

     _  
    /_\ 
   

4. Sombrero ruso

    ___ 
   (_*_)
   

N es para nariz / boca

1. Normal ,

2. Punto .

3. Línea _

4. Ninguna

L es para ojo izquierdo

1. Punto .

2. Punto más grande o

3. El punto más grande O

4. Cerrado -

R es para el ojo derecho

(La misma lista que el ojo izquierdo).

X es para brazo izquierdo

1. Brazo normal

    
   <

2. Brazo hacia arriba

   \
    

3. Brazo hacia abajo

    
   /

4. Ninguna

Y es para el brazo derecho

1. Brazo normal

    
   >

2. Brazo hacia arriba

   /
    

3. Brazo hacia abajo

    
   \

4. Ninguna

T es para el torso

1. Botones :

2. Chaleco ] [

3. Brazos interiores > <

4. Ninguna

B es para base

1. Botones :

2. Pies " "

3. Plano ___

4. Ninguna

Desafío

Escriba un programa que tome una cadena de ocho caracteres (a través de stdin o línea de comando) en el formato HNLRXYTB, donde cada letra es un dígito del 1 al 4 que denota qué preajuste usar para la sección correspondiente de la persona de nieve. Imprima la persona de nieve completa en stdout.

Por ejemplo, la entrada 11114411es el muñeco de nieve en la parte superior de la página. (Primero 1: tiene un sombrero de paja, segundo 1: tiene una nariz normal, etc.)

Otro ejemplo, la persona de nieve para la entrada 33232124:

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

Detalles

• Cualquier cantidad y combinación de espacios iniciales / finales y nuevas líneas iniciales / finales se permiten siempre que ...

  • el muñeco de nieve tiene todas sus secciones ordenadas correctamente una con respecto a la otra, y
  • nunca hay más de 64 caracteres de espacio en blanco en total (el patrón general es solo 7 × 5, por lo que probablemente no alcanzará este límite).

  No necesita imprimir filas / columnas del patrón si solo contienen espacios en blanco. Por ejemplo, no se requiere la línea vacía del sombrero de paja.

• Debe usar el orden de las piezas como se indica arriba.

• En lugar de un programa, puede escribir una función que tome la cadena de dígitos como argumento. La salida debe imprimirse normalmente o devolverse como una cadena.

• Puede tratar la entrada como un entero en lugar de una cadena si lo prefiere.

Puntuación

El código más corto en bytes gana.

Pregunta extra: ¿Cuál de las 65536 personas de nieve distintas es tu favorita?

CJAM, 135 134 132 130 126 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 crear el archivo en su máquina, ejecute xxd -r > snowman.cjam, pegue el hexdump reversible desde arriba, presione Entery finalmente Ctrl+ D.

Alternativamente, puede probar el código en línea utilizando el intérprete CJam .

Prima

Mi muñeco de nieve favorito es Olaf:

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

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

El invierno es un buen momento para quedarse y abrazarse, pero ponme en verano y seré un ... ¡feliz muñeco de nieve!

Idea

La cadena hexadecimal

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

codifica las posibles opciones para todas las partes del muñeco de nieve, incluidas las fijas. Vamos a llamar a esta cadena P .

Para decodificarlo, convertimos P (aquí tratado como una matriz de enteros) de la base 256 a la base 20 y reemplazamos cada uno de los enteros resultantes por el carácter correspondiente de la cadena M :

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

Esto da como resultado la cadena T :

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

La primera línea codifica todas las opciones de sombreros, la última todas las partes fijas del cuerpo. Las otras líneas contienen las 28 partes del cuerpo variables.

Dividimos T en los avances de línea y dividimos las cadenas de la matriz resultante en cuatro partes de igual longitud. Luego, leemos la entrada de STDIN, empujamos la matriz de sus dígitos en la base 10 y seleccionamos los elementos correspondientes de las cadenas divididas. Aprovechamos el hecho de que las matrices se envuelven en CJam, por lo que el elemento en el índice 4 de una matriz de longitud 4 es en realidad el primer elemento. La última cadena dividida no corresponde a ninguna entrada, por lo que se seleccionará por completo.

Manejamos el sombrero desplazando el primer elemento fuera de la matriz resultante. El índice en M del primer carácter, leído como un número base 4, revela el número de espacios y subraya en la primera línea del sombrero. Imprimimos esos caracteres, un salto de línea, un espacio y el resto de la cadena desplazada. Luego, empujamos un salto de línea adicional en la parte inferior de la pila.

Para las partes del cuerpo, concatenamos la cadena correspondiente a todas ellas. Vamos a llamar a esta cadena S . Para el montaje de las partes del cuerpo, llevamos a cabo la transcripción: tomamos cada carácter de la cadena H , calcular su índice en especie (M) y sustituirlo por el carácter correspondiente de S . Aprovechamos el hecho de que el operador de transliteración rellena automáticamente S para que coincida con la longitud de clasificación (M) repitiendo el último carácter de S tantas veces como sea necesario.

Finalmente, dividimos la cadena resultante en subcadenas de longitud 7 y colocamos un salto de línea entre cada par de subcadenas.

Código

Supongamos que las variables My Pcontienen las cuerdas M y 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 es una función anónima; lo usas ejecutando ([function code])('42232124'). La parte más agravante de esto fueron los brazos, que ocupan 2 líneas, por lo que tuve que incluir el código para la parte superior e inferior.

El Fragmento de pila a continuación tiene un código comentado sin golf, sin ES6. Y puede usarlo para probar fácilmente el código y probar diferentes combinaciones. Editar: Me estoy divirtiendo demasiado con esto. He agregado varias características nuevas, incluida una forma de generar un muñeco de nieve aleatorio.

Gracias a Yair Rand por guardar 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

Genera el muñeco de nieve de izquierda a derecha, de arriba a abajo. Esto elimina la necesidad de cualquier tipo de operaciones de unión o reposicionamiento de cuerdas, ya que solo dejo cada pieza del muñeco de nieve en la pila. Y luego, debido al volcado automático de la pila al final de los programas:

♫ ¡ CJam quiere construir un muñeco de nieve! ♫

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

Pruébalo en línea.

Prima

¡Pensar más allá! 32443333le da a un hombre nieve (wo) novia. Tienes que intentarlo un poco para verlo, pero están los brazos hacia adentro, fez + brazos hacia abajo = velo, y la cabeza está realmente en el fez / velo. La forma generalmente grande es el vestido ondulado, y los "ojos" y la "nariz" son pliegues en el vestido.

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

Otras opciones de "ojo" son un poco arriesgadas ...

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 tiene 8 bytes adicionales ( \* 4) para facilitar la lectura.

Construye el muñeco de nieve poco a poco.

Prima

F("44444432") da "oso ruso soñoliento":

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

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]+")"

Llamar s('33232124')da:

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

Pero mis favoritos son 44242123y 41341144:

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

CJAM, 150 145 bytes

Base convertir todas las cosas!

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

SE destruye los no imprimibles, así que aquí hay una copia en Pastebin. Asegúrese de copiar la parte "RAW Paste Data", no la parte al lado de los números de línea. Puede probarlo en línea , pero el enlace permanente puede no funcionar en algunos navegadores.

Explicación

La "b8li'U9gN;|"125:Kb8bpparte genera la 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 asigna cada dígito de la entrada al lugar donde se usa el dígito. Cualquier cosa que sea común a todas las entradas (por ejemplo, espacios iniciales y ()) se le asigna arbitrariamente un 0, excepto el primero al que se le asigna 1 para que la conversión base pueda funcionar.

l:~f=luego convierte cada dígito en un int y asigna en consecuencia, por ejemplo, para 14441133obtener

[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= da la cuerda

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

después de lo cual duplicamos, reemplazamos /<[(con \>])y agregamos para dar una cadena larga. Luego dividimos la cadena en grupos de 4 y correlacionamos de acuerdo con otra matriz "r pL|P3{cR`@L1iT"Kb21b, obteniendo así una matriz de cadenas de longitud 4 que describe todas las opciones posibles en cada celda (por ejemplo, _=./todas las opciones posibles para el segundo carácter en la segunda línea, comenzando desde el Sombrero ruso).

Finalmente, asignamos las opciones a las entradas en consecuencia .=, las dividimos en filas de longitud 7 7/y las distribuimos en algunas líneas nuevas N*.

Pruebas de funcionamiento

11111111

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

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

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

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

TI-BASIC, 397 bytes

Importante: si desea probar esto, descárguelo desde aquí y envíe ese archivo a su calculadora. No , no tratar de copiar el siguiente código en el editor de programas de TI-Connect CE o SourceCoder 3 o algo para construir y enviarlo a la calculadora; en el caso de TI-Connect, dirá que tiene un token no válido. SC3 utiliza la barra diagonal inversa como delimitador de comentarios ( //inicia un comentario en SC3; /\/sin embargo, se exportará como //) y, por lo tanto, no exportará los brazos y el sombrero correctamente, haciendo que el programa muestre las partes incorrectas del cuerpo y arroje un ERROR: DOMINIO de vez en cuando. ¡Cosas divertidas!

Importante # 2: Soy demasiado vago para arreglar la descarga en este momento, así que cuando la transfieras a tu calc, cambia la 7en la tercera línea desde abajo hacia X+6. El código a continuación es fijo si necesita 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

Bono: me gusta especialmente 12341214.

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

Algunas notas:

• Definitivamente se puede jugar más al golf, no hay duda al respecto. Estoy casi seguro de que puedo combinar una mayoría, si no toda, de la salida en un solo bucle For (. Además, estoy bastante seguro de que puedo fusionar algunas cadenas juntas.
• En Str4 (los ojos) utilizo el "punto de la trama" ( [2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct)) en lugar de un punto para que los ojos no se alineen con la coma, porque eso se ve raro como el infierno.
• En Str8 (base) tuve que usar una diéresis (¨) en lugar de comillas dobles porque no hay forma de escapar de los caracteres en TI-BASIC, y las comillas dobles se usan para iniciar / finalizar cadenas.
• En TI-BASIC, no es necesario cerrar los paréntesis y corchetes si van seguidos de dos puntos, una nueva línea o → (utilizado para la asignación de var), y las comillas dobles (cadenas) pueden permanecer sin cerrar cuando se siguen una nueva línea o →.

C, 280 272 264 bytes

En este punto solo jugamos golf parcialmente, pero este es un desafío 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);}

(Con algo más de \ n para facilitar la lectura). Espero que esto definedesaparezca con más golf.

Una versión más legible es

#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];}

Una versión legible:

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

Tomé la idea de la respuesta de Reto Koradi . Hice varias mejoras divertidas que hice, que pueden justificar publicar una respuesta por separado:

• Convertido de función a programa (+10)
• Se movieron nuevas líneas a la cadena de control (-7)
• Se agregó 3 a todos los códigos de caracteres para tener menos caracteres escapados como \"(-3)
• Lectura desde la cadena con autoincremento; también reemplazado t[i++]por *t++(-4)
• Sustituido whilepor for; eliminado {}(-4)
• Terminación de bucle simplificado: lectura hasta \0(-9)
• Transformado t[...],t+=4para(...)[t+=4] eliminar el operador de coma (-1)

¿Por qué tantos problemas? Para compartir mi favorito, fantasma de nieve:

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

JavaScript, 489 (sin líneas nuevas y pestañas)

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'));

corre con node snowman.js 33232124

Pyth, 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\)

Jajaja Pruébelo en línea: Pyth Compiler / Executor

Explicación

Primero defino una función auxiliar g, que toma una lista y un carácter como entrada, convierte el carácter en su valor ASCII y toma el elemento correspondiente (ajuste modular).

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

La otra cosa es imprimir línea por línea. Por ejemplo, la primera línea es:

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

Por cierto. Experimenté un poco con .F"{:^7}", que centra una cadena. Al usarlo, podría guardar algunos espacios en mi código, pero no guarda ningún byte al final.

R, 436 437 bytes

Aquí está mi primer intento en code-golf , usando R, que no es el más corto pero divertido. Al menos estoy superando a JavaScript (por ahora) ...

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

Pruebas:

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

De hecho, me luchado con Xy Ysiendo multilined pero con cosas en el medio, terminó separando cada línea ( X, S) y ( Y, U).

function y la conversión de cadena a entero también son muy detalladas.

Editar 436 => 437

Tuve que arreglar un espacio vacío perdido notado por @OganM

Podría reducir a 428 reemplazando los saltos de línea entre variables con ;, pero el código de "una línea" se ve tan mal e ilegible que no seré tan codicioso.

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) 
/(] [)\
 ( : )

Cómo funciona: indexar cada elemento de la lista [hat options, left upper arm options, left eye options, ..., base options]con el número de entrada correspondiente y concatenarlo en una sola lista. He dividido el brazo izquierdo y derecho en una parte superior e inferior, para poder construir el muñeco de nieve línea por línea.

Mi favorito es el clásico 11112211.

Editar: cambió de la lista de cadenas a cadenas para las partes (sombrero, ojo, ...). Necesita un segundo parámetro, la longitud de la subcadena a tomar.

Editar II: subcadenas comunes extraídas

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("");}}

Con nuevas líneas y espacios en blanco para una mejor legibilidad:

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("");
    }
}

Todo esto es bastante fuerza bruta. Utiliza una tabla que contiene una entrada para cada uno de los 35 caracteres (5 líneas con longitud 7). Cada entrada en la tabla es:

• Una constante de caracteres: , (, ). La longitud de la entrada de la tabla es de 1 carácter.
• Índice de la parte del cuerpo, seguido de los 4 caracteres posibles según la selección de parte en la entrada. La longitud de la entrada de la tabla es de 5 caracteres.

El código luego recorre los 35 caracteres y busca el valor en la tabla.

R 414 bytes

Versión ligeramente modificada de la versión 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="")}

Solo fusioné las variables separadas en una. Shawing de un espacio que se utilizó para la X=c(rutina.

Cjam, 200 191 bytes

Esto seguramente se puede jugar mucho al golf. (Especialmente si la base lo codifico). Pero aquí va para empezar:

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')

La entrada entra en STDIN. Por ejemplo, la entrada 23232223da:

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

Pruébalo en línea aquí

Haskell, 333 bytes

Mi primera sumisión! Construye el muñeco de nieve de arriba a abajo, de izquierda a derecha. Dividí los brazos en dos funciones para cada brazo, la parte al lado de la cabeza y la parte al lado del cuerpo.

La función s toma una lista de enteros y concatena la salida de las funciones que producen las partes del cuerpo dadas las sublistas correctas de la 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

Se basa en la función

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

que devuelve el enésimo elemento de la lista que se le da. Esto permite la lista de sombreros en a, así como cosas como

k=y" /  "

Todas estas funciones usan una reducción beta, por lo que su argumento se pasa como índice a la función y.

Salida:

λ> s $ repeat 1

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

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

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

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

Python 3, 349 336 254 251 bytes

Tanto por hacer mi tesis.

Aquí está el contenido del archivo 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)]))

Y así es como conjuro mi muñeco de nieve favorito:

s('11112311')

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

Explicación

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

Pruébalo en línea!

Nota: La línea 3 tiene 2 espacios de camino, la línea 4 tiene un espacio de camino.

Mi favorito es 44444444"soñoliento guardia ruso":

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

JavaScript (ES6), 247

No es tan buen anuncio @ NinjaBearMonkey :(

Prueba en fragmento (con 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 gracias a @Grimy .

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

Primero creamos la cadena de plantilla:

…( )         # 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 ve así:

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

Luego hago un bucle sobre los dígitos de la entrada:

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

Y haga lo siguiente:
Empuje el índice (indexado a 0) Nde la lista:

  N          # Push the index of the loop

Empuje todas las partes posibles como una 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 el índice de bucle Npara obtener la lista de caracteres de la parte con la que estamos trabajando actualmente:

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

Luego, divida la lista de caracteres en cuatro partes iguales y use el dígito de entrada y(que está indexado en 1) para indexarla. (NOTA: Dado que 05AB1E está indexado en 0, pero la entrada está indexada en 1, sería lógico disminuir el dígito en 1 antes de la indexación. Sin embargo, dado que 05AB1E tiene un ajuste automático (es decir, la indexación 3en la lista [1,3,5]dará como resultado 1), simplemente rotó las partes una vez para que las partes con nr 4 en la descripción del desafío estén al principio de las listas).

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

Y luego reemplace el índice indexado 0 del bucle que empujamos al principio, uno por uno con los caracteres parciales:

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

Y al final, el resultado se emite implícitamente.

Vea esta sugerencia mía 05AB1E (sección ¿Cómo comprimir enteros grandes? Y ¿Cómo comprimir listas enteras? ) Para comprender cómo funcionan las partes de compresión.

En cuanto a mi favorito, sigue siendo el mismo 'conejo de nieve' que hace 1,5 años cuando publiqué mi solución 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]);}

Pruébalo aquí

Explicación:

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

Mi favorito:

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

No sé por qué, pero se ve un poco lindo. Como un conejito con un sombrero ruso en lugar de orejas.

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]

Pruébalo en línea!

Debido a que gutiliza un descriptor de acceso a la matriz, necesito especificar explícitamente el tipo en la definición de la función como a string, por lo que la definición de la función lo tiene (g:string).

Aparte de eso, generalmente es una matriz de stringsacceso por un índice. El sombrero, los brazos izquierdo y derecho que irían en líneas separadas se dividen en matrices superiores e inferiores separadas. La ifunción cambia un número en el argumento gen el índice de matriz. Y la letra breemplaza las cadenas de un espacio en las matrices.

¡Gran reto! Mi muñeco de nieve favorito es probablemente 242244113:

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

Te estoy vigilando

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)');

Pruébalo en línea!

Me gusta sabio señor búho 31333342

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

Python 2.7, 257 bytes (creo)

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

donde 'i' es la entrada como una cadena (por ejemplo, "13243213")

Dart , 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]]})';}

Pruébalo en línea!

Zsh, 247 bytes

Pruébalo en línea !!

(){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}

muñeco de nieve favorito:

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