간단한 ASCII 아트 눈사람 은 다음과 같습니다 .

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

그를 친구로 만들자. 이것은 ASCII 아트 스노우 맨의 일반적인 패턴입니다.

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

선행 공간과 괄호는 모든 스노우 맨에게 항상 동일합니다. 다른 문자는 개별적으로 변경할 수있는 패턴의 섹션을 나타냅니다. 각 섹션에는 ASCII 문자로 채울 수있는 항목에 대해 정확히 4 개의 사전 설정이 있습니다. 8 개의 섹션 모두에 대해 이러한 사전 설정을 혼합하고 일치시킴으로써 다양한 눈사람을 만들 수 있습니다.

모든 프리셋

^{(공백은 그렇지 않으면 빈 줄에 배치되므로 단면 모양이 항상 정확합니다.)}

H는 모자입니다

1. 밀짚 모자

        
   _===_

2. 멕시코 모자

    ___ 
   .....
   

3. 페즈

     _  
    /_\ 
   

4. 러시아 모자

    ___ 
   (_*_)
   

N은 코 / 입

1. 표준 ,

2. 점 .

3. 선 _

4. 없음

L은 왼쪽 눈입니다

1. 점 .

2. 더 큰 도트 o

3. 가장 큰 도트 O

4. 닫은 -

R은 오른쪽 눈입니다

(왼쪽 눈과 동일한 목록)

X는 왼쪽 팔입니다

1. 보통 팔

    
   <

2. 상향 팔

   \
    

3. 하향 팔

    
   /

4. 없음

Y는 오른팔입니다

1. 보통 팔

    
   >

2. 상향 팔

   /
    

3. 하향 팔

    
   \

4. 없음

T는 몸통

1. 버튼 :

