මෙන්න සරල ASCII කලා හිම මිනිසෙක්:

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

අපි ඔහුට මිතුරන් කිහිප දෙනෙකු කරමු. අපගේ ASCII කලා හිම වැසියන්ගේ පොදු රටාව මෙය වනු ඇත:

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

සියලුම හිම වැසියන්ට ප්‍රමුඛ අවකාශයන් සහ වරහන් වර්‍ග සෑම විටම එක හා සමාන වේ. විවිධ අකුරු තනි තනිව වෙනස් කළ හැකි රටාවේ කොටස් නියෝජනය කරයි. සෑම කොටසකටම ASCII අක්ෂර පුරවා ගත හැකි දේ සඳහා පෙර සැකසුම් හතරක් ඇත. කොටස් අට සඳහාම මෙම පෙරසිටහන් මිශ්‍ර කර ගැලපීමෙන් අපට විවිධ හිම හිමියන් සෑදිය හැකිය.

සියලුම පෙරසිටර

^{(අවකාශය වෙනත් ආකාරයකින් හිස් රේඛා මත තබා ඇති බව සලකන්න, එවිට කොටසේ හැඩය සැමවිටම නිවැරදි වේ.)}

එච් යනු තොප්පි සඳහා ය

1. පිදුරු තොප්පිය

        
   _===_

2. මෙක්සිකානු තොප්පි

    ___ 
   .....
   

3. Fez

     _  
    /_\ 
   

4. රුසියානු තොප්පි

    ___ 
   (_*_)
   

N යනු නාසය / මුඛය සඳහා ය

1. සාමාන්‍යයි ,

2. තිත .

3. රේඛාව _

4. කිසිවක් නැත

L යනු වම් ඇස සඳහා ය

1. තිත .

2. විශාල තිත o

3. විශාලතම තිත O

4. වසා ඇත -

R යනු දකුණු ඇස සඳහා ය

(වම් ඇසට සමාන ලැයිස්තුවක්.)

X යනු වම් අත සඳහා ය

1. සාමාන්‍ය හස්තය

    
   <

2. ඉහළට ආම්

   \
    

3. පහළට ආම්

    
   /

4. කිසිවක් නැත

Y යනු දකුණු අත සඳහා ය

1. සාමාන්‍ය හස්තය

    
   >

2. ඉහළට ආම්

   /
    

3. පහළට ආම්

    
   \

4. කිසිවක් නැත

ටී ටෝසෝ සඳහා ය

1. බොත්තම් :

