Hier ist ein einfacher ASCII-Kunstschneemann :

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

Machen wir ihm ein paar Freunde. Dies wird das allgemeine Muster für unsere ASCII-Kunstschneefahrer sein:

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

Die führenden Leerzeichen und die Klammern sind für alle Schneemänner immer gleich. Die verschiedenen Buchstaben stellen Abschnitte des Musters dar, die sich individuell ändern können. Jeder Abschnitt verfügt über genau vier Vorgaben, mit denen ASCII-Zeichen gefüllt werden können. Durch Mischen und Anpassen dieser Voreinstellungen für alle acht Abschnitte können wir eine Vielzahl von Schneemännern erstellen.

Alle Voreinstellungen

^{(Beachten Sie, dass Leerzeichen in ansonsten leere Zeilen gesetzt werden, damit die Abschnittsform immer korrekt ist.)}

H ist für Hut

1. Strohhut

        
   _===_

2. Mexikanischer Hut

    ___ 
   .....
   

3. Fez

     _  
    /_\ 
   

4. Russischer Hut

    ___ 
   (_*_)
   

N ist für Nase / Mund

1. Normal ,

2. Punkt .

3. Linie _

4. Keiner

L steht für das linke Auge

1. Punkt .

2. Größerer Punkt o

3. Größter Punkt O

4. Geschlossen -

R steht für das rechte Auge

(Gleiche Liste wie linkes Auge.)

X steht für den linken Arm

1. Normaler Arm

    
   <

2. Arm nach oben

   \
    

3. Arm nach unten

    
   /

4. Keiner

Y steht für den rechten Arm

1. Normaler Arm

    
   >

2. Arm nach oben

   /
    

3. Arm nach unten

    
   \

4. Keiner

T ist für Torso

1. Tasten :

