Voici un bonhomme de neige art ASCII simple :

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

Faisons-lui des amis. Ce sera le modèle général pour nos snowpeople art ASCII:

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

Les espaces et les parenthèses sont toujours les mêmes pour tous les snowpeople. Les différentes lettres représentent des sections du motif pouvant être modifiées individuellement. Chaque section a exactement quatre préréglages pour quels caractères ASCII peuvent la remplir. En mélangeant et en faisant correspondre ces préréglages pour les huit sections, nous pouvons créer une variété de snowpople.

Tous les préréglages

^{(Notez que les espaces sont placés sur des lignes vides pour que la forme de la section soit toujours correcte.)}

H est pour chapeau

1. Chapeau de paille

        
   _===_

2. Chapeau mexicain

    ___ 
   .....
   

3. Fez

     _  
    /_\ 
   

4. Chapeau russe

    ___ 
   (_*_)
   

N est pour nez / bouche

1. Ordinaire ,

2. Point .

3. Ligne _

4. Aucun

L est pour l'oeil gauche

1. Point .

2. Plus gros point o

3. Le plus gros point O

4. Fermé -

R est pour l'oeil droit

(Même liste que l'œil gauche.)

X est pour le bras gauche

1. Bras normal

    
   <

2. Bras vers le haut

   \
    

3. Bras vers le bas

    
   /

4. Aucun

Y comme bras droit

1. Bras normal

    
   >

2. Bras vers le haut

   /
    

3. Bras vers le bas

    
   \

4. Aucun

T est pour le torse

1. Boutons :

2. Gilet ] [

3. Armes intérieures > <

4. Aucun

B est pour Base

1. Boutons :

2. Pieds " "

3. Plat ___

4. Aucun

Défi

Ecrivez un programme qui prend une chaîne de huit caractères (via stdin ou une ligne de commande) dans le format HNLRXYTBoù chaque lettre est un chiffre de 1 à 4 indiquant le préréglage à utiliser pour la section correspondante du motoneige. Imprimez le snowperson complet sur la sortie.

Par exemple, l'entrée 11114411est le bonhomme de neige en haut de la page. (Premièrement 1: il a un chapeau de paille, deuxièmement 1: il a un nez normal, etc.)

Un autre exemple, le snowperson pour la saisie 33232124:

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

Détails

• Toutes les quantités et les combinaisons d'espaces de début / fin et de nouvelle ligne sont autorisées tant que ...

  • le snowperson a toutes ses sections correctement disposées les unes par rapport aux autres, et
  • il n'y a jamais plus de 64 caractères d'espaces blancs au total (le modèle général n'est que de 7 × 5, vous n'allez donc probablement pas atteindre cette limite).

  Vous n'avez pas besoin d'imprimer les lignes / colonnes du motif si elles ne contiennent que des espaces. par exemple, la ligne vide du chapeau de paille n'est pas requise.

• Vous devez utiliser la commande des pièces telles qu'elles sont données ci-dessus.

• Au lieu d'un programme, vous pouvez écrire une fonction qui prend la chaîne de chiffres en argument. La sortie doit être imprimée normalement ou renvoyée sous forme de chaîne.

• Vous pouvez traiter l'entrée comme un entier au lieu d'une chaîne si vous le préférez.

Notation

Le code le plus court en octets gagne.

Question bonus: Lequel des 65 536 snowpopers différents est votre préféré?

CJam, 135 134 132 130 126 125 octets

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*

Pour créer le fichier sur votre machine, exécutez xxd -r > snowman.cjam, collez le fichier hexadécimal réversible à partir du haut, appuyez sur Enteret enfin sur Ctrl+ D.

Vous pouvez également essayer le code en ligne à l'aide de l' interpréteur CJam .

Prime

Mon bonhomme de neige préféré est Olaf:

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

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

L'hiver est un bon moment pour rester et se câliner, mais mets-moi en été et je serai un… bonhomme de neige heureux!

Idée

La chaîne hexagonale

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

code les choix possibles pour toutes les parties du bonhomme de neige, y compris celles fixes. Appelons cette chaîne P .

Pour le décoder, convertissons P (ici traité comme un tableau d’entiers) de la base 256 en base 20 et remplaçons chacun des entiers résultants par le caractère correspondant de la chaîne M :

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

Cela se traduit par la chaîne T :

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

La première ligne code tous les choix de chapeaux, la dernière toutes les parties du corps fixes. Les autres lignes contiennent les 28 parties du corps variables.

Nous séparons T aux sauts de ligne et divisons les chaînes du tableau résultant en quatre parties de longueur égale. Ensuite, nous lisons l’entrée de STDIN, poussons le tableau de ses chiffres en base 10 et sélectionnons les éléments correspondants des chaînes scindées. Nous tirons parti du fait que les tableaux sont enveloppés dans CJam, de sorte que l'élément d'indice 4 d'un tableau de longueur 4 est en fait le premier élément. La dernière chaîne divisée ne correspond à aucune entrée, elle sera donc entièrement sélectionnée.

Nous manipulons le chapeau en déplaçant le premier élément du tableau résultant. L'index dans M du premier caractère, lu comme un nombre en base 4, révèle le nombre d'espaces et de traits de soulignement dans la première ligne du chapeau. Nous imprimons ces caractères, un saut de ligne, un espace et le reste de la chaîne décalée. Ensuite, nous poussons un saut de ligne supplémentaire au bas de la pile.

Pour les parties du corps, nous concaténons la chaîne correspondant à chacune d’elles. Appelons cette chaîne S . Pour assembler les parties du corps, nous réalisons translittération: nous prenons chaque caractère de la chaîne M , calculer son indice de tri (M) et le remplacer par le caractère correspondant de S . Nous profitons du fait que l’opérateur de translittération remplit automatiquement S pour qu’il corresponde à la longueur du tri (M) en répétant le dernier caractère de S autant de fois que nécessaire.

Enfin, nous divisons la chaîne résultante en sous-chaînes de longueur 7 et plaçons un saut de ligne entre chaque paire de sous-chaînes.

Code

Supposons que les variables Met Pcontiennent les chaînes M et 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 octets

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

C'est une fonction anonyme. vous l'utilisez en exécutant ([function code])('42232124'). La partie la plus agaçante de ce problème était les bras, qui occupent deux lignes. J'ai donc dû inclure du code pour le haut et le bas.

L'extrait de pile ci-dessous contient du code commenté et non-lié à ES6. Et vous pouvez l'utiliser pour tester facilement le code et essayer différentes combinaisons. Edit: Je m'amuse beaucoup trop avec ça. J'ai ajouté plusieurs nouvelles fonctionnalités, notamment un moyen de générer un bonhomme de neige aléatoire.

Merci à Yair Rand d'avoir économisé six octets.

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 octets

Génère le bonhomme de neige de gauche à droite et de haut en bas. Cela élimine le besoin de tout type d’assemblage ou de repositionnement des cordes, car je laisse tout le bonhomme de neige sur la pile. Et puis, en raison du dump de pile automatique à la fin des programmes:

♫ CJam veut construire un bonhomme de neige! ♫

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

Essayez-le en ligne.

Prime

Sortir des sentiers battus! 32443333donne une mariée (wo) homme. Vous devez essayer un peu pour le voir, mais il y a les bras intérieurs, fez + bras bas = voile, et la tête est en réalité dans le fez / voile. La forme généralement large est la robe ample, et les "yeux" et le "nez" sont des plis dans la robe.

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

D'autres choix "yeux" sont un peu risqués ...

Python, 276 289 octets

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

Ce code a 8 octets supplémentaires ( \* 4) pour la lisibilité.

Construit petit à petit le bonhomme de neige.

Prime

F("44444432") donne "ours russe endormi":

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

Python 2, 354 280 241 261 octets

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

L'appel s('33232124')donne:

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

Mais mes favoris sont 44242123et 41341144:

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

CJam, 150 145 octets

Base convertir toutes les choses!

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

SE modifie les fichiers non imprimables, voici donc une copie sur Pastebin. Assurez-vous de copier la partie "RAW Paste Data", et non la partie à côté des numéros de ligne. Vous pouvez l' essayer en ligne , mais le lien permanent peut ne pas fonctionner dans certains navigateurs.

Explication

La "b8li'U9gN;|"125:Kb8bppartie génère le tableau

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

qui mappe chaque chiffre de l'entrée à l'endroit où le chiffre est utilisé. Tout ce qui est commun à toutes les entrées (par exemple, les espaces et les espaces ()) est arbitrairement attribué un 0, sauf le premier auquel on attribue 1 afin que la conversion de base puisse fonctionner.

l:~f=convertit ensuite chaque chiffre en int et mappe en conséquence, par exemple, pour 14441133obtenir

[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= donne la ficelle

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

après quoi nous dupliquons, remplaçons /<[(par \>])et ajoutons pour donner une longue chaîne. Ensuite, nous divisons la chaîne en groupes de 4 et mappons selon un autre tableau "r pL|P3{cR`@L1iT"Kb21b, obtenant ainsi un tableau de chaînes de longueur 4 décrivant toutes les options possibles dans chaque cellule (par exemple, _=./toutes les options possibles pour le deuxième caractère de la deuxième ligne, en partant du début). Chapeau russe).

Enfin, nous mappons les options sur les entrées en conséquence .=, scindées en rangées de longueur 7 7/et alternées dans certaines nouvelles lignes N*.

Essais

11111111

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

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

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

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

TI-BASIC, 397 octets

Important: si vous souhaitez tester ceci, téléchargez-le à partir d’ ici et envoyez le fichier à votre calculatrice. N'essayez pas de copier le code ci-dessous dans l'éditeur de programme de TI-Connect CE, dans SourceCoder 3 ou dans un autre logiciel à construire et à envoyer à votre calculatrice. dans le cas de TI-Connect, il est indiqué que le jeton est invalide. SC3 utilise la barre oblique inversée comme délimiteur de commentaire ( //commence un commentaire dans SC3;, /\/mais exportera en tant que //) et ne exportera donc pas les bras, le bonnet, etc., ce qui obligera le programme à afficher les ERREUR: DOMAIN de temps en temps. Truc amusant!

Important # 2: Je suis trop paresseux pour réparer le téléchargement pour le moment, donc quand vous le transférez sur votre calcul, changez le 7sur la troisième ligne en partant du bas X+6. Le code ci-dessous est corrigé si vous devez comparer.

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: J'aime particulièrement 12341214.

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

Quelques notes:

• On peut certainement jouer davantage au golf, pas de doute. Je suis presque certain de pouvoir combiner la majorité, sinon la totalité, de la sortie dans une boucle unique (boucle). De plus, je suis presque sûr de pouvoir fusionner certaines chaînes.
• Dans Str4 (les yeux), j'utilise le "point de tracé" ( [2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct)) par opposition à un point afin que les yeux ne s'alignent pas avec la virgule, car cela a l'air bizarre.
• Dans Str8 (base), je devais utiliser une diaérèse (¨) au lieu de guillemets doubles car il n'y avait aucun moyen d'échapper aux caractères dans TI-BASIC, et les guillemets doubles étaient utilisés pour démarrer / terminer les chaînes.
• Dans TI-BASIC, il n'est pas nécessaire de fermer les parenthèses et les crochets s'ils sont suivis de deux points, d'une nouvelle ligne ou → (utilisés pour l'affectation var), et les guillemets doubles (chaînes) peuvent rester non fermés lorsqu'ils sont suivis par une nouvelle ligne ou →.

C, 280 272 264 octets

Seulement partiellement joué au golf à ce stade, mais c'est un défi amusant.

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

(Avec un peu plus de \ n pour plus de lisibilité.) Je pense que le definegolf devrait disparaître.

Une version plus lisible est

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

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

Une version lisible:

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

J'ai repris l'idée de la réponse de Reto Koradi . J'ai apporté plusieurs améliorations amusantes qui mériteraient peut-être une réponse distincte:

• Converti de fonction en programme (+10)
• Déplacement de nouvelles lignes dans la chaîne de contrôle (-7)
• Ajout de 3 à tous les codes de caractères pour avoir moins de caractères échappés comme \"(-3)
• Lecture de la chaîne avec auto-incrémentation; également remplacé t[i++]par *t++(-4)
• Remplacé whilepar for; enlevé {}(-4)
• Terminaison de boucle simplifiée: lecture jusqu'à \0 (-9)
• Transformé t[...],t+=4en(...)[t+=4] pour éliminer l'opérateur de virgule (-1)

Pourquoi tout ce problème? Pour partager mon préféré, fantôme de neige:

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

JavaScript, 489 (sans nouvelles lignes et sans onglets)

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

courir avec node snowman.js 33232124

Pyth, 203 octets

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. Essayez-le en ligne: Compilateur / Exécuteur Pyth

Explication

Je définis d'abord une fonction d'assistance g, qui prend une liste et un caractère en entrée, convertit le caractère en sa valeur ASCII et prend l'élément correspondant (wrapping modulaire).

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

Les autres choses ne font qu'imprimer ligne par ligne. Par exemple, la première ligne est:

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

Btw. J'ai expérimenté un peu avec .F"{:^7}", ce qui centre une chaîne. En l'utilisant, je pourrais économiser quelques espaces dans mon code, mais cela ne sauvegardera aucun octet à la fin.

R, 436 437 octets

Voici mon premier essai sur le code-golf , en utilisant R qui n'est pas le plus court mais qui reste amusant. Au moins, je bat JavaScript (pour l'instant) ...

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