2. වෙස්ට් ] [

3. අභ්‍යන්තර ආයුධ > <

4. කිසිවක් නැත

B යනු Base සඳහා ය

1. බොත්තම් :

2. අඩි " "

3. පැතලි ___

4. කිසිවක් නැත

අභියෝගය

අක්ෂර අටකින් (stdin හෝ විධාන රේඛාව හරහා) ගන්නා වැඩසටහනක් ආකෘතියේ ලියන්න HNLRXYTB, එහිදී සෑම අකුරක්ම 1 සිට 4 දක්වා ඉලක්කම් වන අතර එයින් දැක්වෙන්නේ හිම හිමියාගේ අනුරූප කොටස සඳහා කුමන පෙරදසුන භාවිතා කළ යුතුද යන්නයි. සම්පූර්ණ හිමපතනය stdout වෙත මුද්‍රණය කරන්න.

උදාහරණයක් ලෙස, ආදානය 11114411යනු පිටුවේ ඉහළින් ඇති හිම මිනිසා ය. (පළමුව 1: ඔහුට පිදුරු තොප්පියක් ඇත, දෙවනුව 1: ඔහුට සාමාන්‍ය නාසයක් ඇත.)

තවත් උදාහරණයක්, ආදානය සඳහා හිම පියලි 33232124:

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

විස්තර

• ප්‍රමුඛ / පසුපස අවකාශයන් සහ ප්‍රමුඛ / පසුපස නව රේඛා වල ඕනෑම ප්‍රමාණයක් සහ සංයෝජනයන් පවතින තාක් කල් ...

  • හිම හිමියා ඔවුන්ගේ සියලු කොටස් එකිනෙකට සාපේක්ෂව නිවැරදිව සකසා ඇත, සහ
  • සම්පූර්ණ හිස් අවකාශ 64 කට වඩා වැඩි ගණනක් නොමැත (සාමාන්‍ය රටාව 7 × 5 ක් පමණි, එබැවින් ඔබ මෙම සීමාවට නොපැමිණෙනු ඇත).

  සුදු පැහැති අවකාශයක් පමණක් තිබේ නම් රටාවේ පේළි / තීරු මුද්‍රණය කිරීමට ඔබට අවශ්‍ය නැත. උදා: පිදුරු තොප්පියේ හිස් රේඛාව අවශ්‍ය නොවේ.

• ඉහත කොටස්වල අනුපිළිවෙල භාවිතා කළ යුතුය.

• වැඩසටහනක් වෙනුවට, ඉලක්කම් නූල තර්කයක් ලෙස ගන්නා ශ්‍රිතයක් ඔබට ලිවිය හැකිය. ප්‍රතිදානය සාමාන්‍යයෙන් මුද්‍රණය කළ යුතුය.

• ඔබට අවශ්‍ය නම් ආදානය නූලක් වෙනුවට පූර්ණ සංඛ්‍යාවක් ලෙස සැලකිය හැකිය.

ලකුණු කිරීම

බයිට් වල කෙටිම කේතය ජය ගනී.

පාරිතෝෂික ප්‍රශ්නය: ඔබ කැමතිම හිම හිමියන් 65536 දෙනාගෙන් කවරෙක්ද?

සී ජෑම්, 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, ආපසු හැරවිය හැකි හෙක්ස්ඩම්ප් ඉහළින් අලවන්න, ඔබන්න Enterසහ අවසානයේ Ctrl+ D.

විකල්පයක් ලෙස, ඔබට CJam පරිවර්තකය භාවිතයෙන් කේතය මාර්ගගතව උත්සාහ කළ හැකිය .

පාරිතෝෂිකය

මගේ ප්‍රියතම හිම මිනිසා ඕලාෆ්:

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

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

ශීත a තුව රැඳී සිටීමට හා හුරතල් කිරීමට හොඳ කාලයකි, නමුත් ගිම්හානයේදී මාව තබන්න, මම ප්‍රීතිමත් හිම මිනිසෙක් වන්නෙමි!

අදහස

හෙක්ස් නූල

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

ස්ථාවර ඒවා ඇතුළුව හිම මිනිසාගේ සියලුම කොටස් සඳහා කළ හැකි තේරීම් සංකේතවත් කරයි. අපි මෙම නූල P ලෙස හඳුන්වමු .

එය විකේතනය කිරීම සඳහා, අපි P (මෙහි පූර්ණ සංඛ්‍යා සමූහයක් ලෙස සලකනු ලැබේ) 256 පාදමේ සිට 20 වන පාදම බවට පරිවර්තනය කර එහි ප්‍රති ing ලයක් ලෙස ඇති වන පූර්ණ සංඛ්‍යා M නූලට අනුරූප අක්‍ෂරයෙන් ආදේශ කරමු .

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

මෙහි ප්‍රති results ලය T :

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

පළමු පේළියේ සියලුම තොප්පි තේරීම් සංකේතවත් කරයි, අවසාන සියලුම ස්ථාවර ශරීර කොටස්. අනෙක් රේඛාවල විචල්ය ශරීර කොටස් 28 ක් අඩංගු වේ.

අපි රේඛීය පෝෂණයෙන් ටී බෙදූ අතර එහි ප්‍රති ar ලයක් ලෙස ඇති අරාවෙහි නූල් සමාන දිගකින් කොටස් හතරකට බෙදමු. ඉන්පසුව, අපි STDIN වෙතින් ආදානය කියවා, එහි ඉලක්කම්වල අරාව 10 වන පාදයට තල්ලු කර බෙදීම් නූල්වල අනුරූප අංග තෝරා ගනිමු. අරා සීජේම් වටා එතීමෙන් අපි වාසි ලබා ගනිමු, එබැවින් 4 වන අරාවෙහි 4 වන දර්ශකයේ මූලද්‍රව්‍යය ඇත්ත වශයෙන්ම පළමු මූලද්‍රව්‍යය වේ. අවසාන බෙදුණු නූල කිසිදු ආදානයකට අනුරූප නොවේ, එබැවින් එය සම්පූර්ණයෙන්ම තෝරා ගනු ලැබේ.

පළමු මූලද්‍රව්‍යය ප්‍රති ar ලයක් ලෙස අරාව වෙතින් මාරු කිරීමෙන් අපි තොප්පිය හසුරුවන්නෙමු. පළමු අක්ෂරයේ M හි දර්ශකය , පාදක 4 අංකයක් ලෙස කියවා ඇති අතර, තොප්පියේ පළමු පේළියේ ඇති අවකාශ ගණන සහ අවධාරනය කරයි. අපි එම අක්ෂර, රේඛීය පෝෂකයක්, අවකාශයක් සහ මාරු කළ නූලෙහි ඉතිරි කොටස මුද්‍රණය කරමු. ඉන්පසුව, අපි අතිරේක ලයින්ෆීඩ් එකක් තොගයේ පතුලේ තල්ලු කරමු.

ශරීර කොටස් සඳහා, අපි ඒ සියල්ලටම අනුරූප වන නූල සමපාත කරමු. අපි මෙම නූල එස් ලෙස හඳුන්වමු . ශරීර කොටස් එකලස් කිරීම සඳහා, අපි අක්ෂර පරිවර්තනය සිදු කරමු: අපි M නූලෙහි එක් එක් අක්‍ෂරය ගෙන , එහි දර්ශකය වර්ගීකරණය (M) ලෙස ගණනය කර එය S හි අනුරූප අක්ෂරයෙන් ආදේශ කරමු . අපි අක්ෂර පරිවර්තනය ක්රියාකරු ස්වයංක්රීයව පෑඩ් බව වාසිය ලබා ගැනීමට එස් දිග ගැලපෙන ආකාරයේ (M) අවසන් අක්ෂරය නැවත නැවත විසින් S අවශ්ය ලෙස බොහෝ වතාවක් ලෙස.

අවසාන වශයෙන්, අපි එහි ප්‍රති string ලයක් ලෙස ඇති නූල් දිග 7 ක උපස්ථර වලට බෙදන්නෙමු.

කේතය

විචල්යයන් 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.

JavaScript 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 ක් ගනී, එබැවින් ඉහළ සහ පහළ යන දෙකටම කේත ඇතුළත් කිරීමට මට සිදු විය.

පහත දැක්වෙන ස්ටැක් ස්නිපෙට් හි නොගැලපෙන, ඊඑස් 6-අයිෆයිඩ්, අදහස් දැක්වීමේ කේතය ඇත. කේතය පහසුවෙන් පරීක්ෂා කිරීමට සහ විවිධ සංයෝජන අත්හදා බැලීමට ඔබට එය භාවිතා කළ හැකිය. සංස්කරණය කරන්න: මම මේ සමඟ ඕනෑවට වඩා විනෝද වෙමි. අහඹු හිම මිනිසෙකු ජනනය කිරීමේ ක්‍රමයක් ඇතුළුව මම නව විශේෂාංග කිහිපයක් එකතු කර ඇත්තෙමි.

බයිට් හයක් ඉතිරි කිරීම ගැන යයර් රැන්ඩ්ට ස්තූතියි.

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">

සී ජෑම්, බයිට් 164

හිම මිනිසා වමේ සිට දකුණට, ඉහළ සිට පහළට ජනනය කරයි. මෙය හිම හිමියාගේ සෑම කැබැල්ලක්ම තොගයේ තබන බැවින් ඕනෑම ආකාරයක නූල් සම්බන්ධ කිරීම හෝ නැවත ස්ථානගත කිරීමේ මෙහෙයුම් වල අවශ්‍යතාවය ඉවත් කරයි. වැඩසටහන් අවසානයේ ස්වයංක්‍රීය සිරස් ඩම්ප් හේතුවෙන්:

♫ CJam වූ snowman ඉදි කිරීමට අවශ්ය! ♫

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

එය මාර්ගගතව උත්සාහ කරන්න.

පාරිතෝෂිකය

පෙට්ටියෙන් පිටත සිතීම! 32443333හිම (wo) මනාලියක් ලබා දෙයි. ඔබට එය බැලීමට මඳක් උත්සාහ කළ යුතුය, නමුත් ඇතුළත දෑත් ඇත, fez + පහළට ආයුධ = වැස්ම, සහ හිස ඇත්ත වශයෙන්ම fez / veil හි ඇත. සාමාන්‍යයෙන් විශාල ස්වරූපය වන්නේ බිලෝ ඇඳුම වන අතර, "ඇස්" සහ "නාසය" ඇඳුමේ නැමීම් වේ.

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

වෙනත් "අක්ෂි" තේරීම් ටිකක් අවදානම් ...

පයිතන්, බයිට් 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,-) 
 (] [)>  <(   )>
 (___)    (   )

