क्या आप एक स्नोमैन को कोड करना चाहते हैं?

176

यहाँ एक सरल ASCII कला स्नोमैन है:

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

चलो उसे कुछ दोस्त बनाते हैं। यह हमारे ASCII कला हिमपात लोगों के लिए सामान्य पैटर्न होगा:

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

अग्रणी स्थान और कोष्ठक हमेशा सभी हिमपातियों के लिए समान होते हैं। अलग-अलग अक्षर पैटर्न के वर्गों का प्रतिनिधित्व करते हैं जो व्यक्तिगत रूप से बदल सकते हैं। प्रत्येक खंड में चार प्रीसेट हैं जो ASCII वर्ण इसे भर सकते हैं। इन प्रीसेट को सभी आठ वर्गों के लिए मिश्रित करके, हम विभिन्न प्रकार के हिमपात कर सकते हैं।

सभी प्रीसेट

(ध्यान दें कि रिक्त स्थान अन्यथा रिक्त स्थान पर रखे गए हैं ताकि अनुभाग आकार हमेशा सही हो।)

H, Hat के लिए है

  1. स्ट्रा हैट

         
_===_

  2. मैक्सिकन हैट

     ___ 
.....

  3. फेज

      _  
 /_\

  4. रूसी टोपी

     ___ 
(_*_)

N नाक / मुँह के लिए है

  1. साधारण ,

  2. डॉट .

  3. लाइन _

  4. कोई नहीं

L, लेफ्ट आई के लिए है

  1. डॉट .

  2. बड़ा डॉट o

  3. सबसे बड़ा डॉट O

  4. बन्द है -

आर राइट आई के लिए है

(बाईं आंख के रूप में एक ही सूची।)

X लेफ्ट आर्म के लिए है

  1. सामान्य भुजा

     
<

  2. ऊपर की भुजा

    \

  3. नीचे की ओर बांह

     
/

  4. कोई नहीं

Y राइट आर्म के लिए है

  1. सामान्य भुजा

     
>

  2. ऊपर की भुजा

    /

  3. नीचे की ओर बांह

     
\

  4. कोई नहीं