Essai:

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

En fait , je débattais avec Xet Yêtre multilined mais avec des choses entre les deux, a fini par séparer chaque ligne ( X, S) et ( Y, U).

function et la conversion de chaîne en entier sont également très prolifiques.

Éditer 436 => 437

A dû réparer un espace vide manquant remarqué par @OganM

Je pourrais réduire à 428 en remplaçant les sauts de ligne entre les variables par ;, mais le code "à une ligne" a un look tellement mauvais et illisible que je ne serai pas si gourmand.

Haskell, 361 306 289 octets

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

Usage:

putStrLn $ p "12333321"

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

Comment ça marche: indexez chaque élément de la liste [hat options, left upper arm options, left eye options, ..., base options] avec le numéro d’entrée correspondant et concaténez-le en une seule liste. J'ai divisé le bras gauche et le bras droit en une partie supérieure et inférieure afin de pouvoir construire le bonhomme de neige ligne par ligne.

Mon préféré est le classique 11112211.

Edit: est passé de la liste des chaînes aux chaînes des parties (chapeau, oeil, ...). Nécessite un deuxième paramètre, la longueur de la sous-chaîne à prendre.

Edition II: sous-chaînes communes extraites

C, 233 230 octets

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

Avec des nouvelles lignes et des espaces pour une meilleure lisibilité:

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

