Ecco un semplice pupazzo di neve di arte ASCII :

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

Facciamolo degli amici. Questo sarà lo schema generale per i nostri pupazzi di neve di arte ASCII:

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

Gli spazi principali e le parentesi sono sempre gli stessi per tutti gli snowpeople. Le diverse lettere rappresentano sezioni del modello che possono cambiare individualmente. Ogni sezione ha esattamente quattro preset per ciò che i caratteri ASCII possono riempire. Mescolando e abbinando questi preset per tutte e otto le sezioni, possiamo creare una varietà di snowpeople.

Tutti i preset

^{(Notare che gli spazi vengono posizionati su linee vuote altrimenti la forma della sezione è sempre corretta.)}

H è per Hat

1. Cappello di paglia

        
   _===_

2. Cappello messicano

    ___ 
   .....
   

3. Fez

     _  
    /_\ 
   

4. Cappello russo

    ___ 
   (_*_)
   

N sta per Naso / Bocca

1. Normale ,

2. Punto .

3. Linea _

4. Nessuna

L è per l'occhio sinistro

1. Punto .

2. Punto più grande o

3. Punto più grande O

4. Chiuso -

R è per l'occhio destro

(Stesso elenco dell'occhio sinistro.)

X è per il braccio sinistro

1. Braccio normale

    
   <

2. Braccio verso l'alto

   \
    

3. Braccio verso il basso

    
   /

4. Nessuna

Y è per il braccio destro

1. Braccio normale

    
   >

2. Braccio verso l'alto

   /
    

3. Braccio verso il basso

    
   \

4. Nessuna

T sta per Torso

1. pulsanti :

2. Veste ] [

3. Armi interne > <

4. Nessuna

B sta per Base

1. pulsanti :

2. piedi " "

3. Piatto ___

4. Nessuna

Sfida

Scrivi un programma che includa una stringa di otto caratteri (tramite stdin o riga di comando) nel formato HNLRXYTB, in cui ogni lettera è una cifra compresa tra 1 e 4 che indica quale preimpostazione utilizzare per la sezione corrispondente del pupazzo di neve. Stampa l'intero pupazzo di neve su stdout.

Ad esempio, l'input 11114411è il pupazzo di neve nella parte superiore della pagina. (Primo 1: ha un cappello di paglia, secondo 1: ha un naso normale, ecc.)

Un altro esempio, il pupazzo di neve per l'input 33232124:

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

Dettagli

• Sono consentiti importi e combinazioni di spazi iniziali / finali e newline iniziali / finali purché ...

  • il pupazzo di neve ha tutte le sezioni disposte correttamente l'una rispetto all'altra, e
  • non ci sono mai più di 64 caratteri di spazi bianchi totali (il modello generale è solo 7 × 5, quindi probabilmente non raggiungerai questo limite).

  Non è necessario stampare righe / colonne del motivo se contengono solo spazi bianchi. ad es. la linea vuota del cappello di paglia non è richiesta.

• È necessario utilizzare l'ordinamento delle parti come indicato sopra.

• Invece di un programma, è possibile scrivere una funzione che accetta la stringa di cifre come argomento. L'output deve essere stampato normalmente o restituito come stringa.

• Se lo si preferisce, è possibile considerare l'input come un numero intero anziché una stringa.

punteggio

Vince il codice più breve in byte.

Domanda bonus: quale dei 65536 distinti pupazzi di neve è il tuo preferito?

CJam, 135 134 132 130 126 125 byte

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*

Per creare il file sul tuo computer, esegui xxd -r > snowman.cjam, incolla il hexdump reversibile dall'alto, premi Entere infine Ctrl+ D.

In alternativa, puoi provare il codice online usando l' interprete CJam .

indennità

Il mio pupazzo di neve preferito è Olaf:

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

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

L'inverno è un buon momento per restare e coccolare, ma mi metta in estate e sarò un ... felice pupazzo di neve!

Idea

La stringa esadecimale

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

codifica le possibili scelte per tutte le parti del pupazzo di neve, comprese quelle fisse. Chiamiamo questa stringa P .

Per decodificarlo, convertiamo P (qui trattato come un array di numeri interi) dalla base 256 alla base 20 e sostituiamo ciascuno degli interi risultanti con il carattere corrispondente della stringa M :

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

Ciò si traduce nella stringa T :

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

La prima riga codifica per tutte le scelte di cappello, l'ultima per tutte le parti del corpo fisse. Le altre linee contengono le 28 parti del corpo variabili.

Abbiamo diviso T a linefeeds e dividere le corde della matrice risultante in quattro parti di uguale lunghezza. Quindi, leggiamo l'input da STDIN, spingiamo l'array delle sue cifre in base 10 e selezioniamo gli elementi corrispondenti delle stringhe divise. Approfittiamo del fatto che gli array si avvolgono in CJam, quindi l'elemento all'indice 4 di un array di lunghezza 4 è in realtà il primo elemento. L'ultima stringa divisa non corrisponde a nessun input, quindi verrà selezionata interamente.

Gestiamo il cappello spostando il primo elemento dall'array risultante. L'indice in M del primo carattere, letto come un numero di base 4, rivela il numero di spazi e caratteri di sottolineatura nella prima riga del cappello. Stampiamo quei caratteri, un avanzamento riga, uno spazio e il resto della stringa spostata. Quindi, inseriamo un ulteriore avanzamento riga nella parte inferiore della pila.

Per le parti del corpo, concateniamo la stringa corrispondente a tutte. Chiamiamo questa stringa S . Per assemblare le parti del corpo, effettuiamo traslitterazione: prendiamo ogni carattere della stringa M , calcolare il suo indice di ordinamento (M) e sostituirlo con il carattere corrispondente S . Approfittiamo del fatto che l'operatore di traslitterazione inserisce automaticamente S per abbinare la lunghezza dell'ordinamento (M) ripetendo l'ultimo carattere di S tutte le volte necessarie.

Infine, dividiamo la stringa risultante in sottostringhe di lunghezza 7 e posizioniamo un avanzamento di riga tra ogni coppia di sottostringhe.

Codice

Supponiamo che le variabili Me Pcontengono le stringhe M 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 byte

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

Questa è una funzione anonima; lo usi eseguendo ([function code])('42232124'). La parte più aggravante di ciò sono state le armi, che occupano 2 righe, quindi ho dovuto includere il codice sia in alto che in basso.

Lo snippet di stack in basso ha un codice non modificato, non-ES6, commentato. E puoi usarlo per testare facilmente il codice e provare diverse combinazioni. Modifica: mi sto divertendo troppo con questo. Ho aggiunto diverse nuove funzionalità, incluso un modo per generare un pupazzo di neve casuale.

Grazie a Yair Rand per aver salvato sei byte.

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 byte

Genera il pupazzo di neve da sinistra a destra, dall'alto verso il basso. Questo elimina la necessità di qualsiasi tipo di operazione di unione o riposizionamento delle stringhe, poiché lascio semplicemente ogni pezzo del pupazzo di neve in pila. E poi, a causa del dump automatico dello stack alla fine dei programmi:

♫ CJam vuole costruire un pupazzo di neve! ♫

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

Provalo online.

indennità

Pensare fuori dagli schemi! 32443333dà una neve (guai) uomo sposa. Devi provare un po 'a vederlo, ma ci sono le braccia verso l'interno, fez + le braccia verso il basso = velo, e la testa è in realtà nel fez / velo. La forma generalmente grande è l'abito fluttuante e gli "occhi" e il "naso" sono pieghe nell'abito.

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

Altre scelte "oculari" sono un po 'rischiose ...

Python, 276 289 byte

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

Questo codice ha 8 byte extra ( \* 4) per la leggibilità.

Costruisce il pupazzo di neve poco a poco.

indennità

F("44444432") dà "orso russo assonnato":

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

Python 2, 354 280 241 261 byte

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

La chiamata s('33232124')dà:

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

Ma i miei preferiti sono 44242123e 41341144:

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

CJam, 150 145 byte

Base converti tutte le cose!

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

Mangles non stampabili, quindi eccone una copia su Pastebin. Assicurati di copiare la parte "RAW Paste Data", non la parte accanto ai numeri di riga. Puoi provarlo online , ma il permalink potrebbe non funzionare in alcuni browser.

Spiegazione

La "b8li'U9gN;|"125:Kb8bpparte genera l'array

[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]

che mappa ogni cifra dell'input su dove viene utilizzata la cifra. A qualsiasi cosa comune a tutti gli input (ad es. Spazi iniziali e ()) viene assegnato arbitrariamente uno 0, tranne il primo a cui è assegnato 1 in modo che la conversione di base possa funzionare.

l:~f=quindi converte ogni cifra in un int e le mappe di conseguenza, ad esempio per 14441133noi

[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à la stringa

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

dopodiché dupliciamo, sostituiamo /<[(con \>])e aggiungiamo per dare una lunga stringa. Quindi dividiamo la stringa in gruppi di 4 e mappiamo secondo un altro array "r pL|P3{cR`@L1iT"Kb21b, ottenendo così un array di stringhe di lunghezza 4 che descrivono tutte le possibili opzioni in ogni cella (ad es. Sono _=./tutte le opzioni possibili per il secondo carattere sulla seconda riga, a partire dal Cappello russo).

Infine mappiamo le opzioni sugli input di conseguenza .=, divise in file di lunghezza 7 7/e sfogliate in alcune nuove righe N*.

Esecuzioni di test

11111111

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

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

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

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

TI-BASIC, 397 byte

Importante: se vuoi provarlo, scaricalo da qui e invia quel file alla tua calcolatrice. Non non provare a copiare il codice qui sotto in editor di programma di TI-Connect CE o SourceCoder 3 o qualcosa da costruire e inviarlo al tuo calcolatrice; nel caso di TI-Connect, dirà che ha un token non valido. SC3 utilizza la barra rovesciata come delimitatore di commento ( //inizia un commento in SC3; /\/tuttavia, esporterà come //) e quindi non esporterà le braccia e il cappello e così correttamente, facendo sì che il programma visualizzi entrambe le parti del corpo errate e lanci un ERRORE: DOMINIO di tanto in tanto. Cose divertenti!

Importante # 2: sono troppo pigro per risolvere il download in questo momento, quindi quando lo trasferisci sul tuo calc, cambia 7la terza riga dal basso in X+6. Il codice seguente è fisso se devi confrontare.

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

Bonus: sono particolarmente affezionato 12341214.

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

Alcune note:

• Si può sicuramente giocare a golf di più, non c'è dubbio. Sono quasi sicuro di poter combinare la maggioranza, se non tutta, dell'output in un singolo ciclo For (Inoltre. Sono abbastanza sicuro di poter unire alcune stringhe insieme.
• In Str4 (gli occhi) uso il "punto trama" ( [2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct)) anziché un punto in modo che gli occhi non si allineino con la virgola, perché sembra strano come l'inferno.
• In Str8 (base) ho dovuto usare una diaeresi (¨) invece delle doppie virgolette perché non c'è modo di sfuggire ai caratteri in TI-BASIC e le virgolette doppie sono usate per iniziare / finire le stringhe.
• In TI-BASIC, non è necessario chiudere parentesi e parentesi se sono seguite da due punti, una nuova riga o → (usato per l'assegnazione var) e le doppie virgolette (stringhe) possono rimanere chiuse quando seguite da una nuova riga o →.

C, 280 272 264 byte

A questo punto, solo parzialmente ha giocato a golf, ma questa è una sfida divertente.

#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 qualche extra per la leggibilità.) Mi aspetto che definedovrebbe andare via con ulteriore golf.

Una versione più leggibile è

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

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 versione leggibile:

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

Ho preso l'idea dalla risposta di Reto Koradi . Sono stati apportati diversi miglioramenti divertenti, che possono giustificare la pubblicazione di una risposta separata:

• Convertito da funzione a programma (+10)
• Newline spostate nella stringa di controllo (-7)
• Aggiunti 3 a tutti i codici carattere per avere meno caratteri di escape come \"(-3)
• Lettura dalla stringa con autoincremento; sostituito anche t[i++]da *t++(-4)
• Sostituito whileda for; rimosso {}(-4)
• Terminazione loop semplificata: lettura fino a \0(-9)
• Trasformato t[...],t+=4in(...)[t+=4] per eliminare l'operatore virgola (-1)

Perché tutti quei problemi? Per condividere il mio preferito, snow ghost:

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

JavaScript, 489 (senza nuove righe e schede)

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

Corri con node snowman.js 33232124

Pyth, 203 byte

M@GCHgc"  ___

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

Lol. Provalo online: Pyth Compiler / Executor

Spiegazione

Per prima cosa definisco una funzione di supporto g, che accetta un elenco e un carattere come input, converte il carattere nel suo valore ASCII e accetta l'elemento corrispondente (wrapping modulare).

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

L'altra cosa è solo la stampa riga per riga. Ad esempio la prima riga è:

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

Btw. Ho sperimentato un po 'con .F"{:^7}", che centra una stringa. Usandolo, potrei salvare alcuni spazi nel mio codice, ma alla fine non salva alcun byte.

R, 436 437 byte

Ecco il mio primo tentativo su code-golf , usando R che non è il più breve ma comunque divertente. Almeno sto battendo JavaScript (per ora) ...

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

test:

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

In realtà ho lottato con Xe Yessendo multilinea ma con cose in mezzo, ho finito per separare ogni riga tra ( X, S) e ( Y, U).

function e anche la conversione da stringa a numero intero è molto dettagliata.

Modifica 436 => 437

Ho dovuto riparare uno spazio vuoto mancante notato da @OganM

Potrei ridurre a 428 sostituendo le interruzioni di riga tra le variabili ;, ma il codice "a riga singola" sembra così male e illeggibile che non sarò così avido.

Haskell, 361 306 289 byte

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

Come funziona: indicizza ogni elemento dell'elenco [hat options, left upper arm options, left eye options, ..., base options]con il numero di input corrispondente e concatenalo in un unico elenco. Ho diviso il braccio sinistro e destro in una parte superiore e inferiore, in modo da poter costruire il pupazzo di neve riga per riga.

Il mio preferito è il classico 11112211.

Modifica: passa dall'elenco delle stringhe alle stringhe per le parti (cappello, occhio, ...). È necessario un secondo parametro, la lunghezza della sottostringa da prendere.

Modifica II: sottostringhe comuni estratte

C, 233 230 byte

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 newline e spazi bianchi per una migliore leggibilità:

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

L'intera cosa è una forza abbastanza bruta. Utilizza una tabella che contiene una voce per ciascuno dei 35 (5 righe con lunghezza 7) caratteri. Ogni voce nella tabella è:

• Un carattere costante: , (, ). La lunghezza della voce della tabella è di 1 carattere.
• Indice della parte del corpo, seguito dai 4 caratteri possibili a seconda della selezione della parte nell'input. La lunghezza della voce della tabella è di 5 caratteri.

Il codice quindi scorre oltre i 35 caratteri e cerca il valore nella tabella.

R 414 byte

Versione leggermente modificata della versione di 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="")}

Ho appena unito le variabili separate in una sola. Rasatura di un po 'di spazio utilizzato per la X=c(routine.

CJam, 200 191 byte

Questo può sicuramente essere giocato a golf molto. (Specialmente se lo base lo codifico). Ma qui va per cominciare:

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

L'ingresso va in STDIN. Ad esempio, l'input 23232223fornisce:

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

Provalo online qui

Haskell, 333 byte

La mia prima presentazione! Costruisce il pupazzo di neve dall'alto verso il basso, da sinistra a destra. Ho diviso le braccia in due funzioni per ciascun braccio, la parte accanto alla testa e la parte accanto al corpo.

La funzione s prende un elenco di numeri interi e concatena l'output delle funzioni che producono le parti del corpo dati gli elenchi corretti dell'input.

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

Si basa sulla funzione

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

che restituisce l'ennesimo elemento dell'elenco che gli viene dato. Questo consente l'elenco dei cappelli in a, così come cose del genere

k=y" /  "

tutte queste funzioni usano una riduzione beta, quindi il loro argomento viene passato come indice alla funzione y.

Produzione:

λ> s $ repeat 1

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

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

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

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

Python 3, 349 336 254 251 byte

Questo per quanto riguarda la tesi.

Ecco il contenuto del file 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)]))