T धड़ के लिए है

  1. बटन :

  2. बनियान ] [

  3. आवक शस्त्र > <

  4. कोई नहीं

B बेस के लिए है

  1. बटन :

  2. पैर का पंजा " "

  3. समतल ___

  4. कोई नहीं

चुनौती

प्रारूप में एक आठ वर्ण स्ट्रिंग (स्टड या कमांड लाइन के माध्यम से) में एक प्रोग्राम लिखें HNLRXYTB, जहां प्रत्येक अक्षर 1 से 4 तक का एक अंक है जो यह दर्शाता है कि स्नोपरर्स के संबंधित अनुभाग के लिए कौन से प्रीसेट का उपयोग करना है। पूर्ण स्नूपर्स को प्रिंटआउट में प्रिंट करें।

उदाहरण के लिए, इनपुट 11114411पृष्ठ के शीर्ष पर स्नोमैन है। (पहले 1: उसके पास एक पुआल टोपी है, दूसरा 1: उसकी एक सामान्य नाक है, आदि)

एक और उदाहरण, इनपुट के लिए स्नोपरसन 33232124:

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

विवरण

  • किसी भी मात्रा और प्रमुख / अनुगामी स्थानों के संयोजन और प्रमुख / अनुगामी न्यूलाइन्स को लंबे समय के रूप में अनुमति दी जाती है ...

    • स्नोपर्सन ने अपने सभी वर्गों को एक दूसरे के संबंध में सही तरीके से व्यवस्थित किया है, और
    • 64 से अधिक कुल व्हाट्सएप वर्ण कभी नहीं होते हैं (सामान्य पैटर्न केवल 7 × 5 है, इसलिए आप शायद इस सीमा को नहीं मारेंगे)।

    आपको पैटर्न की पंक्तियों / स्तंभों को प्रिंट करने की आवश्यकता नहीं है, यदि उनमें केवल व्हाट्सएप हो। उदाहरण के लिए पुआल टोपी की खाली लाइन की आवश्यकता नहीं है।

  • आपको ऊपर दिए गए भागों के क्रम का उपयोग करना चाहिए।

  • एक कार्यक्रम के बजाय, आप एक फ़ंक्शन लिख सकते हैं जो अंक स्ट्रिंग को तर्क के रूप में लेता है। आउटपुट को सामान्य रूप से मुद्रित किया जाना चाहिए या एक स्ट्रिंग के रूप में लौटाया जाना चाहिए।

  • यदि आप चाहें तो इनपुट को एक स्ट्रिंग के बजाय पूर्णांक के रूप में मान सकते हैं।

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है।

बोनस प्रश्न: 65536 अलग-अलग स्नो पर्सन में से कौन सा आपका पसंदीदा है?

code-golf  string  ascii-art 
— केल्विन के शौक
स्रोत
19
मुझे परी 14441133 पसंद है । वैकल्पिक रूप से छोटे आंखों वाले चार-सशस्त्र राक्षस। आपकी पिक
— Sp3000
14
क्या यह एक स्नोमैन होना चाहिए?
54
यह एक स्नोमैन होना जरूरी नहीं है। (डिस्क्लेमर: यह एक स्नोमैन हो सकता है)
— जोशपब्रॉन
3
सामयिक मजाकिया टिप्पणी अच्छी है, लेकिन विस्तारित चर्चा के लिए कृपया टिप्पणियों के बजाय चैट का उपयोग करें । मैंने इसे थोड़ा साफ किया है।
— मार्टिन एंडर
36
अगला करने के लिए प्रश्न: "कोड ने मुझे कभी भी परेशान नहीं किया"
— केल्विन के शौक

जवाबों:

39

CJam, 135 134 132 130 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 दुभाषिया का उपयोग करके कोड को ऑनलाइन आज़मा सकते हैं ।

बोनस

मेरा पसंदीदा स्नोमैन Olaf है:

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

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

सर्दियों में रहने और कुडल करने का एक अच्छा समय है, लेकिन मुझे गर्मियों में डाल दो और मैं एक खुशहाल स्नोमैन बनूंगा!

विचार

हेक्स स्ट्रिंग

dd7382d6bfab28707190992f240c362ee510262bd07a7708
556de9dcdb566c676817c2b87f5ecb8bab145dc2f2f76e07

स्नोमैन के सभी हिस्सों के लिए संभव विकल्पों को एन्कोड करता है, जिसमें फिक्स्ड वाले भी शामिल हैं। चलो इस स्ट्रिंग को पी कहते हैं ।

इसे डीकोड करने के लिए, हम पी को परिवर्तित करते हैं (यहाँ एक पूर्णांक के रूप में माना जाता है) को बेस 256 से बेस 20 तक और परिणामस्वरूप प्रत्येक पूर्णांक को स्ट्रिंग M के संगत वर्ण द्वारा प्रतिस्थापित करें :

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

यह स्ट्रिंग T में परिणाम देता है :

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

पहली पंक्ति सभी हैट विकल्पों को एन्कोड करती है, अंतिम सभी निश्चित बॉडी पार्ट्स। अन्य लाइनों में 28 वैरिएबल बॉडी पार्ट्स होते हैं।

हम टी को लाइनफीड में विभाजित करते हैं और परिणामस्वरूप सरणी के तारों को समान लंबाई के चार भागों में विभाजित करते हैं। फिर, हम एसटीडीआईएन से इनपुट पढ़ते हैं, बेस 10 में इसके अंकों की सरणी को आगे बढ़ाते हैं और विभाजन के तार के संबंधित तत्वों का चयन करते हैं। हम इस तथ्य का लाभ उठाते हैं कि सरणियां सीजेएम में चारों ओर लपेटती हैं, इसलिए लंबाई 4 की एक सरणी के सूचकांक 4 में तत्व वास्तव में पहला तत्व है। अंतिम विभाजित स्ट्रिंग किसी इनपुट के अनुरूप नहीं है, इसलिए यह पूरी तरह से चयनित हो जाएगा।

हम परिणामस्वरूप तत्व से पहले तत्व को स्थानांतरित करके टोपी को संभालते हैं। M के पहले चरित्र में सूचकांक , एक आधार 4 नंबर के रूप में पढ़ा जाता है, टोपी की पहली पंक्ति में रिक्त स्थान की संख्या और अंडरस्कोर को दर्शाता है। हम उन वर्णों को प्रिंट करते हैं, एक लाइनफीड, एक स्थान और स्थानांतरित स्ट्रिंग के शेष। फिर, हम स्टैक के तल पर एक अतिरिक्त लाइनफीड धक्का देते हैं।

शरीर के अंगों के लिए, हम उन सभी के अनुरूप स्ट्रिंग को बदलते हैं। चलिए इस तार को S कहते हैं । शरीर के अंगों को इकट्ठा करने के लिए, हम लिप्यंतरण करते हैं: हम स्ट्रिंग एम के प्रत्येक चरित्र को लेते हैं , इसके सूचकांक को सॉर्ट (एम) में गणना करते हैं और इसे एस के इसी चरित्र द्वारा प्रतिस्थापित करते हैं । हम इस तथ्य का लाभ उठाते हैं कि लिप्यंतरण ऑपरेटर स्वचालित रूप से S के अंतिम वर्ण को आवश्यकतानुसार कई बार दोहराकर S (M) की लंबाई का मिलान करता है।

अंत में, हम परिणामी स्ट्रिंग को लंबाई 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.
— डेनिस
स्रोत
60

जावास्क्रिप्ट ईएस 6, 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 लाइनें थीं, इसलिए मुझे ऊपर और नीचे दोनों के लिए कोड शामिल करना था।

नीचे दिए गए स्टैक स्निपेट में असमतल, संयुक्त राष्ट्र ES6-ified, टिप्पणी कोड है। और आप आसानी से कोड का परीक्षण करने और विभिन्न संयोजनों का प्रयास करने के लिए इसका उपयोग कर सकते हैं। संपादित करें: मैं इस के साथ बहुत मज़ा कर रहा हूँ। मैंने कई नई सुविधाएँ जोड़ी हैं, जिसमें एक यादृच्छिक स्नोमैन उत्पन्न करने का तरीका भी शामिल है।

छह बाइट बचाने के लिए यार रैंड को धन्यवाद।

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">
स्निपेट का विस्तार करें

— NinjaBearMonkey
स्रोत
3
+1 बहुत चालाक, मेरी तुलना में बहुत बेहतर
— edc65
23
'जीयूआई' बहुत ही शानदार है।
— Topher
7
22112333: मीठा, 8 आंखों मकड़ी हिममानव की जाँच
— Claudiu
1
मुझे सोते हुए रूसी उल्लू पसंद है: 41444442
— ETHproductions
1
आप एक स्लॉट ( 1 1-> 11) में प्रत्येक एकल स्थान को हटाकर और ||' 'अंत में जोड़कर छह बाइट्स बचा सकते हैं ।
— येर रैंड
30

सीजेएम, 164 बाइट्स

स्नोमैन को बाएं से दाएं, ऊपर से नीचे की ओर उत्पन्न करता है। यह किसी भी प्रकार के स्ट्रिंग ज्वाइनिंग या रिपोजिशनिंग ऑपरेशंस की आवश्यकता को समाप्त करता है, क्योंकि मैं स्टैक पर स्नोमैन के हर टुकड़े को छोड़ता हूं। और फिर, कार्यक्रमों के अंत में स्वचालित स्टैक डंप के कारण:

♫ सीजम एक स्नोमैन का निर्माण करना चाहता है! ♫

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

इसे ऑनलाइन आज़माएं।

बोनस

खुल के सोचो! 32443333एक बर्फ (वू) आदमी दुल्हन देता है। आप इसे देखने के लिए थोड़ा सा प्रयास करेंगे, लेकिन अंदर की ओर हथियार, fez + नीचे की ओर हथियार = घूंघट हैं, और सिर वास्तव में fez / घूंघट में है। आम तौर पर बड़े रूप में बिलॉवी पोशाक होती है, और "आँखें" और "नाक" पोशाक में सिलवटों होती हैं।

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

अन्य "आंख" विकल्प थोड़ा बड़ा है ...

— Runer112
स्रोत
17
मेरे लिए, आपका बोनस दुल्हन की तुलना में केकेके सदस्य की तरह अधिक दिखता है।
— ace_HongKongInd डिपेंडेंस
26

पायथन, 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") "नींद रूसी भालू" देता है:

  ___    
 (_*_)
 (- -)
 (> <)
 (" ")
— Claudiu
स्रोत
13
नींद रूसी भालू अब मेरा भी पसंदीदा है।
— केल्विन के शौक
1
शीर्ष पंक्ति अंडरस् फ्रोज़ और रूसी टोपियों पर सही नहीं लगती है। उदा। यह एक प्रोपेलर टोपी दे रहा है ..
— केल्विन के शौक
@ केल्विन के शौक: रूसी टोपी ठीक थी, लेकिन फ़ैज़ टोपी गड़बड़ कर दी गई थी। मैंने इसे अब ठीक कर दिया और अन्य सभी मामलों की भी जाँच की। मुझे भविष्य में और अधिक सावधान रहना चाहिए!
— क्लाउडिया
पार्टी के लिए सुपर लेट, लेकिन यह टीआईओ कहता है कि यह मेरे लिए 297 है। इंटेलीज कहते हैं 299. क्या मुझे कुछ याद आ रहा है?
— बर्फानी
21

पायथन 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,-) 
 (] [)>  <(   )>
 (___)    (   )