Le tout est une force assez brute. Il utilise une table qui contient une entrée pour chacun des 35 caractères (5 lignes de longueur 7). Chaque entrée dans la table est soit:

• Un caractère constant: , (, ). La longueur de la table est de 1 caractère.
• Index de la partie du corps, suivi des 4 caractères possibles en fonction de la sélection de la partie dans l'entrée. La longueur de la table est de 5 caractères.

Le code parcourt ensuite les 35 caractères et recherche la valeur dans la table.

R 414 octets

Version légèrement modifiée de la version 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="")}

Vient de fusionner les variables distinctes en une seule. Shawing de l'espace qui a été utilisé pour la X=c(routine.

CJam, 200 191 octets

Cela peut sûrement être joué au golf beaucoup. (Surtout si je base l'encodage). Mais voici pour commencer:

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'entrée va dans STDIN. Par exemple, input 23232223donne:

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

Essayez-le en ligne ici

Haskell, 333 octets

Ma première soumission! Construit le bonhomme de neige de haut en bas, de gauche à droite. Je divise les bras en deux fonctions pour chaque bras, la partie à côté de la tête et la partie à côté du corps.

La fonction s prend une liste d’entiers et concatène la sortie des fonctions qui produisent les parties du corps avec des sous-listes correctes de l’entrée.

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

Il s'appuie sur la fonction

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

qui retourne le nième élément de la liste qui lui est donnée. Cela permet la liste des chapeaux dans un, ainsi que des choses comme

k=y" /  "

toutes ces fonctions utilisent une réduction bêta de sorte que leur argument est passé comme index à la fonction y.

Sortie:

λ> s $ repeat 1

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

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

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

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

Python 3, 349 336 254 251 octets

Voilà pour ma thèse.

Voici le contenu du fichier 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)]))