2. Weste ] [

3. Innere Arme > <

4. Keiner

B steht für Base

1. Tasten :

2. Füße " "

3. Eben ___

4. Keiner

Herausforderung

Schreiben Sie ein Programm, das HNLRXYTBeine achtstellige Zeichenfolge (über stdin oder Befehlszeile) in dem Format enthält , in dem jeder Buchstabe eine Ziffer von 1 bis 4 ist, die angibt, welche Voreinstellung für den entsprechenden Abschnitt des Schneemanns verwendet werden soll. Drucken Sie den vollen Schneemann auf stdout.

Die Eingabe 11114411ist beispielsweise der Schneemann oben auf der Seite. (Erstens 1: Er hat einen Strohhut, zweitens 1: Er hat eine normale Nase usw.)

Ein weiteres Beispiel, der Schneemann für die Eingabe 33232124:

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

Einzelheiten

• Beliebige Mengen und Kombinationen von führenden / nachfolgenden Leerzeichen und führenden / nachfolgenden Zeilenumbrüchen sind zulässig, solange ...

  • der Schneemann hat alle seine Abschnitte richtig zueinander angeordnet, und
  • Es gibt nie mehr als 64 Whitespace-Zeichen insgesamt (das allgemeine Muster ist nur 7 × 5, sodass Sie dieses Limit wahrscheinlich nicht erreichen werden).

  Sie müssen keine Zeilen / Spalten des Musters drucken, wenn sie nur Leerzeichen enthalten. zB die Leerzeile des Strohhutes wird nicht benötigt.

• Sie müssen die oben angegebene Reihenfolge der Teile verwenden.

• Anstelle eines Programms können Sie eine Funktion schreiben, die die Ziffernfolge als Argument verwendet. Die Ausgabe sollte normal gedruckt oder als Zeichenfolge zurückgegeben werden.

• Bei Bedarf können Sie die Eingabe als Ganzzahl anstelle einer Zeichenfolge behandeln.

Wertung

Der kürzeste Code in Bytes gewinnt.

Bonusfrage : Welcher der 65536 verschiedenen Schneemänner ist Ihr Favorit?

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*

Um die Datei auf Ihrem Computer zu erstellen, führen Sie aus xxd -r > snowman.cjam, fügen Sie den reversiblen Hexdump von oben ein, drücken Sie Enterund schließlich Ctrl+ D.

Alternativ können Sie den Code online mit dem CJam-Interpreter testen .

Bonus

Mein Lieblingsschneemann ist Olaf:

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

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

Der Winter ist eine gute Zeit zum Kuscheln und Verweilen, aber wenn ich in den Sommer komme, werde ich ein… glücklicher Schneemann sein!

Idee

Die Hex-Zeichenfolge

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

codiert die möglichen Auswahlen für alle Teile des Schneemanns, einschließlich der festen. Lassen Sie uns diese Zeichenfolge nennen P .

Um es zu dekodieren, konvertieren wir P (hier als ein Array von Ganzzahlen behandelt) von der Basis 256 zur Basis 20 und ersetzen jede der resultierenden Ganzzahlen durch das entsprechende Zeichen der Zeichenkette M :

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

Dies ergibt den String T :

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

Die erste Zeile kodiert alle Hutwahlen, die letzten alle festen Körperteile. Die anderen Zeilen enthalten die 28 variablen Körperteile.

Wir teilen T in Zeilenvorschübe und teilen die Strings des resultierenden Arrays in vier Teile gleicher Länge. Dann lesen wir die Eingabe von STDIN, verschieben das Array seiner Ziffern in Basis 10 und wählen die entsprechenden Elemente der geteilten Zeichenfolgen aus. Wir machen uns die Tatsache zunutze, dass Arrays in CJam herumlaufen, sodass das Element am Index 4 eines Arrays der Länge 4 tatsächlich das erste Element ist. Die zuletzt geteilte Zeichenfolge entspricht keiner Eingabe und wird daher vollständig ausgewählt.

Wir behandeln den Hut, indem wir das erste Element aus dem resultierenden Array herausschieben. Der Index in M des ersten Zeichens, der als Zahl zur Basis 4 gelesen wird, gibt die Anzahl der Leerzeichen und Unterstriche in der ersten Zeile des Hutes an. Wir drucken diese Zeichen, einen Zeilenvorschub, ein Leerzeichen und den Rest der verschobenen Zeichenfolge. Dann schieben wir einen zusätzlichen Zeilenvorschub auf die Unterseite des Stapels.

Für die Körperteile verketten wir die Zeichenfolge, die allen von ihnen entspricht. Lassen Sie uns diese Zeichenfolge rufen S . Um die Körperteile zusammenzubauen, wir Transliteration ausführen: wir nehmen jedes Zeichen der Zeichenkette M , berechnet seinen Index in sort (M) und ersetzen sie durch das entsprechende Zeichen von S . Wir machen uns die Tatsache zunutze, dass der Transliterationsoperator S automatisch an die Länge der Sortierung (M) anpasst, indem er das letzte Zeichen von S so oft wie nötig wiederholt .

Zum Schluss teilen wir die resultierende Zeichenfolge in Teilzeichenfolgen der Länge 7 und platzieren einen Zeilenvorschub zwischen jedem Teilzeichenfolgenpaar.

Code

Nehmen wir an, dass die Variablen Mund Penthalten die Saiten M und 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]||' ')

Dies ist eine anonyme Funktion. Sie verwenden es, indem Sie ausführen ([function code])('42232124'). Der erschwerendste Teil davon waren die Arme, die 2 Zeilen einnehmen, also musste ich Code für oben und unten einfügen.

Das folgende Stack-Snippet enthält kommentierten, nicht mit ES6 versehenen Code. Damit können Sie den Code ganz einfach testen und verschiedene Kombinationen ausprobieren. Edit: Ich habe viel zu viel Spaß damit. Ich habe einige neue Funktionen hinzugefügt, darunter eine Möglichkeit, einen zufälligen Schneemann zu generieren.