— सेसम टिमरमैन
स्रोत
1
जब मैं करता हूँ s('33232124')fez स्लैश तैयार नहीं हैं। वास्तव में टोपी का निचला हिस्सा बहुत सारे मामलों में गायब है। इसके अलावा, 0विकल्पों में से एक नहीं है।
— केल्विन के शौक
@ केल्विन हॉबीज़ थैंक्स, मैंने इसे ठीक किया।
— सेस टिम्मरमैन
20

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*

एसई unprintables, तो यहाँ Pastebin पर एक प्रति है। सुनिश्चित करें कि आप "RAW पेस्ट डेटा" भाग की प्रतिलिपि बनाएँ, न कि पंक्ति संख्याओं के आगे का भाग। आप इसे ऑनलाइन आज़मा सकते हैं , लेकिन कुछ ब्राउज़र में पर्मलिंक काम नहीं कर सकता है।

व्याख्या

"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 को सौंपा गया है, पहले को छोड़कर जो 1 सौंपा गया है ताकि आधार कन्वर्ट काम कर सके।

l:~f= फिर प्रत्येक अंक को एक इंट में बदलता है और उसी के अनुसार मैप करता है, उदाहरण के लिए 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
  ___  
 (_*_) 
 (- -) 
 (   ) 
 (   )