2. 조끼 ] [

3. 안쪽 팔 > <

4. 없음

B는 기본입니다

1. 버튼 :

2. 피트 " "

3. 플랫 ___

4. 없음

도전

형식으로 8 자 문자열 (stdin 또는 명령 행을 통해)을 취하는 프로그램을 작성하십시오 HNLRXYTB. 여기서 각 문자는 눈사람의 해당 섹션에 사용할 사전 설정을 나타내는 1-4의 숫자입니다. 스노우 맨 전체를 표준 출력으로 프린트하십시오.

예를 들어, 입력 11114411은 페이지 상단의 눈사람입니다. (첫째 1: 밀짚 모자, 두 번째 1: 보통 코 등)

또 다른 예는 입력을위한 snowperson입니다 33232124.

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

세부

• 선행 / 트레일 공간 및 선행 / 트레일 링 개행 문자의 수량 및 조합은 다음과 같이 허용됩니다.

  • 눈사람은 모든 섹션이 서로 올바르게 정렬되어 있으며
  • 총 공백 문자는 64자를 넘지 않아야합니다 (일반 패턴은 7 × 5에 불과하므로이 한계에 도달하지는 않습니다).

  공백 만 포함 된 패턴의 행 / 열을 인쇄 할 필요는 없습니다. 예를 들어 밀짚 모자의 빈 줄은 필요하지 않습니다.

• 위에 제시된대로 부품 순서를 사용해야합니다.

• 프로그램 대신 숫자 문자열을 인수로 사용하는 함수를 작성할 수 있습니다. 출력은 정상적으로 인쇄되거나 문자열로 반환되어야합니다.

• 원하는 경우 입력을 문자열 대신 정수로 취급 할 수 있습니다.

채점

바이트 단위의 가장 짧은 코드가 이깁니다.

보너스 질문 : 65536 개의 다른 스노우 맨이 가장 좋아하는 것은?

CJam, 135 134 132 130 126 125 바이트

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*

컴퓨터에서 파일을 만들려면을 실행 xxd -r > snowman.cjam하고 가역 16 진수 덤프를 위에서 붙여넣고 Enter마지막으로 Ctrl+를 누르십시오 D.

또는 CJam 인터프리터를 사용하여 온라인으로 코드를 시험해 볼 수 있습니다 .

보너스

내가 가장 좋아하는 눈사람은 올라프입니다.

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

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

겨울은 껴안고 껴안을 수있는 좋은 시간이지만 여름에 나를 데려 가면… 행복한 눈사람이 될 것입니다!

생각

16 진 문자열

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

눈사람을 포함하여 눈사람의 모든 부분에 대해 가능한 선택을 인코딩합니다. 이 문자열을 P 라고합시다 .

그것을 해독하기 위해 P (여기서는 정수 배열로 취급)를 기본 256에서 기본 20으로 변환하고 결과 정수 각각을 문자열 M 의 해당 문자로 바꿉니다 .

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

결과적으로 문자열 T가됩니다 .

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

첫 번째 줄은 모든 모자 선택, 마지막으로 모든 고정 신체 부위를 인코딩합니다. 다른 라인에는 28 개의 가변 바디 파트가 있습니다.

우리 는 줄 바꿈에서 T 를 나누고 결과 배열의 문자열을 같은 길이의 네 부분으로 나눕니다. 그런 다음 STDIN에서 입력을 읽고 밑 10의 자릿수 배열을 푸시하고 분할 문자열의 해당 요소를 선택합니다. 우리는 CJam에서 배열이 랩핑된다는 사실을 이용하므로 길이가 4 인 배열의 인덱스 4에있는 요소가 실제로 첫 번째 요소입니다. 마지막으로 분할 된 문자열은 입력에 해당하지 않으므로 완전히 선택됩니다.

결과 배열에서 첫 번째 요소를 이동하여 모자를 처리합니다. 첫 번째 문자 M 의 색인 ( 기본 4 숫자로 읽음)은 모자의 첫 번째 행에 공백과 밑줄의 수를 나타냅니다. 이러한 문자, 줄 바꿈, 공백 및 나머지 문자열을 인쇄합니다. 그런 다음 스택 맨 아래에 추가 줄 바꿈을 밀어 넣습니다.

신체 부위의 경우 모든 부위에 해당하는 문자열을 연결합니다. 이 문자열을 S 라고합시다 . 본문 부분을 조립하기 위해 음역을 수행합니다. 문자열 M 의 각 문자를 가져 와서 sort (M) 의 색인을 계산하여 S 의 해당 문자로 바꿉니다 . 음역 연산자 는 S 의 마지막 문자 를 필요한만큼 여러 번 반복하여 sort (M) 의 길이에 맞게 S 를 자동으로 채운다는 사실을 이용 합니다.

마지막으로 결과 문자열을 길이가 7 인 하위 문자열로 나누고 각 하위 문자열 쌍 사이에 줄 바꿈을 배치합니다.

암호

변수한다고 가정 M하고 P문자열이 포함 M 과 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.

자바 스크립트 ES6, 210 (208) 202 바이트

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

이것은 익명의 기능입니다. 를 실행하여 사용합니다 ([function code])('42232124'). 이것의 가장 악화되는 부분은 2 줄을 차지하는 팔이었습니다. 그래서 상단과 하단에 대한 코드를 포함시켜야했습니다.

아래의 스택 스 니펫에는 ungolfed, ES6 인증되지 않은 주석 코드가 있습니다. 또한 코드를 쉽게 테스트하고 다양한 조합을 시도 할 수 있습니다. 편집 : 나는 이것으로 너무 재미있다. 임의의 눈사람을 생성하는 방법을 포함하여 몇 가지 새로운 기능을 추가했습니다.

6 바이트를 절약 한 Yair Rand에게 감사합니다.

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 바이트

눈사람을 왼쪽에서 오른쪽으로, 위에서 아래로 생성합니다. 이것은 눈사람의 모든 부분을 스택에 남겨두기 때문에 모든 종류의 문자열 결합 또는 재배치 작업이 필요하지 않습니다. 그런 다음 프로그램 끝의 자동 스택 덤프로 인해

♫ CJam은 눈사람을 만들고 싶어합니다! ♫

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

온라인으로 사용해보십시오.

보너스

틀을 깨고 생각하라! 32443333눈이 남자 신부를 제공합니다. 조금 보려고 노력해야하지만 안쪽 팔, fez + 아래쪽 팔 = 베일이 있으며 머리는 실제로 fez / veil에 있습니다. 일반적으로 큰 형태는 격렬한 드레스이며, "눈"과 "코"는 드레스의 주름입니다.

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

다른 "눈"선택은 약간 위험합니다 ...

Python, 276 289 바이트

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

이 코드에는 \가독성을 위해 8 개의 추가 바이트 ( * 4)가 있습니다.

눈사람을 조금씩 쌓아 올립니다.

보너스

F("44444432") "졸린 러시아 곰"을 제공합니다 :

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

파이썬 2 354 280 241 261 바이트

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

전화 s('33232124')는 다음을 제공합니다.

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

하지만 내 즐겨 찾기는 44242123과 41341144:

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

CJam, 150 145 바이트

모든 것을 기본으로 변환 하십시오 !

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

SE는 인쇄 할 수없는 파일을 맹 글링하므로 여기 Pastebin에 사본이 있습니다. 줄 번호 옆에있는 부분이 아니라 "RAW Paste Data"부분을 복사해야합니다. 온라인으로 시도 할 수 있지만 일부 브라우저에서는 영구 링크가 작동하지 않을 수 있습니다.

설명

"b8li'U9gN;|"125:Kb8bp부분 배열을 생성

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

입력의 각 숫자를 숫자가 사용되는 위치에 매핑합니다. 모든 입력 (예 : 선행 공백 및 ())에 공통 인 항목 에는 기본 변환이 작동 할 수 있도록 1이 할당 된 것을 제외하고 0이 임의로 할당됩니다.

l:~f=다음 int로 각 숫자를 변환하고 예를 들어, 그에 따라 매핑 14441133우리가 얻을

[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= 줄을 준다

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

그 후에 우리는 복제 교체 /<[(로 \>])긴 문자열을 제공하기 위해 추가합니다. 그럼 다른 배열에있어서, (4) 및 맵 그룹으로 문자열을 분할 "r pL|P3{cR`@L1iT"Kb21b따라서 (예를 들어, 각 셀에서 모든 가능한 옵션을 설명하는 길이 4 문자열의 배열을 얻는 _=./로부터 시작하여, 두번째 행의 두번째 문자를위한 모든 가능한 옵션이고 러시아 모자).

마지막으로 옵션을 입력에 매핑하고 .=길이 7의 행으로 나누고 줄 7/바꿈을 N*합니다.

시운전

11111111

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

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

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

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

TI-BASIC, 397 바이트

중요 사항 : 이것을 테스트하려면 여기 에서 다운로드하여 해당 파일을 계산기로 보내십시오. 마십시오 하지 TI-연결 CE의 프로그램 편집기 나 SourceCoder 3 구축하고 계산기로 보내 뭔가에 아래의 코드를 복사하려고; TI-Connect의 경우 유효하지 않은 토큰이 있다고 말합니다. SC3은 백 슬래시를 주석 구분자로 사용 하지만 //(SC3에서 주석을 시작합니다. /\/그러나로 //내보내기), 팔과 모자 등을 올바르게 내 보내지 않으므로 프로그램이 잘못된 신체 부위를 표시하고 오류 : 도메인마다 재미있는 것들!

중요 # 2 : 현재 다운로드를 수정하기에는 너무 게으르다. 따라서 계산을 전송으로 전송할 때 7세 번째 줄의 아래에서로 변경하십시오 X+6. 아래 코드는 비교해야 할 경우 고정되어 있습니다.

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

보너스 : 특히 좋아 12341214합니다.

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

몇 가지 참고 사항 :

• 의심 할 여지없이 골프를 더 많이 즐길 수 있습니다. 나는 대부분의 출력을 단일 For (루프)로 결합 할 수 있다는 점에 거의 긍정적이다. 또한 일부 문자열을 함께 병합 할 수 있다고 확신한다.
• Str4 (눈) [2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct)에서는 눈에 쉼표가 표시되지 않도록 마침표와 달리 "플롯 도트"( )를 사용합니다.
• Str8 (기본)에서는 TI-BASIC에서 문자를 이스케이프 처리 할 방법이없고 문자열을 시작 / 종료하는 데 큰 따옴표가 사용되므로 큰 따옴표 대신 분음 기호 (¨)를 사용해야했습니다.
• TI-BASIC에서는 괄호와 괄호 뒤에 콜론, 줄 바꿈 또는 → (var 할당에 사용됨)이 있으면 닫을 필요가 없으며, 큰 따옴표 (문자열)는 줄 바꿈이나 →가 올 때 닫히지 않을 수 있습니다.

C, 28072 264 바이트

이 시점에서 부분적으로 만 골프를 쳤지 만 이것은 재미있는 도전입니다.

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

(가독성을 위해 약간의 추가 \ n이 있습니다.) 나는 define더 많은 골프를 치러 가야한다고 기대합니다 .

더 읽기 쉬운 버전은

#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 바이트

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

읽을 수있는 버전 :

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

Reto Koradi의 답변 에서 아이디어를 얻었습니다 . 몇 가지 재미있는 개선이 있었으므로 별도의 답변을 게시해야합니다.

• 기능에서 프로그램으로 변환 (+10)
• 줄 바꾸기를 제어 문자열로 이동했습니다 (-7).
• \"(-3) 과 같이 이스케이프 문자가 더 적도록 모든 문자 코드에 3을 추가했습니다.
• 자동 증가로 문자열에서 읽기; 또한 교체 t[i++]로 *t++(-4)
• 대체 while에 의해 for; 제거됨 {}(-4)
• 단순화 된 루프 종료 : \0(-9) 까지 읽기
• t[...],t+=4(...)[t+=4]쉼표 연산자를 제거하도록 변환 됨 (-1)

왜 그 모든 문제? 내가 좋아하는 것을 공유하기 위해 눈 유령 :

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

자바 스크립트, 489 (개행 및 탭 제외)

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

와 실행 node snowman.js 33232124

Pyth, 203 바이트

M@GCHgc"  ___

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

롤 온라인 사용해보기 : Pyth Compiler / Executor

설명

먼저 g목록과 문자를 입력으로 사용하고 문자를 ASCII 값으로 변환하고 해당 요소 (모듈 식 줄 바꿈)를 취하는 도우미 함수를 정의합니다 .

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

다른 것은 단지 한 줄씩 인쇄하는 것입니다. 예를 들어 첫 번째 줄은 다음과 같습니다.

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

Btw. 나는 .F"{:^7}"문자열을 중심 으로 약간을 실험했습니다 . 그것을 사용하면 코드에 약간의 공백을 저장할 수는 있지만 끝에 바이트를 저장하지는 않습니다.

R, 436 437 바이트

가장 짧지는 않지만 여전히 재미있는 R을 사용하여 code-golf 에 대한 첫 번째 시도는 다음과 같습니다 . 적어도 나는 JavaScript를 치고 있습니다 (현재).

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

테스트 :

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

사실 고생 X하고 Y(multilined되고 있지만, 그 사이의 물건, 각 라인을 분리 끝났다X , S()과 Y, U).

function 문자열에서 정수로의 변환도 매우 장황합니다.

편집 436 => 437

@OganM이 발견 한 빈 공간을 수정해야했습니다.

변수 사이의 줄 바꿈을으로 바꾸면 428로 줄일 수 ;있지만 "한 줄짜리"코드는 너무 나쁘고 읽을 수 없으므로 욕심 많지 않습니다.

하스켈, 361 (306) 289 바이트

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

용법:

putStrLn $ p "12333321"

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

작동 방식 : 목록의 모든 요소를 ​​색인화 [hat options, left upper arm options, left eye options, ..., base options] 해당 입력 번호로 하고 단일 목록으로 연결하십시오. 나는 눈사람을 한 줄씩 만들 수 있도록 왼쪽과 오른쪽 팔을 위쪽과 아래쪽으로 나눕니다.

내가 가장 좋아하는 것은 클래식 11112211 입니다.

편집 : 문자열 목록에서 부품의 문자열로 전환했습니다 (모자, 눈, ...). 가져올 부분 문자열의 길이 인 두 번째 매개 변수가 필요합니다.

편집 II : 추출 된 공통 부분 문자열

C, 233230 바이트

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

가독성을 높이기 위해 줄 바꿈과 공백이 있습니다.

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

모든 것은 상당히 무차별적인 힘입니다. 35 자 (길이 7 인 5 행) 각각에 대해 하나의 항목이 포함 된 테이블을 사용합니다. 테이블의 각 항목은 다음 중 하나입니다.

• 상수 문자 : , (, ). 테이블 항목 길이는 1 자입니다.
• 본문 부분의 색인, 입력에서 부분 선택에 따라 4 개의 가능한 문자가 뒤 따릅니다. 테이블 항목 길이는 5 자입니다.

그런 다음 코드는 35자를 반복하여 테이블에서 값을 찾습니다.

R 414 바이트

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

별도의 변수를 하나로 병합하십시오. 일상적으로 사용 된 공간의 일부를 깎습니다 X=c(.

CJam, 200 191 바이트

이것은 확실히 많은 골프를 할 수 있습니다. (특히 내가 기본 인코딩하면). 그러나 여기에 초보자가 있습니다.

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

입력이 STDIN으로 들어갑니다. 예를 들어, 입력 23232223은 다음을 제공합니다.

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

여기에서 온라인으로 사용해보십시오

하스켈, 333 바이트

내 첫 제출! 눈사람을 위에서 아래로, 왼쪽에서 오른쪽으로 만듭니다. 팔을 팔 옆에 두 부분, 머리 옆 부분과 몸 옆 부분으로 나눕니다.

함수 s는 정수 목록을 가져오고 입력의 올바른 하위 목록이 제공된 신체 부분을 생성하는 함수의 출력을 연결합니다.

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

그것은 기능에 의존

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

주어진리스트의 n 번째 요소를 반환합니다. 이를 통해 모자 목록은 물론

k=y" /  "

이러한 모든 함수는 베타 축소를 사용하므로 인수가 y 함수에 대한 인덱스로 전달됩니다.

산출:

λ> s $ repeat 1

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

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

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

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

파이썬 3, 349 336 254 251 바이트

내 논문을 작성하는 데 너무 많은.

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

그리고 이것이 내가 좋아하는 눈사람을 불러내는 방법입니다.

s('11112311')

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

설명

# 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 바이트

Reto Koradi 및 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

온라인으로 사용해보십시오!

참고 : 3 행에는 2 개의 트레일 공간이 있고 4 행에는 트레일 공간이 있습니다.

내가 가장 좋아하는 것은 44444444"졸린 러시아 경비원"입니다.

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

자바 스크립트 (ES6), 247

@NinjaBearMonkey의 좋은 광고가 아닙니다 :(

스 니펫 테스트 (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 바이트

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

@Grimy 덕분에 -6 바이트 .

온라인으로 시도 하거나 몇 가지 테스트 사례를 확인하십시오 .

설명:

먼저 템플릿 문자열을 만듭니다.

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

이것은 다음과 같습니다

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

그런 다음 입력 숫자를 반복합니다.

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

그리고 다음을 수행하십시오. 목록
의 (0- 인덱스 화 된) 색인 N을 누르십시오 .

  N          # Push the index of the loop

가능한 모든 부품을 문자 목록으로 푸시하십시오.

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

루프 인덱스 N를 사용하여 현재 작업중인 부품의 문자 목록을 가져옵니다.

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

그런 다음 문자 목록을 4 개의 동일한 부분으로 나누고 입력 숫자 y(1 색인)를 사용하여 색인화하십시오. (참고 : 05AB1E는 0- 인덱싱되지만 입력은 1- 인덱싱되기 때문에 인덱싱하기 전에 숫자를 1 씩 줄이는 것이 논리적이지만, 05AB1E에는 자동 랩 어라운드 가 있으므로 ( 3목록의 인덱싱 [1,3,5]결과는 1) 챌린지 설명에서 nr 4 인 부품이 목록의 맨 앞에 오도록 부품을 한 번 회전했습니다.)

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

그런 다음 처음에 푸시 한 루프의 인덱스가 0 인 인덱스를 부분 문자로 하나씩 바꿉니다.

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

결국 결과는 암시 적으로 출력됩니다.

내이 05AB1E 팁을 참조하십시오 (섹션 얼마나 큰 정수를 압축하는 방법? 및 정수 목록을 압축하는 방법을? ) 압축 부분이 어떻게 작동하는지 이해하기.

내가 가장 좋아하는 것은 1.5 년 전 Java 솔루션을 게시했을 때와 동일한 '눈 토끼'입니다 .

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

자바 (8) 548 545 432 401 399 바이트

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

여기에서 시도하십시오.

설명:

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

내가 좋아하는 것:

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

왜 그런지 모르겠지만 좀 귀엽습니다. 귀 대신 러시아 모자를 쓴 토끼처럼.

F #, 369 바이트

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]

온라인으로 사용해보십시오!

g배열 접근자를 사용 하기 때문에 함수 정의에서 유형을 명시 적으로 지정해야하므로 string이것이 함수 정의에 있습니다 (g:string).

그 외에도 일반적으로 strings인덱스에 의해 액세스되는 배열입니다 . 별도의 라인에있는 모자, 왼쪽 및 오른쪽 팔은 별도의 상단 및 하단 배열로 분리됩니다. 이 i함수는 인수의 숫자를 g배열 색인으로 변경합니다 . 그리고 문자 b는 배열의 한 공백 문자열을 대체합니다.

큰 도전! 내가 가장 좋아하는 눈사람은 아마 242244113다음과 같습니다 .

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

당신을보고 있어요

PHP, 378 바이트

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

온라인으로 사용해보십시오!

나는 현명한 올빼미를 좋아한다 31333342

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

파이썬 2.7, 257 바이트 (제 생각에)

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

여기서 'i'는 문자열로 입력됩니다 (예 : "13243213")

다트 , 307 바이트

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

온라인으로 사용해보십시오!

Zsh, 247 바이트

온라인으로 사용해보십시오!

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

fav 눈사람 :

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