Vielen Dank an Yair Rand für das Speichern von sechs 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

Erzeugt den Schneemann von links nach rechts und von oben nach unten. Auf diese Weise müssen keine Fäden mehr zusammengefügt oder neu positioniert werden, da ich einfach jedes Stück des Schneemanns auf dem Stapel liegen lasse. Und dann, aufgrund des automatischen Stack-Dumps am Ende von Programmen:

♫ CJam will einen Schneemann bauen! ♫

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

Probieren Sie es online aus.

Bonus

In andere Richtungen denken! 32443333gibt einem schneemann eine braut. Du musst ein bisschen versuchen, es zu sehen, aber es gibt die inneren Arme, Fez + untere Arme = Schleier, und der Kopf ist tatsächlich im Fez / Schleier. Die allgemein große Form ist das wogende Kleid, und die "Augen" und "Nase" sind Falten im Kleid.

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

Andere "Auge" Entscheidungen sind ein bisschen riskant ...

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

Dieser Code verfügt \zur besseren Lesbarkeit über 8 zusätzliche Bytes ( * 4).

Baut den Schneemann Stück für Stück auf.

Bonus

F("44444432") gibt "verschlafenen russischen Bären":

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

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

Anrufen s('33232124')gibt:

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

Aber meine Favoriten sind 44242123und 41341144:

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

CJam, 150 145 Bytes

Basis konvertieren alle Dinge!

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

SE mangelt an nicht druckbaren Dateien. Hier ist eine Kopie von Pastebin. Stellen Sie sicher, dass Sie den Teil "RAW Paste Data" kopieren, nicht den Teil neben den Zeilennummern. Sie können es online ausprobieren , aber der Permalink funktioniert in einigen Browsern möglicherweise nicht.

Erläuterung

Das "b8li'U9gN;|"125:Kb8bpTeil generiert das 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]

Hiermit wird jede Ziffer der Eingabe dem Ort zugeordnet, an dem die Ziffer verwendet wird. Allen Eingaben (z. B. führenden Leerzeichen und ()) , die allen Eingaben gemeinsam sind, wird willkürlich eine 0 zugewiesen, mit Ausnahme der ersten, die 1 zugewiesen wird, damit die Basiskonvertierung funktionieren kann.

l:~f=konvertiert dann jede Ziffer in ein int und ordnet sie entsprechend zu, zB für das 14441133wir bekommen

