Oto prosty bałwan artystyczny ASCII :

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

Zróbmy mu przyjaciół. Będzie to ogólny wzorzec dla naszych śnieżnych artystów ASCII:

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

Wiodące miejsca i nawiasy są zawsze takie same dla wszystkich snowpeople. Różne litery reprezentują sekcje wzoru, które można indywidualnie zmieniać. Każda sekcja ma dokładnie cztery ustawienia wstępne dla tego, jakie znaki ASCII mogą ją wypełnić. Mieszając i dopasowując te ustawienia wstępne dla wszystkich ośmiu sekcji, możemy stworzyć różnych snowpeople.

Wszystkie ustawienia wstępne

^{(Zauważ, że spacje są umieszczane w przeciwnym razie puste linie, więc kształt przekroju jest zawsze poprawny.)}

H jest dla Hat

1. Słomiany kapelusz

        
   _===_

2. Meksykański kapelusz

    ___ 
   .....
   

3. Fez

     _  
    /_\ 
   

4. Rosyjski kapelusz

    ___ 
   (_*_)
   

N oznacza nos / usta

1. Normalna ,

2. Kropka .

3. Linia _

4. Żaden

L oznacza lewe oko

1. Kropka .

2. Większa kropka o

3. Największa kropka O

4. Zamknięte -

R oznacza prawe oko

(Ta sama lista co dla lewego oka.)

X oznacza lewe ramię

1. Normalne ramię

    
   <

2. Ramię w górę

   \
    

3. Ramię w dół

    
   /

4. Żaden

Y oznacza prawą rękę

1. Normalne ramię

    
   >

2. Ramię w górę

   /
    

3. Ramię w dół

    
   \

4. Żaden

T jest dla tułowia

1. guziki :