සී ජෑම්, බයිට් 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 මැන්ගල්ස් මුද්‍රණය කළ නොහැකි ය, එබැවින් මෙහි පේස්ට්බින් පිටපතක් ඇත. පේළි අංකවලට යාබදව නොව "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]

එමඟින් ආදානයේ එක් එක් ඉලක්කම් ඉලක්කම් භාවිතා කරන ස්ථානයට සිතියම් ගත කරයි. සියලු යෙදවුම් වලට පොදු වන ඕනෑම දෙයක් (උදා: ප්‍රමුඛ අවකාශ සහ ()) අත්තනෝමතික ලෙස 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 ,._  \"_ :   : _"

ඉන්පසු අපි අනුපිටපත් කර, ප්‍රතිස්ථාපනය /<[(කර \>])දිගු නූලක් ලබා දෙන්නෙමු. ඉන්පසු අපි "r pL|P3{cR`@L1iT"Kb21bනූල 4 කාණ්ඩවලට බෙදූ අතර තවත් අරාවකට අනුව සිතියම් ගත කරමු. මේ අනුව සෑම සෛලයකම ඇති විය හැකි සියලු විකල්ප විස්තර කරන දිග -4 නූල් ලබා ගනී (උදා: _=./දෙවන පේළියේ දෙවන අක්‍ෂරය සඳහා කළ හැකි සියලු විකල්පයන්, රුසියානු තොප්පිය).