[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= gibt die Zeichenfolge

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

Danach duplizieren wir, ersetzen /<[(mit \>])und fügen einen langen String hinzu. Dann teilen wir den String in 4er - Gruppen auf und ordnen ihn einem anderen Array zu "r pL|P3{cR`@L1iT"Kb21b. Auf diese Weise erhalten wir ein Array von Strings der Länge 4, die alle möglichen Optionen in jeder Zelle beschreiben (z. B. _=./sind alle möglichen Optionen für das zweite Zeichen in der zweiten Zeile ab dem Russischer Hut).

Schließlich ordnen wir die Optionen den Eingaben entsprechend zu .=, teilen sie in Zeilen mit der Länge 7 auf 7/und riffeln einige Zeilenumbrüche ein N*.

Testläufe

11111111

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

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

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

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

TI-BASIC, 397 Bytes

Wichtig: Wenn Sie dies testen möchten, laden Sie es von hier herunter und senden Sie die Datei an Ihren Rechner. Versuchen Sie nicht , den folgenden Code in den Programmeditor oder SourceCoder 3 von TI-Connect CE zu kopieren, um ihn zu erstellen, und senden Sie ihn an Ihren Rechner. Im Fall von TI-Connect wird ein ungültiges Token angezeigt. SC3 verwendet den umgekehrten Schrägstrich als Kommentarbegrenzer ( //startet einen Kommentar in SC3; /\/wird jedoch als exportiert //) und exportiert daher die Arme und den Hut usw. nicht korrekt, wodurch das Programm die falschen Körperteile anzeigt und einen Wurf ausführt FEHLER: Von Zeit zu Zeit DOMAIN. Lustige Sachen!

Wichtig Nr. 2: Ich bin zu faul, um den Download im Moment zu reparieren. Wenn Sie ihn also auf Ihren Rechner übertragen, ändern Sie den Wert 7in der dritten Zeile von unten in X+6. Der folgende Code ist behoben, wenn Sie vergleichen müssen.

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: Ich mag es besonders gern 12341214.

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

Einige Notizen:

• Es kann definitiv mehr Golf gespielt werden, keine Frage. Ich bin mir fast sicher, dass ich die meisten, wenn nicht alle Ausgaben in einer einzigen For (-Schleife kombinieren kann. Außerdem bin ich mir ziemlich sicher, dass ich einige Zeichenfolgen zusammenführen kann.
• In Str4 (die Augen) verwende ich den "Handlungspunkt" ( [2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct)) im Gegensatz zu einem Punkt, damit die Augen nicht mit dem Komma fluchten, weil das höllisch komisch aussieht.
• In Str8 (Basis) musste ich anstelle von doppelten Anführungszeichen eine Diaeresis (¨) verwenden, da in TI-BASIC kein Escapezeichen möglich ist und doppelte Anführungszeichen zum Starten / Beenden von Zeichenfolgen verwendet werden.
• In TI-BASIC müssen Klammern und Klammern nicht geschlossen werden, wenn ihnen ein Doppelpunkt, ein Zeilenumbruch oder ein → (für die Var-Zuweisung verwendet) folgt, und doppelte Anführungszeichen (Zeichenfolgen) können nicht geschlossen werden, wenn ein Zeilenumbruch oder ein → folgt.

C 280 272 264 Bytes

Zu diesem Zeitpunkt nur teilweise Golf gespielt, aber das ist eine lustige Herausforderung.

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

(Mit einigem Extra \ n für die Lesbarkeit.) Ich definegehe davon aus, dass das weitere Golfen ein Ende haben sollte.

Eine lesbarere Version ist

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

Eine lesbare Version:

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

Ich habe die Idee der Antwort von Reto Koradi entnommen . Ich habe einige unterhaltsame Verbesserungen vorgenommen, die möglicherweise eine separate Antwort rechtfertigen:

• Konvertiert von Funktion zu Programm (+10)
• Zeilenumbrüche in die Steuerzeichenfolge verschoben (-7)
• 3 zu allen Zeichencodes hinzugefügt, um weniger entgangene Zeichen wie \"(-3) zu erhalten
• Lesen von der Saite mit Autoincrement; auch ersetzt t[i++]durch *t++(-4)
• Ersetzt whiledurch for; entfernt {}(-4)
• Vereinfachte Schleifenbeendigung: Lesen bis \0(-9)
• Transformiert t[...],t+=4,(...)[t+=4] um den Komma-Operator (-1) zu entfernen

Warum all diese Schwierigkeiten? Um meinen Favoriten, den Schneegeister, zu teilen:

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

JavaScript, 489 (ohne Zeilenumbrüche und Tabulatoren)

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

renn mit 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\)

Lol. Probieren Sie es online aus: Pyth Compiler / Executor

Erläuterung

Zuerst definiere ich eine Hilfsfunktion g, die eine Liste und ein Zeichen als Eingabe verwendet, das Zeichen in seinen ASCII-Wert konvertiert und ein entsprechendes Element (modulares Wrapping) annimmt.

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

Das andere ist, nur Zeile für Zeile zu drucken. Zum Beispiel ist die erste Zeile:

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

Btw. Ich habe ein bisschen experimentiert .F"{:^7}", bei dem eine Saite zentriert ist. Wenn ich es benutze, könnte ich ein paar Leerzeichen in meinem Code speichern, aber am Ende werden keine Bytes gespeichert.

R, 436 437 Bytes

Hier ist mein erster Versuch mit Code-Golf , wobei R nicht das kürzeste ist, aber trotzdem Spaß macht. Zumindest bin ich gegen JavaScript (für jetzt) ​​...

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

Testen:

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

Ich kämpfte tatsächlich mit Xund Ywar mehrzeilig, aber mit Dazwischen, und trennte schließlich jede Zeile in ( X, S) und ( Y, U).

function Die Konvertierung von String in Integer ist ebenfalls sehr ausführlich.

Edit 436 => 437

Musste einen fehlenden leeren Raum reparieren, der von @OganM bemerkt wurde

Ich könnte die Zeilenumbrüche zwischen Variablen auf 428 reduzieren ;, aber der "einzeilige" Code sieht so schlecht und unleserlich aus, dass ich nicht so gierig sein werde.

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

Verwendungszweck:

putStrLn $ p "12333321"

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

So funktioniert es: Indizieren Sie jedes Element der Liste von [hat options, left upper arm options, left eye options, ..., base options]mit der entsprechenden Eingangsnummer und verknüpfen Sie es zu einer einzigen Liste. Ich habe den linken und rechten Arm in einen oberen und einen unteren Teil geteilt, damit ich den Schneemann Zeile für Zeile bauen kann.

Mein Favorit ist der Klassiker 11112211.

Bearbeiten: Wechselt von der Liste der Zeichenfolgen zu Zeichenfolgen für die Teile (Hut, Auge, ...). Benötigt einen zweiten Parameter, die Länge des zu nehmenden Teilstrings.

Edit II: extrahierte gemeinsame Teilstrings

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

Mit Zeilenumbrüchen und Leerzeichen für bessere Lesbarkeit:

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

Das Ganze ist ziemlich brachial. Es wird eine Tabelle verwendet, die einen Eintrag für jedes der 35 (5 Zeilen mit der Länge 7) Zeichen enthält. Jeder Eintrag in der Tabelle ist entweder:

• Ein konstanter Charakter: , (, ). Die Länge des Tabelleneintrags beträgt 1 Zeichen.
• Index des Körperteils, gefolgt von den 4 möglichen Zeichen, abhängig von der Teileauswahl in der Eingabe. Die Länge des Tabelleneintrags beträgt 5 Zeichen.

Der Code durchläuft dann die 35 Zeichen und schlägt den Wert in der Tabelle nach.

R 414 Bytes

Leicht modifizierte Version von Molx 'Version

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

Einfach die einzelnen Variablen zu einer zusammenfassen. Etwas Platz, der für X=c(Routinezwecke genutzt wurde.

CJam, 200 191 Bytes

Dies kann sicherlich viel golfen werden. (Speziell wenn ich es Base codiere). Aber hier geht für den Anfang:

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

Die Eingabe erfolgt in STDIN. Beispielsweise gibt die Eingabe 23232223Folgendes aus:

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

Probieren Sie es hier online aus

Haskell, 333 Bytes

Meine erste Einreichung! Baut den Schneemann von oben nach unten, von links nach rechts. Ich habe die Arme für jeden Arm in zwei Funktionen aufgeteilt, den Teil neben dem Kopf und den Teil neben dem Körper.

Die Funktion s nimmt eine Liste von ganzen Zahlen und verkettet die Ausgabe der Funktionen, die die Körperteile erzeugen, wenn die richtigen Unterlisten der Eingabe gegeben sind.

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

Es hängt von der Funktion ab

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

Dies gibt das n-te Element der angegebenen Liste zurück. Dies ermöglicht die Liste der Hüte in, sowie Dinge wie

k=y" /  "

Alle diese Funktionen verwenden eine Beta-Reduktion, sodass ihr Argument als Index an die y-Funktion übergeben wird.

Ausgabe:

λ> s $ repeat 1

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

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

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

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

Python 3, 349 336 254 251 Bytes

Soviel zu meiner Abschlussarbeit.

Hier ist der Inhalt der Datei 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)]))