— Sp3000
स्रोत
19

टीआई-बेसिक, 397 बाइट्स

महत्वपूर्ण: यदि आप इसका परीक्षण करना चाहते हैं, तो इसे यहां से डाउनलोड करें और उस फ़ाइल को अपने कैलकुलेटर पर भेजें। करो नहीं TI-कनेक्ट सीई कार्यक्रम संपादक या 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 (बेस) में, मुझे दोहरे उद्धरण चिह्नों के बजाय एक डाइरेसिस (instead) का उपयोग करना पड़ा क्योंकि TI-BASIC में वर्णों से बचने का कोई तरीका नहीं है, और स्ट्रिंग को प्रारंभ / समाप्त करने के लिए दोहरे उद्धरण चिह्नों का उपयोग किया जाता है।
  • TI-BASIC में, कोष्ठक और कोष्ठक को बंद करने की कोई आवश्यकता नहीं है यदि वे एक बृहदान्त्र, newline या → (var असाइनमेंट के लिए प्रयुक्त) का पालन करते हैं, और newline या → द्वारा पीछा किए जाने पर दोहरे उद्धरण (स्ट्रिंग्स) को बंद नहीं किया जा सकता है।
— एमआई राइट
स्रोत
1
पहला, दूसरी पंक्ति में, length(Ansहोना चाहिए length(Str9; दूसरा, क्या आपने Str3 के माध्यम से Str3 को एक स्ट्रिंग में संयोजित करने की कोशिश की है?
— lirtosiast
ओह, उफ़! मुझे लगता है कि डाउनलोड में यह तय है, हालांकि। कि इसके अलावा, मैं इतना पर ध्यान दिया है नहीं के बाद से मैं इसे बनाया है, लेकिन मैं किया था उल्लेख नहीं है कि मैं शायद कुछ तार एक साथ मर्ज कर सकता है; मैं आज / कभी इस सप्ताह में देखूंगा।
— एमआई राइट
18

सी, 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. */
         );
}
— Cl-
स्रोत
12

सी, 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) को खत्म करने के लिए परिवर्तित

वह सब परेशानी क्यों? मेरा पसंदीदा एक साझा करने के लिए, बर्फ भूत:

   _
  /_\
\(. .)/
 (   )
 (___)
— anatolyg
स्रोत
dपीछे के main
— पार्न्स
10

जावास्क्रिप्ट, 489 (newlines और टैब के बिना)

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