2. Kamizelka ] [

3. Wewnętrzne ramiona > <

4. Żaden

B oznacza bazę

1. guziki :

2. Stopy " "

3. Mieszkanie ___

4. Żaden

Wyzwanie

Napisz program, który pobierze ośmioznakowy ciąg znaków (w formacie stdin lub wiersza poleceń) w formacie HNLRXYTB, w którym każda litera jest cyfrą od 1 do 4, która wskazuje, które ustawienie wstępne należy zastosować dla odpowiedniej sekcji snowperson. Wydrukuj cały snowperson na stdout.

Na przykład dane wejściowe 11114411to bałwan na górze strony. (Po pierwsze 1: ma słomkowy kapelusz, po drugie 1: ma normalny nos itp.)

Kolejny przykład, snowperson dla danych wejściowych 33232124:

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

Detale

• Dowolne ilości i kombinacje spacji wiodących / końcowych i nowych / wiodących znaków nowej linii są dozwolone, dopóki ...

  • snowperson ma odpowiednio ustawione wszystkie sekcje względem siebie, oraz
  • nigdy nie ma więcej niż 64 znaków białych znaków (ogólny wzór to tylko 7 × 5, więc prawdopodobnie nie przekroczysz tego limitu).

  Nie trzeba drukować wierszy / kolumn wzoru, jeśli zawierają one tylko białe znaki. np. pusta linia słomkowego kapelusza nie jest wymagana.

• Musisz użyć kolejności części, jak podano powyżej.

• Zamiast programu możesz napisać funkcję, która przyjmuje ciąg cyfr jako argument. Dane wyjściowe powinny być wydrukowane normalnie lub zwrócone jako ciąg.

• Jeśli chcesz, możesz traktować dane wejściowe jako liczbę całkowitą zamiast ciągu.

Punktacja

Najkrótszy kod w bajtach wygrywa.

Pytanie dodatkowe: Który z 65536 różnych snowparian jest twoim ulubionym?

CJam, 135 134 132 130 126 125 bajtów

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*

Aby utworzyć plik na komputerze, wykonaj xxd -r > snowman.cjam, wklej odwracalny zrzut heksowy z góry, naciśnij Enteri na końcu Ctrl+ D.

Alternatywnie możesz wypróbować kod online za pomocą interpretera CJam .

Premia

Moim ulubionym bałwanem jest Olaf:

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

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

Zima to dobry czas, aby zostać i przytulić się, ale zostaw mnie latem, a ja będę ... szczęśliwym bałwanem!

Pomysł

Ciąg szesnastkowy

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

koduje możliwe wybory dla wszystkich części bałwana, w tym stałych. Nazwijmy ten ciąg P .

Aby go zdekodować, konwertujemy P (tutaj traktowane jako tablicę liczb całkowitych) z podstawy 256 na podstawę 20 i zastępujemy każdą z wynikowych liczb całkowitych odpowiednim znakiem ciągu M :

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

Wynikiem jest ciąg T :

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

Pierwsza linia koduje wszystkie wybory kapelusza, ostatnia wszystkie stałe części ciała. Pozostałe linie zawierają 28 zmiennych części ciała.

Dzielimy T przy liniach i dzielimy łańcuchy wynikowej tablicy na cztery części o równej długości. Następnie odczytujemy dane wejściowe ze STDIN, wciskamy tablicę cyfr w bazie 10 i wybieramy odpowiednie elementy podzielonych ciągów. Korzystamy z faktu, że tablice owijają się w CJam, więc element o indeksie 4 tablicy o długości 4 jest tak naprawdę pierwszym elementem. Ostatni podzielony ciąg nie odpowiada żadnym wejściom, więc zostanie wybrany całkowicie.

Obsługujemy kapelusz, przesuwając pierwszy element poza wynikową tablicę. Indeks w M pierwszego znaku, odczytany jako podstawowa liczba 4, pokazuje liczbę spacji i znaków podkreślenia w pierwszym wierszu czapki. Drukujemy te znaki, przesuw linii, spację i resztę przesuniętego łańcucha. Następnie wciskamy dodatkowe podawanie linii na spodzie stosu.

W przypadku części ciała łączymy ciąg odpowiadający im wszystkim. Nazwijmy ten ciąg S . W celu zmontowania części ciała wykonujemy transliteracje: wziąć każdy znak łańcucha M , obliczyć jego indeks rodzaju (M) i zastąpienie go przez odpowiedni charakteru S . Korzystamy z faktu, że operator transliteracji automatycznie dopełnia S, aby dopasować długość sortowania (M) , powtarzając ostatni znak S tyle razy, ile to konieczne.

Na koniec dzielimy powstały ciąg na podciągi o długości 7 i umieszczamy linię między każdą parą podciągów.

Kod

Załóżmy, że zmienne Mi Pzawierają ciągi M i 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 bajtów

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

To anonimowa funkcja; używasz go wykonując ([function code])('42232124'). Najbardziej irytującą częścią tego były ramiona, które zajmują 2 linie, więc musiałem dołączyć kod zarówno dla góry, jak i dołu.

Poniższy fragment stosu zawiera niepopoznany kod, skomentowany niezgodnie z ES6. Możesz go użyć do łatwego przetestowania kodu i wypróbowania różnych kombinacji. Edycja: Mam za dużo zabawy z tym. Dodałem kilka nowych funkcji, w tym sposób generowania losowego bałwana.

Dzięki Yair Rand za oszczędność sześciu bajtów.

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 bajty

Generuje bałwana od lewej do prawej, od góry do dołu. Eliminuje to konieczność wykonywania jakichkolwiek operacji łączenia lub zmiany pozycji sznurka, ponieważ zostawiam każdy kawałek bałwana na stosie. A następnie, z powodu automatycznego zrzutu stosu na końcu programów:

♫ CJam chce zbudować bałwana! ♫

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

Wypróbuj online.

Premia

Myśleć poza szablonowo! 32443333daje oblubienicy człowieka ze śniegu. Musisz trochę to zobaczyć, ale są ramiona wewnętrzne, fez + ramiona skierowane w dół = welon, a głowa faktycznie znajduje się w fezie / welonie. Ogólnie dużą postacią jest zwiewna sukienka, a „oczy” i „nos” to fałdy w sukience.

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

Inne „oko” są nieco ryzykowne ...

Python, 276 289 bajtów

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

Ten kod ma 8 dodatkowych bajtów ( \* 4) dla czytelności.

Buduje bałwana krok po kroku.

Premia

F("44444432") daje „śpiącego rosyjskiego niedźwiedzia”:

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

Python 2, 354 280 241 261 bajtów

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

Dzwonienie s('33232124')daje:

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

Ale moimi ulubionymi są 44242123i 41341144:

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

CJam, 150 145 bajtów

Baza przekonwertować wszystkie rzeczy!

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

SE interpretuje niedrukowalne, więc tutaj jest kopia na Pastebin. Upewnij się, że skopiowałeś część „RAW Paste Data”, a nie część obok numerów linii. Możesz wypróbować online , ale bezpośredni link może nie działać w niektórych przeglądarkach.

Wyjaśnienie

"b8li'U9gN;|"125:Kb8bpCzęść generuje tablicę

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

który odwzorowuje każdą cyfrę wejścia na miejsce, w którym używana jest cyfra. Wszystkim, co jest wspólne dla wszystkich danych wejściowych (np. Spacje wiodące i ()), arbitralnie przypisywane jest 0, z wyjątkiem pierwszego, któremu przypisano 1, aby konwersja bazowa mogła działać.

l:~f=następnie konwertuje każdą cyfrę na liczbę całkowitą i odpowiednio mapuje, np. dla 14441133otrzymania

[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= daje ciąg

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

po którym możemy powielać, wymienić /<[(się \>])i dołącz do dać długi łańcuch. Następnie dzielimy ciąg na grupy po 4 i mapujemy według innej tablicy "r pL|P3{cR`@L1iT"Kb21b, uzyskując w ten sposób tablicę ciągów o długości 4 opisujących wszystkie możliwe opcje w każdej komórce (np. Czy _=./są wszystkie możliwe opcje dla drugiego znaku w drugim wierszu, zaczynając od Rosyjski kapelusz).

Na koniec mapujemy odpowiednio opcje na dane wejściowe .=, dzielimy na rzędy o długości 7 7/i riffle w niektórych nowych wierszach N*.

Testy przebiegają

11111111

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

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

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

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

TI-BASIC, 397 bajtów

Ważne: jeśli chcesz to przetestować, pobierz go stąd i wyślij ten plik do kalkulatora. Czy nie próbować skopiować poniższy kod do edytora programu TI-CONNECT CE lub SourceCoder 3 lub czegoś do tworzenia i wysyłania go do kalkulatora; w przypadku TI-Connect powie, że ma nieprawidłowy token. SC3 używa ukośnika odwrotnego jako ogranicznika komentarza ( //rozpoczyna komentarz w SC3; /\/jednak eksportuje jako //), więc nie eksportuje broni i czapki i tak poprawnie, powodując, że program wyświetla zarówno nieprawidłowe części ciała, jak i rzuca BŁĄD: DOMENA co jakiś czas. Zabawne rzeczy!

Ważne # 2: Jestem zbyt leniwy, aby w tej chwili naprawić pobieranie, więc kiedy przesyłasz go do swojego programu, zmień 7trzeci wiersz z dołu na X+6. Poniższy kod został naprawiony, jeśli chcesz porównać.

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

Premia: Szczególnie lubię 12341214.

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

Niektóre uwagi:

• Zdecydowanie można w nią grać w golfa, bez wątpienia. Jestem prawie pewien, że mogę połączyć większość, jeśli nie wszystkie, danych wyjściowych w jedną pętlę For (pętla. Jestem też całkiem pewien, że mogę scalić niektóre ciągi razem.
• W Str4 (oczy) używam „kropki fabularnej” ( [2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct)) zamiast kropki , aby oczy nie pokrywały się z przecinkiem, ponieważ wygląda to dziwnie jak diabli.
• W Str8 (podstawa) musiałem użyć diaeresis (¨) zamiast podwójnych cudzysłowów, ponieważ nie ma możliwości ucieczki znaków w TI-BASIC, a podwójne cudzysłowy są używane do rozpoczynania / kończenia ciągów.
• W TI-BASIC nie ma potrzeby zamykania nawiasów i nawiasów, jeśli następuje po nich dwukropek, znak nowej linii lub → (używane do przypisania var), a podwójne cudzysłowy (ciągi) mogą pozostać niezamknięte, po którym następuje znak nowej linii lub →.

C, 280 272 264 bajtów

W tym momencie tylko częściowo grał w golfa, ale jest to zabawne wyzwanie.

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

(Z dodatkowymi \ n dla czytelności.) Spodziewam się, że definepowinienem odejść z dalszym golfem.

Bardziej czytelna wersja to

#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 bajtów

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

Czytelna wersja:

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

Wziąłem ten pomysł z odpowiedzi Reto Koradi . Wprowadziłem kilka fajnych ulepszeń, które mogą uzasadnić opublikowanie osobnej odpowiedzi:

• Przekształcony z funkcji na program (+10)
• Przeniesiono nowe wiersze do ciągu kontrolnego (-7)
• Dodano 3 do wszystkich kodów znaków, aby mieć mniej znaków ucieczki, takich jak \"(-3)
• Odczytywanie z łańcucha z autoinkrementacją; również zastąpiony t[i++]przez *t++(-4)
• Zastąpiony whileprzez for; usunięty {}(-4)
• Uproszczone zakończenie pętli: czytanie do \0(-9)
• Przekształcono, t[...],t+=4aby(...)[t+=4] wyeliminować operator przecinka (-1)

Skąd te wszystkie kłopoty? Aby podzielić się moim ulubionym, śnieżnym duchem:

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

JavaScript, 489 (bez nowego wiersza i kart)

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

Biegnij z node snowman.js 33232124

Pyth, 203 bajty

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. Wypróbuj online: Pyth Compiler / Executor

Wyjaśnienie

Najpierw definiuję funkcję pomocnika g, która pobiera listę i znak jako dane wejściowe, konwertuje znak na jego wartość ASCII i przyjmuje odpowiedni element (modułowe zawijanie).

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

Inne rzeczy to po prostu drukowanie linia po linii. Na przykład pierwszy wiersz to:

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

Btw. Eksperymentowałem trochę z tym .F"{:^7}", co wyśrodkowuje strunę. Korzystając z niego, mogę zapisać kilka spacji w kodzie, ale nie zapisuje on żadnych bajtów na końcu.

R, 436 437 bajtów

Oto moja pierwsza próba gry w golfa z użyciem kodu , która nie jest najkrótsza, ale nadal sprawia przyjemność. Przynajmniej pokonuję JavaScript (na razie) ...

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

Testowanie:

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

I rzeczywiście z trudem Xi Yjest multilined ale z materiałem pomiędzy, skończyło się oddzielając linię ( X, S) i ( Y, U).

function i konwersja z ciągu na liczbę całkowitą jest również bardzo szczegółowa.

Edytuj 436 => 437

Musiałem naprawić brakujące puste miejsce zauważone przez @OganM

Mógłbym zredukować do 428, zastępując podziały linii między zmiennymi ;, ale kod „jednowierszowy” wygląda tak źle i nieczytelny, że nie będę aż tak chciwy.

Haskell, 361 306 289 bajtów

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

Stosowanie:

putStrLn $ p "12333321"

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

Jak to działa: indeksuj każdy element listy [hat options, left upper arm options, left eye options, ..., base options]odpowiednim numerem wejściowym i konkatenuj go w jedną listę. Podzieliłem lewą i prawą rękę na górną i dolną część, aby móc budować bałwana linia po linii.

Moim ulubionym jest klasyk 11112211.

Edycja: przełączono z listy ciągów na ciągi dla części (kapelusz, oko, ...). Potrzebuje drugiego parametru - długości podciągu do wzięcia.

Edycja II: wyodrębniono typowe podciągi

C, 233 230 bajtów

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

Z nowymi liniami i białymi znakami dla lepszej czytelności:

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

Całość to dość brutalna siła. Używa tabeli, która zawiera jeden wpis dla każdego z 35 (5 wierszy o długości 7) znaków. Każdy wpis w tabeli to:

• Stała postać: , (, ). Długość wpisu w tabeli wynosi 1 znak.
• Indeks części ciała, po której następują 4 możliwe znaki w zależności od wyboru części na wejściu. Długość wpisu w tabeli wynosi 5 znaków.

Następnie kod zapętla 35 znaków i sprawdza wartość w tabeli.

R 414 bajtów

Nieznacznie zmodyfikowana wersja wersji 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="")}

Po prostu połączyłem osobne zmienne w jedną. Shawing trochę miejsca, które zostało wykorzystane do X=c(rutyny.

CJam, 200 191 bajtów

Z pewnością można w to dużo grać w golfa. (Szczególnie, jeśli go koduję). Ale tutaj jest na początek:

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

Wejście przechodzi w STDIN. Na przykład dane wejściowe 23232223dają:

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

Wypróbuj online tutaj

Haskell, 333 bajty

Moje pierwsze zgłoszenie! Buduje bałwana od góry do dołu, od lewej do prawej. Podzielę ramiona na dwie funkcje dla każdego ramienia, część przy głowie i część przy ciele.

Funkcja s pobiera listę liczb całkowitych i konkatenuje dane wyjściowe funkcji, które tworzą części ciała, biorąc pod uwagę poprawne podlisty danych wejściowych.

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

To zależy od funkcji

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

który zwraca n-ty element podanej listy. Pozwala to na listę czapek w, a także rzeczy takich jak

k=y" /  "

wszystkie te funkcje wykorzystują redukcję beta, więc ich argument jest przekazywany jako indeks funkcji y.

Wynik:

λ> s $ repeat 1

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

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

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

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

Python 3, 349 336 254 251 bajtów

Tyle za zrobienie mojej pracy magisterskiej.

Oto zawartość pliku 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)]))