Ed è così che evoco il mio pupazzo di neve preferito:

s('11112311')

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

Spiegazione

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

Ispirato da 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

Provalo online!

Nota: la linea 3 ha 2 spazi pista, la linea 4 ha uno spazio pista.

Il mio preferito è 44444444"assonnato guardia russa":

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

JavaScript (ES6), 247

Annuncio non buono @ NinjaBearMonkey :(

Test in snippet (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 byte

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

-6 byte grazie a @Grimy .

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

Per prima cosa creiamo la stringa modello:

…( )         # 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)"

Che assomiglia a questo:

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

Quindi giro le cifre dell'ingresso:

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

Ed esegui le seguenti operazioni:
Premi l'indice (0-indicizzato) Ndell'elenco:

  N          # Push the index of the loop

Invia tutte le parti possibili come un elenco di elenchi di caratteri:

  ”</[(
  ._-=:"ÆŸ,*”
            "# 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"],[" "," "," ","<","\"," "," ","/"],[" "," "," ",">","/"," "," ","\"],[" "," "," "," ",":"," ","]"," ","[",">"," ","<"],[" "," "," "," ",":"," ","""," ",""","_","_","_"]]

Utilizzare l'indice del ciclo Nper ottenere l'elenco dei caratteri della parte con cui stiamo attualmente lavorando:

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

Quindi dividi l'elenco dei caratteri in quattro parti uguali e usa la cifra di input y(che è 1-indicizzata) per indicizzarla. (NOTA: poiché 05AB1E è indicizzato 0, ma l'input è 1 indicizzato, sarebbe logico ridurre la cifra di 1 prima dell'indicizzazione. Tuttavia, poiché 05AB1E ha un avvolgimento automatico (ovvero l'indicizzazione 3nell'elenco [1,3,5]comporterà 1), semplicemente ruotato le parti una volta così le parti con nr 4 nella descrizione della sfida, sono in cima alle liste.)

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

E quindi sostituisci l'indice 0-index del loop che abbiamo inserito inizialmente, uno per uno con i caratteri di parte:

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

E alla fine il risultato viene prodotto implicitamente.

Vedi questo mio suggerimento 05AB1E (sezione Come comprimere numeri interi grandi? E Come comprimere gli elenchi di numeri interi? ) Per capire come funzionano le parti di compressione.

Per quanto riguarda il mio preferito, è ancora lo stesso "coniglio di neve" di 1,5 anni fa quando ho pubblicato la mia soluzione Java :

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

Java 8, 548 545 432 401 399 byte

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

Provalo qui.

Spiegazione:

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

Il mio preferito:

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

Non so perché, ma sembra piuttosto carino. Come un coniglio con un cappello russo invece delle orecchie.

F #, 369 byte

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]

Provalo online!

Poiché gutilizza un accessor di array, devo specificare esplicitamente il tipo nella definizione della funzione come a string, motivo per cui ha la definizione della funzione (g:string).

A parte questo, di solito è una matrice di stringsaccessi da un indice. Il cappello, le braccia sinistra e destra che andrebbero su linee separate sono divisi in matrici superiore e inferiore separate. La ifunzione modifica un numero nell'argomento gnell'indice dell'array. E la lettera bsostituisce le stringhe di uno spazio negli array.

Grande sfida! Il mio pupazzo di neve preferito è probabilmente 242244113:

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

ti sto guardando

PHP, 378 byte

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

Provalo online!

Mi piace il saggio signor gufo 31333342

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

Python 2.7, 257 byte (penso)

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

dove 'i' è l'input come stringa (ad es. "13243213")

Dardo , 307 byte

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

Provalo online!

Zsh, 247 byte

provalo 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}

pupazzo di neve preferito:

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