අවසාන වශයෙන් අපි ඒ අනුව යෙදවුම් සඳහා විකල්පයන් සිතියම් ගත කර .=, දිග 7 පේළි වලට බෙදී 7/සමහර නව රේඛාවල රයිෆල් කරන්නෙමු N*.

ටෙස්ට් ලකුණු

11111111

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

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

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

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

TI-BASIC, බයිට් 397

වැදගත්: ඔබට මෙය පරීක්ෂා කිරීමට අවශ්‍ය නම්, එය මෙතැනින් බාගත කර එම ගොනුව ඔබේ කැල්කියුලේටරය වෙත යවන්න. එපා නොවන ගොඩනැගීමට සහා TI-Connect ක්රිස්තු වර්ෂ වැඩසටහන කර්තෘ හෝ 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.-)/
<( : )
 (   )

සමහර සටහන්:

• එය අනිවාර්යයෙන්ම තවත් ගොල්ෆ් කළ හැකිය, ඒ ගැන කිසිදු ප්‍රශ්නයක් නැත. ප්‍රතිදානය තනි ෆෝ (ලූපයක්) බවට බහුතරයක් ඒකාබද්ධ කළ හැකි බව මම බොහෝ දුරට ධනාත්මක වෙමි. එසේම, මට නූල් කිහිපයක් ඒකාබද්ධ කළ හැකි බව මට හොඳටම විශ්වාසයි.
• Str4 (ඇස්) තුළ මම "කුමන්ත්‍රණ තිත" ( [2ND] → [0]CATALOG → [3]θ → scroll down, it's between ﹢ (small plus) and · (interpunct)) භාවිතා කරන්නේ යම් කාල පරිච්ඡේදයකට වඩා වෙනස්වය. එවිට ඇස් කොමාව සමඟ නොගැලපේ. මන්ද එය අපායක් සේ පෙනේ.
• Str8 (base) හි මට TI-BASIC හි අක්ෂර වලින් ගැලවීමට ක්‍රමයක් නොමැති නිසා ද්විත්ව උපුටා දැක්වීම් වෙනුවට ඩයරෙසිස් (¨) භාවිතා කිරීමට සිදු වූ අතර නූල් ආරම්භ කිරීමට / අවසන් කිරීමට ද්විත්ව උපුටා දැක්වීම් භාවිතා කරයි.
• TI-BASIC හි, වරහන් සහ වරහන් මහා බඩවැලක්, නව රේඛාවක් හෝ → (var පැවරුම සඳහා භාවිතා කරයි) අනුගමනය කරන්නේ නම් ඒවා වසා දැමීමේ අවශ්‍යතාවයක් නොමැත, සහ ද්විත්ව උපුටා දැක්වීම් (නූල්) නව රේඛාවක් හෝ by අනුගමනය කරන විට අනාවරණය නොවී සිටිය හැකිය.

සී, 280 272 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. */
         );
}

සී, බයිට් 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];
}

මම අදහස ගත්තේ රෙටෝ කෝරාඩිගේ පිළිතුරෙනි . මා විසින් කරන ලද විනෝදජනක වැඩිදියුණු කිරීම් කිහිපයක් ඇත, එයට වෙනම පිළිතුරක් පළ කිරීම අවශ්‍ය විය හැකිය:

• ශ්‍රිතයෙන් වැඩසටහනට පරිවර්තනය කර ඇත (+10)
• නව රේඛා පාලක නූලට ගෙන යන ලදි (-7)
• \"(-3) වැනි ගැලවී ගිය අක්ෂර අඩු වීමට සියලුම අක්ෂර කේත වලට 3 ක් එක් කරන ලදි
• ස්වයංක්රීයකරණයෙන් නූලෙන් කියවීම; (-4) t[i++]මගින් ද ප්‍රතිස්ථාපනය වේ*t++
• ආදේශ 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

පයිත්, බයිට් 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\)

Lol. එය මාර්ගගතව උත්සාහ කරන්න: පයිත් සම්පාදක / ක්‍රියාත්මක කරන්නා

පැහැදිලි කිරීම

පළමුවෙන්ම මම උපකාරක ශ්‍රිතයක් අර්ථ දක්වන්නෙමි 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}", එය නූලක් කේන්ද්‍රගත කරයි. එය භාවිතා කිරීමෙන්, මගේ කේතයේ ඇති ඉඩ කිහිපයක් ඉතිරි කර ගත හැකි නමුත් එය අවසානයේ කිසිදු බයිට් එකක් ඉතිරි නොකරයි.

ආර්, බයිට් 436 437