— क्रिस्टोफर रीड
स्रोत
6
कोड गोल्फ में आपका स्वागत है! कुछ संकेत: आपको parseIntकॉल की आवश्यकता नहीं हो सकती है , क्योंकि घटाव स्वचालित रूप से संख्याओं के लिए स्ट्रिंग ऑपरेंड करने का प्रयास करता है। इसके अलावा, आप functionरैपिंग से छुटकारा पा सकते हैं और बस लीड कर सकते हैं i=process.argv[2], जब तक कि आप इसे रिकर्सन या वैरिएबल स्कोपिंग के लिए उपयोग नहीं कर रहे हैं। इसके अतिरिक्त, आप sपूरी तरह से छुटकारा पा सकते हैं और बस कर सकते हैं console.log([ ... ].join('\n'))।
— apsillers
3
वास्तव में, आप इनपुट स्ट्रिंग-टू-ऐरे रूपांतरण को पूरी तरह से कर सकते हैं यदि आप प्रत्येक आइटम के सूचकांक को बढ़ाने के लिए अपने प्रत्येक सरणियों में एक अग्रणी अल्पविराम लगाते हैं। यह 7 कहते हैं ,वर्ण, लेकिन यह आप एक से अधिक 50. अंत में, एक बहुत नकचढ़ा अनुकूलन का उपयोग करेंगे दूर करने के लिए अनुमति देता है q=j[4]-1के बजाय q=j[4]==1(और फिर के आपके उपयोग flipping qऔर !q)। इस कारण होगा qहोने के लिए 0(एक falsey मूल्य) जब j[4]है 1, और नहीं तो एक truthy अशून्य मूल्य। यह आपके वर्तमान सही / गलत मूल्यों के बिल्कुल विपरीत है, इसलिए आप बस स्विच करते हैं qऔर !q।
— अप्सिलर्स
आपके पहले जवाब पर प्रतिक्रिया के टीले के लिए क्षमा करें! मैं व्यक्तिगत रूप से अपने सबमिशन को संशोधित करके गोल्फिंग के सबसे मज़ेदार हिस्सों में से एक मानता हूँ; यदि आप मेरी भावना को साझा नहीं करते हैं तो मेरी क्षमा याचना। :)
— apsillers
@apsillers आपकी प्रतिक्रिया की बहुत सराहना की है! मैं कल रात सोने जा रहा था और फिर इसे बाद में सबसे सरल तरीके से संभव करने के लिए इसे चौड़ा करने के पूरे इरादे से मज़े के लिए लिखा। मैं आज रात कुछ संपादन कर रहा हूँ!
— क्रिस्टोफर रीड
9

पायथ, 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\)

जबरदस्त हंसी। इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

व्याख्या

पहले मैं एक सहायक फ़ंक्शन को परिभाषित करता हूं g, जो एक सूची और एक इनपुट के रूप में चार ले जाता है, चार को अपने एएससीआईआई-मूल्य में परिवर्तित करता है और संवाददाता तत्व (मॉड्यूलर रैपिंग) लेता है।

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}", जो एक स्ट्रिंग को केंद्र में रखता है। इसका उपयोग करते हुए, मैं अपने कोड में कुछ स्थान बचा सकता था, लेकिन यह अंत में किसी भी बाइट को नहीं बचाता है।

— Jakube
स्रोत
9

आर, 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 के साथ चर विराम के बीच की रेखा विराम को कम कर सकता था ;, लेकिन "एक पंक्तिबद्ध" कोड इतना बुरा और अपठनीय लगता है कि मैं उस लालची नहीं रहूंगा।

— Molx
स्रोत
आपको 4 वीं टोपी के लिए और अतिरिक्त चार की आवश्यकता है
— ओग्मैन
@OganM उस अतिरिक्त बाइट के लिए धन्यवाद! :( स्थिर।
— मोलक्स
कोडगुल्फ़ करते समय हम आम तौर पर प्रत्येक नई पंक्ति को एक वर्ण के रूप में गिनते हैं (जैसा कि यह * निक्स पर है) दो के विपरीत (विंडोज़ में)। इसलिए यह मायने नहीं रखता कि आप अर्धविराम या नई पंक्ति का उपयोग करते हैं या नहीं।
— ace_HongKongIndोसेंडेंस
@ace टिप के लिए धन्यवाद, अच्छा पता है!
— मोलक्स
8

हास्केल, 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: निकाले गए सामान्य पदार्थ

— nimi
स्रोत
8

सी, 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 वर्णों पर लूप करता है, और तालिका में मान दिखता है।

— रेटो कोराडी
स्रोत
8

आर 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(रूटीन के लिए इस्तेमाल किया गया था ।

— OganM
स्रोत
7

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)/
 (] [) 
 (___)

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
7

हास्केल, 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)

जो दी गई सूची का nth तत्व देता है। यह एक के रूप में अच्छी तरह से चीजों में टोपी की सूची के लिए अनुमति देता है

k=y" /  "