I w ten sposób wyczuwam mojego ulubionego bałwana:

s('11112311')

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

Wyjaśnienie

# 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 bajtów

Inspirowany Reto Koradi i anatolygiem .

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

Wypróbuj online!

Uwaga: Linia 3 ma 2 miejsca na szlaki, linia 4 ma miejsce na szlaki.

Moim ulubionym jest 44444444„śpiący rosyjski strażnik”:

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

JavaScript (ES6), 247

Nie tak dobra reklama @ NinjaBearMonkey :(

Test we fragmencie (w przeglądarce 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 bajtów

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

-6 bajtów dzięki @Grimy .

Wypróbuj online lub sprawdź kilka innych przypadków testowych .

Wyjaśnienie:

Najpierw tworzymy ciąg szablonu:

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

Który wygląda tak:

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

Następnie zapętlam cyfry wejścia:

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

I wykonaj następujące czynności:
Wciśnij (0-indeksowany) indeks Nlisty:

  N          # Push the index of the loop

Wciśnij wszystkie możliwe części jako listę list postaci:

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

Użyj indeksu pętli, Naby uzyskać listę znaków części, z którą obecnie pracujemy:

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

Następnie podziel listę znaków na cztery równe części i użyj cyfry wejściowej y(która jest indeksowana 1), aby się do niej zindeksować. (UWAGA: Ponieważ 05AB1E ma indeksowanie 0, ale wejście ma indeksowanie 1, logiczne byłoby zmniejszenie cyfry o 1 przed indeksowaniem. Jednak ponieważ 05AB1E ma automatyczne zawijanie (tzn. Spowoduje indeksowanie 3listy ), po prostu raz obróciłem części, więc części z numerem 4 w opisie wyzwania znajdują się na początku listy).[1,3,5]1

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

A następnie zamień indeksowany przez 0 indeks pętli, którą najpierw wypchnęliśmy, po kolei znakami części:

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

Ostatecznie wynik jest dorozumiany.

Zobacz moją wskazówkę 05AB1E (sekcja Jak kompresować duże liczby całkowite? I Jak kompresować listy liczb całkowitych? ), Aby zrozumieć, jak działają części kompresji.

Co do mojego ulubionego, to wciąż ten sam „śnieżny królik” jak 1,5 roku temu, kiedy opublikowałem moje rozwiązanie Java :

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

Java 8, 548 545 432 401 399 bajtów

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

Wypróbuj tutaj.

Wyjaśnienie:

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

Mój ulubiony:

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

Nie wiem dlaczego, ale wygląda to trochę uroczo. Jak królik z rosyjskim kapeluszem zamiast uszu.

F #, 369 bajtów

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]

Wypróbuj online!

Ponieważ gużywa akcesorium tablicowego, muszę jawnie określić typ w definicji funkcji jako string, i dlatego definicja funkcji ma (g:string).

Poza tym zwykle jest to tablica, do której stringsdostęp uzyskuje indeks. Czapka, lewe i prawe ramiona, które biegną osobnymi liniami, są podzielone na oddzielne górne i dolne tablice. iFunkcja zmiany numeru w argument gdo indeksu tablicy. I litera bzastępuje ciągi jednowymiarowe w tablicach.

Świetne wyzwanie! Moim ulubionym bałwanem jest prawdopodobnie 242244113:

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

obserwuję Cię

PHP, 378 bajtów

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

Wypróbuj online!

Lubię mądrego Pana Owl 31333342

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

Python 2.7, 257 bajtów (myślę)

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

gdzie „i” to dane wejściowe jako ciąg znaków (np. „13243213”)

Dart , 307 bajtów

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

Wypróbuj online!

Zsh, 247 bajtów

spróbuj 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}

ulubiony bałwan:

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