Et voici comment je conjure mon bonhomme de neige préféré:

s('11112311')

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

Explication

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

Inspiré par Reto Koradi et 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

Essayez-le en ligne!

Remarque: la ligne 3 a 2 espaces de sentier, la ligne 4 a un espace de sentier.

Mon préféré est 44444444"garde russe endormi":

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

JavaScript (ES6), 247

Pas aussi bon annonce @ NinjaBearMonkey's :(

Test en extrait (avec 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 octets

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

-6 octets grâce à @Grimy .

Essayez-le en ligne ou vérifiez quelques autres cas de test .

Explication:

Nous créons d'abord le template-string:

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

Qui ressemble à ceci:

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

Ensuite, je boucle sur les chiffres de l'entrée:

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

Et procédez comme suit:
Appuyez sur l'index (indexé 0) Nde la liste:

  N          # Push the index of the loop

Poussez toutes les parties possibles en tant que liste de listes de caractères:

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

Utilisez l'index de boucle Npour obtenir la liste de caractères de la partie avec laquelle nous travaillons actuellement:

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

Ensuite, divisez la liste de caractères en quatre parties égales et utilisez le chiffre d'entrée y(indexé 1) pour l'indexer. (REMARQUE:. Comme 05AB1E est 0 indexées, mais l'entrée est 1-indexé, il serait logique de réduire le chiffre de 1 avant l' indexation Cependant, depuis 05AB1E a wraparound automatique ( par exemple l' indexation 3dans la liste [1,3,5]entraînera 1), je simplement Une fois les pièces tournées, les pièces avec le numéro 4 dans la description du défi se trouvent en tête des listes.)

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

Et puis remplacez l'index 0-indexé de la boucle que nous avons d'abord poussée, un par un, avec les caractères de la pièce:

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

Et à la fin, le résultat est généré implicitement.

Consultez cette astuce 05AB1E (section Comment compresser de grands entiers? Et Comment compresser des listes d’entiers? ) Pour comprendre le fonctionnement des éléments de compression.

Quant à mon préféré, c'est toujours le même "lapin de neige" qu'il y a un an et demi lorsque j'ai posté ma solution Java :

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

Java 8, 548 545 432 401 399 octets

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

Essayez ici.

Explication:

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

Mon préféré:

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

Je ne sais pas pourquoi, mais ça a l'air plutôt mignon. Comme un lapin avec un chapeau russe à la place des oreilles.

F #, 369 octets

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]

Essayez-le en ligne!

Parce que gutilise un accesseur de tableau, je dois spécifier explicitement le type dans la définition de fonction en tant que string, ce qui explique pourquoi la définition de fonction a (g:string).

En dehors de cela, il s'agit généralement d'un tableau d' stringsindex auquel on a accès. Le chapeau, les bras gauche et droit qui iraient sur des lignes séparées sont divisés en rangées supérieure et inférieure séparées. La ifonction change un nombre dans l'argument gdans l'index du tableau. Et la lettreb remplace les chaînes d'un espace dans les tableaux.

Grand défi! Mon bonhomme de neige préféré est probablement 242244113:

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

je te surveille

PHP, 378 octets

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

Essayez-le en ligne!

J'aime les sages M. Chouette 31333342

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

Python 2.7, 257 octets (je pense)

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

où 'i' est l'entrée sous forme de chaîne (par exemple "13243213")

Dart , 307 octets

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

Essayez-le en ligne!

Zsh, 247 octets

essayez-le en ligne !!

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

bonhomme de neige fav:

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