ये सभी फ़ंक्शन बीटा कमी का उपयोग करते हैं, इसलिए उनके तर्क को y फ़ंक्शन के सूचकांक के रूप में पारित किया जाता है।

आउटपुट:

λ> s $ repeat 1

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

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

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

λ> s $ repeat 4
  ___ 
 (_*_)
 (- -) 
 (   ) 
 (   )
— क्रेग रॉय
स्रोत
@ केल्विन हॉबीज़ थैंक्स, मुझे लगता है कि मैंने अब ठीक कर लिया है।
— क्रेग रॉय
7

पायथन 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))
— मैटी
स्रोत
आप बीच में पंक्ति 2 में स्थान हटा सकते हैं [int(i)]और for। इसी तरह आप लाइन 7 f(int(i))और के बीच की जगह को हटा सकते हैं for। इसके अलावा, आपके print()बयान में आपको अंतिम स्थान को प्रिंट करने की आवश्यकता नहीं है - यह स्नोमैन का हिस्सा नहीं है। अंत में, अपने print()कॉल को सिंगल-लाइन में बदलें print("{}\n{}({}{}{}){}\n{}({}){}\n ({})".format(*c))। इनमें से प्रत्येक को आपको 1 बाइट बचाना चाहिए, जिससे कुल 4 बाइट
— बचती हैं
1
इसके अलावा, वैश्विक चर का उपयोग करने के बजाय n, आप फ़ंक्शन की विशेषता को परिभाषित कर सकते हैं f। तो आप लाइनों को 5-6 से बदल सकते हैं: def f(m):f.n+=1;return l[4*m+int(b[f.n])-1]<newline> f.n=-1। यह 3 और बाइट्स को कम करता है।
— ace_HongKongIndependence
1
@ace धन्यवाद, इससे पहले कभी भी फ़ंक्शन विशेषता के बारे में नहीं सुना, कुछ नया सीखा!
— मैटी
6

शक्ति कोशिका , 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"नींद रूसी रक्षक" है:

 ___
(_*_)
(- -)
(   )
(   )
— Mazzy
स्रोत
5

जावास्क्रिप्ट (ईएस 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>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

05AB1E , 137 135 128 122 बाइट्स

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

-6 बाइट्स @Grimy को धन्यवाद ।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

हम पहले टेम्पलेट-स्ट्रिंग बनाते हैं:

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

और निम्न कार्य करें:
सूची Nका (0-अनुक्रमित) सूचकांक पुश करें :

  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 में स्वचालित रैपराउंड है (यानी 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 साल पहले की तरह ही 'स्नो खरगोश' है, जब मैंने अपना जावा समाधान पोस्ट किया था :

44114432:
   _  
 (_*_)
 (. .) 
 (> <) 
 (" ")
— केविन क्रूज़सेन
स्रोत
-4 , सीजेएम को हराने के लिए बस इतना काफी है!
— ग्रिमी
1
122 से नीचे , और मूल रूप से जो आपके पास था उसके करीब भी।
— ग्रिम
@Grimy आपका 122 बाइट संस्करण 0उसकी आँखों के बीच है। :)
— केविन क्रूज़सेन
बस एक बेस -12 एन्कोडिंग गलती, ठीक करने के लिए पर्याप्त आसान होना चाहिए!
— गंभीर
@Grimy तुम सही हो। मेरे पास कल बहुत समय नहीं था, लेकिन यह वास्तव में सूची में एक साधारण सुधार है। धन्यवाद के लिए -6! :)
— केविन क्रूज़सेन
2

जावा 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:
   _  
 (_*_)
 (. .) 
 (> <) 
 (" ")

मुझे पता नहीं क्यों, लेकिन यह थोड़े प्यारा लगता है। कानों के बजाय रूसी टोपी के साथ एक बनी की तरह।

— केविन क्रूज़सेन
स्रोत
1

एफ #, 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) 
 ( : ) 
 ( : )

मैं तुम्हें देख रहा हूं

— Ciaran_McCarthy
स्रोत
1

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) 
/(   )\
 (" ")
— Jo।
स्रोत
1

पायथन 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")

— खलील
स्रोत
2
PPCG में आपका स्वागत है! जैसा कि होता है, यह 256 बाइट्स है। दुर्भाग्य से, आप यह नहीं मान सकते हैं कि इनपुट एक चर में संग्रहीत है। आप फिर भी जगह ले सकता है iके लिए input()262 बाइट्स के लिए कुल
— H.PWiz
0

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) 
 (] [)>
 (" ")
— roblogic
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.