Und so zaubere ich meinen Lieblingsschneemann:

s('11112311')

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

Erläuterung

# 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

Inspiriert von Reto Koradi und 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

Probieren Sie es online!

Hinweis: Die Linie 3 hat 2 Trailfelder, die Linie 4 hat ein Trailfeld.

Mein Favorit ist 44444444"sleepy russian guard":

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

JavaScript (ES6), 247

Nicht so gute Anzeige @ NinjaBearMonkey's :(

Test im Snippet (mit 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 dank @Grimy .

Probieren Sie es online aus oder überprüfen Sie ein paar weitere Testfälle .

Erläuterung:

Wir erstellen zuerst den 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)"

Welches sieht so aus:

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

Dann schleife ich über die Ziffern der Eingabe:

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

Und machen Sie folgendes:
Verschieben Sie den (0-indizierten) Index Nder Liste:

  N          # Push the index of the loop

Verschiebe alle möglichen Teile als Liste von Charakterlisten:

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

Verwenden Sie den Schleifenindex N, um die Zeichenliste des Teils abzurufen, mit dem wir gerade arbeiten:

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

Teilen Sie dann die Zeichenliste in vier gleiche Teile auf und yindizieren Sie sie mit der eingegebenen Ziffer (die 1-indiziert ist). (HINWEIS: Da 05AB1E 0-indiziert ist, die Eingabe jedoch 1-indiziert ist, ist es logisch, die Ziffer vor der Indizierung um 1 zu verringern. Da 05AB1E jedoch einen automatischen Wraparound aufweist (dh die Indizierung 3in der Liste [1,3,5]führt zu 1), führe ich dies einfach aus drehte die Teile einmal, so dass Teile mit Nr. 4 in der Herausforderungsbeschreibung an der Spitze der Listen stehen.)

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