කේත-ගොල්ෆ් පිළිබඳ මගේ පළමු උත්සාහය මෙන්න , R භාවිතා කරමින් කෙටිම නමුත් තවමත් විනෝදජනක නොවේ. අවම වශයෙන් මම ජාවාස්ක්‍රිප්ට් වලට පහර දෙමි (දැනට) ...

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බහුකාර්ය වූ නමුත් ඒවා අතර ඇති දේවල් සමඟ, ( 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 සංස්කරණය කරන්න: උපුටා ගත් පොදු උපස්ථර

සී, 233 230 බයිට්

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 ට වඩා ලූපයක් වන අතර වගුවේ වටිනාකම සොයා ගනී.

ආර් 414 බයිට්

මොල්ක්ස්ගේ අනුවාදයේ තරමක් වෙනස් කරන ලදි

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(දෛනික කටයුතු සඳහා භාවිතා කළ යම් ඉඩක් සෙවීම .

සී ජෑම්, බයිට් 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

මගේ පළමු ඉදිරිපත් කිරීම! හිම මිනිසා ඉහළ සිට පහළට, වමේ සිට දකුණට ගොඩනඟයි. මම එක් එක් හස්තය සඳහා දෑත් කොටස් දෙකකට බෙදුවෙමි, හිස හිසට යාබද කොටස සහ ශරීරයට යාබද කොටස.

ශ්‍රිතය පූර්ණ සංඛ්‍යා ලැයිස්තුවක් ගෙන ආදානයේ නිවැරදි උප ලැයිස්තු ලබා දී ඇති ශරීර කොටස් නිපදවන ශ්‍රිතවල ප්‍රතිදානය සමපාත කරයි.

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 වන අංගය නැවත ලබා දෙයි. මෙය a හි තොප්පි ලැයිස්තුවක් මෙන්ම වෙනත් දේ සඳහාද ඉඩ දෙයි

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

පවර්ෂෙල් , බයිට් 199 යි

රෙටෝ කෝරාඩි සහ ඇනටොලිග් විසින් දේවානුභාවයෙන් .

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“නිදිමත රුසියානු ආරක්ෂකයා”:

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

ජාවාස්ක්‍රිප්ට් (ඊඑස් 6), 247

එතරම් හොඳ දැන්වීමක් නොවේ @ NinjaBearMonkey's :(

ස්නිපටයේ පරීක්ෂණය (ෆයර්ෆොක්ස් සමඟ)

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 121 බයිට්

…( )7ÝJ»•αγʒδÓ₂©8¥ŽQxΣxêÿ•sÅв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
 s           # Swap to get the earlier created string at the top of the stack
  Åв         # Convert the large integer to base-"( )\n01234567",
             # which basically converts to base-length, and indexes 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 → [" "," "," "," ",":"," ","]"," ","[",">"," ","<"]

ඉන්පසු අක්ෂර ලැයිස්තුව සමාන කොටස් හතරකට බෙදන්න, සහ ආදාන-ඉලක්කම් y(එය 1-සුචිගත කර ඇති) භාවිතා කර එයට දර්ශක කරන්න. (සටහන: 05AB1E 0-සුචිගත නිසා, නමුත් ආදාන 1-සුචිගත වේ, එය ශක පෙර ඉලක්කම් 1 අඩු කිරීමට තාර්කික වනු ඇත කෙසේ වෙතත්, 05AB1E ස්වයංක්රීය wraparound කර ඇති බැවින් (එනම්, සූචිගත. 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

අවසානයේ ප්‍රති result ලය ව්‍යංගයෙන් ප්‍රතිදානය වේ.

සම්පීඩන කොටස් ක්‍රියා කරන ආකාරය අවබෝධ කර ගැනීම සඳහා මෙම 05AB1E ඉඟිය බලන්න ( විශාල සංඛ්‍යා සම්පීඩනය කරන්නේ කෙසේද ? සහ පූර්ණ සංඛ්‍යා සම්පීඩනය කරන්නේ කෙසේද? ) .

මගේ ප්‍රියතම දේ නම්, එය මීට වසර 1.5 කට පෙර මම මගේ ජාවා විසඳුම පළ කළ විට සමාන 'හිම හාවා' ය :

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

ජාවා 8, 548 545 432 401 399 397 බයිට්

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:32+X%2*15,"   s : s] [s> <".split("s")[a[6]%4],92-(Y%3+Y%6/4)*30,"   s : s\" \"s___".split("s")[a[7]%4]);}

බයිට් -2 ක් @ceilingcat ට ස්තූතියි .

එය මෙහි උත්සාහ කරන්න.

පැහැදිලි කිරීම:

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:32+X%2*15,                          //  + 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:
   _  
 (_*_)
 (. .) 
 (> <) 
 (" ")

එයට හේතුව මම නොදනිමි, නමුත් එය හුරුබුහුටි පෙනුමකි. කන් වෙනුවට රුසියානු තොප්පියක් ඇති බනිස් මෙන්.

එෆ් #, බයිට් 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}

හිම හිම මිනිසා:

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

Clojure (407 කි බයිට් 402)

(defn a[s](let[[H N L R X Y T B](into[](map #(-(int %)49)(into[]s)))h(["""  ___""   _""  ___"]H)i([" _===_"" .....""  /_\\"" (_*_)"]H)n([","".""_"" "]N)e[".""o""O""-"]l([" ""\\"" "" "]X)m(["<"" ""/"" "]X)r(["""/"""""]Y)u([">""""\\"""]Y)t([" : ""] [""> <""   "]T)b([" : ""   ""___""   "]B)d(["""\" \""""""]B)f(str \newline)](str h f i f l "(" (e L) n (e R) ")" r f m "(" t ")" u f " (" b ")" f "  " d)))

එය සෑම කෙනෙකුටම පැහැදිලිය.

නැතිනම් ...

Ungolfed අනුවාදය:

(defn build-a-snowman [s]
  (let [ [H N L R X Y T B] (into [] (map #(- (int %) 49) (into [] s)))
         hat1     ([""       "  ___"  "   _"   "  ___" ] H) ; first line of hats
         hat2     ([" _===_" " ....." "  /_\\" " (_*_)"] H) ; second line of hats
         nose     ([","      "."      "_"      " "     ] N)
         eye      ["."      "o"      "O"      "-"     ]
         left1    ([" "      "\\"     " "      " "     ] X) ; left arm, upper position
         left2    (["<"      " "      "/"      " "     ] X) ; left arm, lower position
         right1   ([""       "/"      ""       ""      ] Y) ; right arm, upper position
         right2   ([">"      ""       "\\"     ""      ] Y) ; right arm, lower position
         torso    ([" : "    "] ["    "> <"    "   "   ] T)
         base1    ([" : "    "   "    "___"    "   "   ] B) ; first line of base
         base2    ([""       "\" \""  ""       ""      ] B) ; second line of base
         nl       (str \newline) ]
    (str hat1 nl
         hat2 nl
         left1 "(" (eye L) nose (eye R) ")" right1 nl
         left2 "(" torso ")" right2 nl
         " (" base1 ")" nl
         "  " base2)))

පරීක්ෂණ:

(println (a "33232124"))  ; waving guy with fez 
(println (a "11114411"))  ; simple ASCII-art snowman
(println (a "34334442"))  ; mouse
(println (a "41214433"))  ; commissar with monocle
(println (a "41212243"))  ; commissar celebrating success of five-year plan
(println (a "41232243"))  ; commissar after too much vodka

මගේ ප්රියතම:

34334442 - මූසිකය

එය මාර්ගගතව උත්සාහ කරන්න!