Und dann ersetze den 0-indizierten Index der Schleife, die wir zuerst verschoben haben, nacheinander durch die Teilzeichen:

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

Und am Ende wird das Ergebnis implizit ausgegeben.

In diesem meiner Tipps zu 05AB1E (Abschnitt Komprimieren großer Ganzzahlen und Komprimieren von Ganzzahllisten ) erfahren Sie , wie die Komprimierungsteile funktionieren.

Mein Favorit ist immer noch derselbe Schneehase wie vor 1,5 Jahren, als ich meine Java-Lösung veröffentlichte :

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

Probieren Sie es hier aus.

Erläuterung:

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

Mein Favorit:

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

Ich weiß nicht warum, aber es sieht irgendwie süß aus. Wie ein Hase mit russischem Hut statt Ohren.

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]

Probieren Sie es online!

Da gein Array-Accessor verwendet wird, muss der Typ in der Funktionsdefinition explizit als a angegeben werden string, weshalb die Funktionsdefinition über Folgendes verfügt (g:string).

Abgesehen davon ist es normalerweise ein Array, auf das stringsein Index zugreift. Der Hut, der linke und der rechte Arm, die auf getrennten Linien laufen würden, sind in getrennte obere und untere Felder aufgeteilt. Die iFunktion ändert eine Zahl im Argument gin den Array-Index. Und der Buchstabe bersetzt die Ein-Leerzeichen-Zeichenfolgen in den Arrays.

Große Herausforderung! Mein Lieblingsschneemann ist wahrscheinlich 242244113:

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

Ich beobachte dich

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

Probieren Sie es online!

Ich mag weise Mr. Owl 31333342

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

Python 2.7, 257 Bytes (glaube ich)

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

wobei 'i' die Eingabe als String ist (zB "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]]})';}

Probieren Sie es online!

Zsh, 247 Bytes

Probiere es online aus !!

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

Lieblingsschneemann:

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