परिचय:

मुझे लगता है कि हम सभी इसे जानते हैं, और इसका अनुवाद संभवत: विभिन्न भाषाओं के भार में किया गया है: "हेड, शोल्डर्स, केन एंड टोज़" चिल्ड्रन सॉन्ग:

सिर, कंधे, घुटने और पैर की उंगलियों, घुटने और पैर की उंगलियों
सिर, कंधे, घुटने और पैर की उंगलियों, घुटने और पैर की उंगलियों
और आँखें और कान और मुंह और नाक
सिर, कंधे, घुटने और पैर की उंगलियों, घुटने और पैर की उंगलियों
विकिपीडिया

चुनौती:

इनपुट: एक सकारात्मक पूर्णांक।

आउटपुट: n- वें सूचकांक के रूप में इनपुट के आधार पर निम्नलिखित शब्दों में से एक आउटपुट:

head
shoulders
knees
toes
eyes
ears
mouth
nose

यहाँ शरीर के अंगों को अनुक्रमित के साथ जोड़ा गया है:

Head (0), shoulders (1), knees (2) and toes (3), knees (4) and toes  (5)
Head (6), shoulders (7), knees (8) and toes (9), knees (10) and toes (11) 
And eyes (12) and ears (13) and mouth (14) and nose (15)
Head (16), shoulders (17), knees (18) and toes (19), knees (20) and toes (21)

Head (22), shoulders (23), knees (24) and toes (25), knees (26) and toes  (27)
Head (28), shoulders (29), knees (30) and toes (31), knees (32) and toes (33) 
And eyes (34) and ears (35) and mouth (36) and nose (37)
Head (38), shoulders (39), knees (40) and toes (41), knees (42) and toes (43)

etc.

चुनौती नियम:

आप बेशक 0-अनुक्रमित के बजाय 1-अनुक्रमित इनपुट का उपयोग करने की अनुमति देते हैं। लेकिन कृपया निर्दिष्ट करें कि आपने अपने उत्तर में किसका उपयोग किया है।
आउटपुट असंवेदनशील है, इसलिए यदि आप इसे कैप्स में आउटपुट देना चाहते हैं तो यह ठीक है।
आपको कम से कम 1,000 तक इनपुट का समर्थन करना चाहिए।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

परीक्षण के मामले (0-अनुक्रमित):

Input:  Output:
0       head
1       shoulders
7       shoulders
13      ears
20      knees
35      ears
37      nose
98      knees
543     nose
1000    knees

code-golf string kolmogorov-complexity

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

3

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

— मार्टिन एंडर

@MartinEnder धन्यवाद मैं, गलत तरीके से, केवल kolmogorov-complexityउन उत्तरों के लिए उपयोग किया जाता है जो हमेशा एक ही निश्चित आउटपुट होते हैं, लेकिन अब मैं देख रहा हूं कि यह कोड में निश्चित आउटपुट-स्ट्रिंग्स के बारे में है, और इसे खोजने के लिए पैटर्न खोज रहे हैं (या इसे @ Enigma के 05AB1E उत्तर के साथ एन्कोड करें )। इसे जोड़ने के लिए धन्यवाद; मुझे यह भी पक्का नहीं था कि इस चुनौती के लिए कौन से टैग प्रासंगिक थे, जो सैंडबॉक्स में मेरे (दुर्भाग्य से अनुत्तरित) सवालों में से एक था।

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

1

टैग के उपयोग के बारे में प्रासंगिक मेटा पोस्ट।

— मार्टिन एंडर

1

@KevinCruijssen कम से कम आपके प्रश्न ने कुछ + 1 का :) (आशावादी टिप्पणी) पकड़ा है आप सैंडबॉक्स में खोज कर सकते हैं inquestion:2140 shoulders।

— निकोलग्राफ

3

क्या किसी और ने पूरे दिन इस गाने को अपने सिर में

— फँसा लिया

12

05AB1E , 36 35 34 बाइट्स

“‡ä¾ØsÏ©s¸±s“#2ä¤«Ð“—íÖÇ©¢ÄÃ“#s)˜è

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

“‡ä¾ØsÏ©s¸±s“                        # dictionary string 'head shoulders knees toes'
             #                       # split on spaces
              2ä                     # split in 2 parts
                ¤                    # get the last part ['knees', 'toes']
                 «                   # concatenate and flatten
                                     # STACK: [['head', 'shoulders'], ['knees', 'toes'], 'knees', 'toes']
                  Ð                  # triplicate
                   “—íÖÇ©¢ÄÃ“        # dictionary string 'eyes ears mouth nose'
                             #s      # split on spaces and swap top 2 elements of stack
                               )˜    # wrap stack in a list and flatten
                                 è   # index into list with input

संक्षेप में, हम ['head', 'shoulders', 'knees', 'toes', 'knees', 'toes', 'head', 'shoulders', 'knees', 'toes', 'knees', 'toes', 'eyes', 'ears', 'mouth', 'nose', 'head', 'shoulders', 'knees', 'toes', 'knees', 'toes']इनपुट (0-अनुक्रमित) के साथ सूची और सूचकांक का निर्माण करते हैं ।

— Emigna
स्रोत

4

@ केविनक्रूजसेन: एक स्पष्टीकरण टो की आ रही है :) यह गोल्फ की भाषाओं के लिए बहुत अनिवार्य है।

— एमिगा

‡ä¾ØsÏ©s¸±sअजीब लगता है, यह देखते हुए कि प्रत्येक शब्द 2 वर्ण है। यह कुछ और है?

— निकोलफर

2

@EriktheGolfer: हाँ, 3 sके बहुवचन हैं shoulder, knee, toeजो कोश में विलक्षण हैं। हमें इसकी आवश्यकता नहीं है eyes, earsक्योंकि वे पहले से ही शब्दकोश में बहुवचन में हैं ताकि स्ट्रिंग की अपेक्षित लंबाई भी हो।

— 15

ओह, उन्होंने मुझे भ्रमित कर दिया। धन्यवाद।

— निकोलगर्फ़

31

जावास्क्रिप्ट (ईएस 6), 91 88 87 बाइट्स

n=>'knees,toes,head,shoulders,eyes,ears,mouth,nose'.split`,`[(245890>>(n%22&~1))&6|n%2]

यह काम किस प्रकार करता है

हमारे पास 4 अलग-अलग शब्द हैं जो हमेशा एक साथ दिखाई देते हैं: 'सिर' हमेशा 'कंधे', 'घुटने' हमेशा 'पैर की उंगलियों', आदि द्वारा पीछा किया जाता है।

इसलिए, हम निम्नलिखित सूचकांक का उपयोग कर सकते हैं:

00: [ 'knees', 'toes' ]
01: [ 'head', 'shoulders' ]
10: [ 'eyes', 'ears' ]
11: [ 'mouth', 'nose' ]

और निम्नलिखित बाइनरी मास्क में पूरे अनुक्रम (रिवर्स ऑर्डर में) को संपीड़ित करें:

00 00 01 11 10 00 00 01 00 00 01

हम [ 'knees', 'toes' ]संभव के रूप में कई अग्रणी शून्य पाने के लिए पहली जोड़ी के रूप में उपयोग करते हैं।

हम इस अनुक्रम को एक अतिरिक्त के साथ पैड करते हैं 0ताकि निकाले गए मान को 2 से प्रीमियर किया जा सके, जो इस प्रकार है:

0b00000111100000010000010 = 245890

इसलिए सही शब्द के लिए अंतिम सूत्र:

(245890 >> (n % 22 & ~1)) & 6 | n % 2

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

n=>'knees,toes,head,shoulders,eyes,ears,mouth,nose'.split`,`[(245890>>(n%22&~1))&6|n%2]

console.log(f(0));    // head
console.log(f(1));    // shoulders
console.log(f(7));    // shoulders
console.log(f(13));   // ears
console.log(f(20));   // knees
console.log(f(35));   // ears
console.log(f(37));   // nose
console.log(f(98));   // knees
console.log(f(543));  // nose
console.log(f(1000)); // knees

स्निपेट का विस्तार करें

— Arnauld
स्रोत

10

अजगर 2, 158 148 137 128 114 109 104 बाइट्स

लुकअप टेबल बेहतर लगती है। इसके अलावा बड़े स्ट्रिंग को छोटा किया और आइटम को फिर से व्यवस्थित किया। एक सूची के रूप में स्ट्रिंग का उपयोग करने के लिए -5 बाइट्स रॉड का धन्यवाद।

c=int('602323'*2+'4517602323'[input()%22])
print"smkteehnhonoyaeooueeerasutesssdelhs"[c::8]+"ders"*(c<1)

प्रारंभिक समाधान:

n=input()%22
n-=10*(n>15)
if n>=12:n-=8
else:n%=6;n-=2*(n>3)
print"hskteemnehnoyaooaoeeerusduessste ls   h  d       e       r       s"[n::8].strip()

— कार्ल नेफ
स्रोत

1

बहुत ही मूल उत्तर! +1। लेकिन, उम्म ..., अधिकांश उत्तर जो पूर्ण तारों का उपयोग करते हैं, वे इससे छोटे हैं। फिर भी, मुझे यह पसंद है कि स्ट्रिंग्स में किसी तरह का पैटर्न देखने के लिए आपने जो खर्च उठाया है! उसके लिए चपेउ।

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

मुझे लगता है कि आप इस स्ट्रिंग को बनाकर इस कंधे को बना सकते हैं: hskteemnehnoyaooaoeeerusduessste ls h dऔर फिर 'ers' को जोड़ना अगर आपको पता है कि शब्द 'कंधे' माना जाता है :)

— Kade

1

आप बस का उपयोग c=int('602323'*2+'4517602323'[input()%22])और ड्रॉप कर सकते हैं hसी:

— रॉड

1

[i%22]पहले [input()%22]पर, दूसरे पर

— रॉड

1

@ रो आह, अगर आप अपने कोड को लंबे समय तक देखते हैं तो आप अंधे हो जाते हैं।

— कार्ल नैप

6

पर्ल, 74 बाइट्स

के लिए 73 बाइट्स कोड + 1 -p।

$_=(@a=(head,shoulders,(knees,toes)x2),@a,eyes,ears,mouth,nose,@a)[$_%22]

0-आधारित अनुक्रमण का उपयोग करता है। एक विभाजक उत्पादन नहीं करता है, लेकिन यह -lझंडे में संशोधन किया जा सकता है ।

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

— डोम हेस्टिंग्स
स्रोत

आप x2)x2इसके बजाय 1 बाइट बचा सकते हैंx2),@a

— एडम

4

पायथन 2, 97 90 बाइट्स

कुछ गणित हो सकता है जो इसे बनाता है इसलिए मुझे शब्द सूची बनाने की ज़रूरत नहीं है, लेकिन यह अभी के लिए काम करता है!

lambda n,k='head shoulders '+'knees toes '*2:(k*2+'eyes ears mouth nose '+k).split()[n%22]

^{7 बाइट बचाने के लिए Flp.Tkc का धन्यवाद :)}

— Kade
स्रोत

1

मुझे एक समान समाधान मिला, लेकिन split()इसे छोटा बनाने के लिए इस्तेमाल किया गया:k='head shoulders '+'knees toes '*2 print(k*2+'eyes ears mouth nose'+k).split()[input()%22]

— फ्लिपकैक

क्षमा करें, वहाँ 'नाक' के बाद एक जगह होनी चाहिए :)

— 14

@ Flp.Tkc हाँ मुझे एहसास हुआ कि :) एक सेकंड में अपडेट!

— Kade

4

जावा 7, 155 137 131 123 111 110 बाइट्स

String c(int i){return"knees,toes,head,shoulders,eyes,ears,mouth,nose".split(",")[(245890>>(i%22&~1))&6|i%2];}

-12 बाइट्स @ @ नील को धन्यवाद ।
-1 बाइट से बेशर्मी से @Arnauld का अद्भुत उत्तर ।

जावा 0-अनुक्रमित है, इसलिए मैंने इसका उपयोग किया है।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

class M{
  static String c(int i){
    return "knees,toes,head,shoulders,eyes,ears,mouth,nose".split(",")
      [(245890>>(i%22&~1))&6|i%2];
  }

  public static void main(String[] a){
    System.out.println(c(0));
    System.out.println(c(1));
    System.out.println(c(7));
    System.out.println(c(13));
    System.out.println(c(20));
    System.out.println(c(35));
    System.out.println(c(37));
    System.out.println(c(98));
    System.out.println(c(543));
    System.out.println(c(1000));
  }
}

आउटपुट:

head
shoulders
shoulders
ears
knees
nose
ears
knees
nose
knees

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

1

String c(int i){return "head,shoulders,knees,toes,knees,toes,eyes,ears,mouth,nose".split(",")[(i+16)%22%16%10];}केवल 112 बाइट्स है।

— नील

यदि आप टिप्पणी से प्रतिलिपि बनाने की कोशिश करते हैं तो आपको स्टैक एक्सचेंज के सौजन्य से कुछ अतिरिक्त अदृश्य बाइट्स मिलते हैं।

— नील

@ नील ओके, मैं एक बेवकूफ हूं .. कोई विचार नहीं है कि मैंने कल देर शाम को कैसे 120 की गिनती की है .. शायद बहुत देर हो चुकी थी ..>>> वैसे भी, मैंने इसे संपादित किया है (प्लस 1 अतिरिक्त बाइट को हटाकर। अंतरिक्ष), इसलिए धन्यवाद!

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

3

सी, 153 बाइट्स 141 बाइट्स

*b[]={"head","shoulders","knees","toes","eyes","ears","mouth","nose"};i;char*g(a){a%=22;i=(a+4)%10;return b[a<4?a:(a&12)>8?a-8:i<2?i:a%2+2];}

4 बाइट्स के लिए @cleblanc को धन्यवाद। विश्व स्तर पर बी की घोषणा इंट के लिए कास्टिंग के बारे में चेतावनियों की एक टन फेंकता है, लेकिन मेरे लिए नहीं टूटा।

Ungolfed:

*b[]={"head","shoulders","knees","toes","eyes","ears","mouth","nose"};
i;
char* g(a) {
    a%=22;
    i=(a+4)%10;
    return b[a < 4        ? a
            :(a & 12) > 8 ? a-8
            :i < 2        ? i
            :               a % 2 + 2];
}

यह सबसे छोटा जवाब नहीं है, लेकिन मुझे तकनीक पसंद है, और कुछ पैटर्न खोजने में मज़ा आया।

बदलाव का:

(4 बाइट्स) bसे बचने के लिए वैश्विक स्तर पर चले गएchar
a > 11 && a < 16=> (a & 12) > 8(2 बाइट्स)
i=(a-6)%10=> i=(a+4)%10ताकि i < 2 && i >= 0= = i < 2(6 बाइट्स)

— nmjcman101
स्रोत

1

आप इसे थोड़ा और नीचे गोल्फ कर सकते हैं। B [] को एक वैश्विक दायरे में ले जाकर इसे इस तरह से char * का उपयोग किए बिना घोषित किया जा सकता है *b[]={"head","shoulders","knees","toes","eyes","ears","mouth","nose"},i'और फिर रिटर्न b [...] को एक पुट (b [...]) से बदलकर आप इसे 143 बाइट्स तक ले जा सकते हैं

— 14

+1 और @cleblanc के सुझाव के अलावा , आप दोनों &&को बदल भी सकते हैं &।

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

मुझे उत्सुकता है कि विश्व स्तर पर कामों की घोषणा करने के बारे में @cleblanc कैसे सुझाव देता है। संकलक ने मुझे बताया कि यह एक * int [] होगा, और मुझे लगा कि आकार अंतर कोड को तोड़ देगा। हालांकि यह नहीं था, इसलिए धन्यवाद!

— nmjcman101

2

जावास्क्रिप्ट (ईएस 6) 91 89 बाइट्स

f=
n=>((d='head:shoulders:'+(b='knees:toes:')+b)+d+'eyes:ears:mouth:nose:'+d).split`:`[n%22]

console.log(f.toString().length)
console.log(f(0) === 'head')
console.log(f(1) === 'shoulders')
console.log(f(7) === 'shoulders')
console.log(f(13) === 'ears')
console.log(f(20) === 'knees')
console.log(f(35) === 'ears')
console.log(f(37) === 'nose')
console.log(f(98) === 'knees')
console.log(f(543) === 'nose')
console.log(f(1000) === 'knees')

स्निपेट का विस्तार करें

— Lmis
स्रोत

1

अच्छा! +1। जब मैं आपके उत्तर को जावा 7 में पोर्ट करता हूं तो यह @ अरनुल्द के पहले से छोटे-से-मेरे जवाब की तुलना में एक ठोस -7 बाइट्स है। ;) धन्यवाद!

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

1

मैं के अपने उपयोग के साथ रचनात्मक किया जा रहा द्वारा एक बाइट बचाया %: n=>`head:shoulders:knees:toes:knees:toes:eyes:ears:mouth:nose`.split`:`[(n+16)%22%16%10]।

— नील

2

आर, 95 बाइट्स

c(o<-c("head","shoulders",y<-c("knees","toes"),y),o,"eyes","ears","mouth","nose",o)[scan()%%22]

लुकअप टेबल के रूप में कार्य करने के लिए एक वर्ण वेक्टर बनाता है। स्टडिन से इनपुट लेता है ( 1-indexed) और %%22संबंधित बॉडी पार्ट को खोजने के लिए।

बोनस: %%सदिशीकृत है जिसका अर्थ है कि यह एक वेक्टर इनपुट के साथ भी काम करेगा।

आर-फिडल पर परीक्षण के मामले (ध्यान दें कि यह एक नामित फ़ंक्शन है क्योंकि scanआर-फ़िडल पर काम नहीं करता है)

— Billywob
स्रोत

2

jq, 80 अक्षर

(77 वर्ण कोड + 3 वर्ण कमांड लाइन विकल्प)

((("head shoulders "+"knees toes "*2)*2+"eyes ears mouth nose ")*2/" ")[.%22]

नमूना रन:

bash-4.3$ jq -r '((("head shoulders "+"knees toes "*2)*2+"eyes ears mouth nose ")*2/" ")[.%22]' <<< 1000
knees

ऑन-लाइन परीक्षण ( -rURL से गुजरना समर्थित नहीं है - स्वयं रॉ आउटपुट की जाँच करें।)

— आदमी काम पर है
स्रोत

2

WinDbg, 207 157 151 बाइट्स

ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41

-50 बाइट्स के रूप में शरीर के अंगों की ऑफसेट / लंबाई को एन्सिसी चर के रूप में एन्कोडिंग करके।

जब ऑफसेट / लंबाई की तलाश में एक स्थानीय संस्करण का उपयोग करके -6 बाइट्स।

इनपुट छद्म रजिस्टर में निर्धारित मूल्य के साथ किया जाता है $t0।

यह काम किस प्रकार करता है:

* Initialization, writes this string at address 0x2000000. The nonsense after the body parts
* are the offsets and lengths of the body parts in the first part of the string, each of
* which is incremented by 0x41 to make it a printable ascii character.
ea 2000000 
        "headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";


* Display the output:
r$t4=(@$t0%16)*2+2000027
da1FFFFBF+by(@$t4) Lby(@$t4+1)-41

* Display output explanation:
r $t4 = (@$t0%16)*2+2000027   * Set $t4 = input, @$t0, mod 22, doubled +0x2000027
by(@$t4)                      * byte_at(@$t4)-0x41 is the {Offset} into the string 
                              * for the start of output. The -0x41 is already subtracted
                              * from 0x2000000 to make 0x1FFFFBF.
Lby(@$t4+1)-41                * byte_at(@$t4+1)-0x41 is the {Length} of the output.
da 1FFFFBF+{Offset} L{Length} * Display {Length} chars from {Offset} of the above string.

नमूना उत्पादन:

0:000> r$t0=0
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
02000000  "head"


0:000> r$t0=1
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
02000004  "shoulders"


0:000> r$t0=7
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
02000004  "shoulders"


0:000> r$t0=0n13
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
0200001a  "ears"


0:000> r$t0=0n20
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
0200000d  "knees"


0:000> r$t0=0n35
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
0200001a  "ears"


0:000> r$t0=0n37
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
02000023  "nose"


0:000> r$t0=0n98
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
0200000d  "knees"


0:000> r$t0=0n543
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
02000023  "nose"


0:000> r$t0=0n1000
0:000> ea2000000"headshoulderskneestoeseyesearsmouthnoseAEEJNFSENFSEAEEJNFSENFSEWE[E_FdEAEEJNFSENF";r$t4=(@$t0%16)*2+2000027;da1FFFFBF+by(@$t4) Lby(@$t4+1)-41
0200000d  "knees"

— दूध
स्रोत

2

PHP, 91 102 118 128 129 बाइट्स

<?=[head,shoulders,knees,toes,eyes,ears,mouth,nose]['0123230123234567012323'[$argv[1]%22]];

0-इंडेक्स्ड

91 से नीचे str_split को हटाने के बाद, एहसास नहीं हुआ कि PHP स्ट्रिंग एक चार सरणी (PHP 5+ चीज़) के रूप में सुलभ है?

102 से नीचे स्ट्रिंग उद्धरण को हटाने और नोटिस की अनुमति देने के लिए सम्मिलित करें सुझाव के लिए धन्यवाद

— CT14.IT
स्रोत

-16 बाइट्स:' शब्दों को चारों ओर से हटा दें , जैसे 'head'बन जाता है headइत्यादि

— प्रविष्टि 15:17

यह निश्चित नहीं है कि नियम इसके साथ क्या हैं, लेकिन एक डिफ़ॉल्ट PHP इंस्टॉल के साथ, मुझे ऐसा करने पर अपेक्षित अपरिभाषित निरंतर चेतावनी

— मिलती

1

हां, लेकिन साइट के नियमों के साथ यह बिल्कुल ठीक है। नोटिस और चेतावनियों को नजरअंदाज किया जा सकता है।

— सम्मिलित

@ CT14.IT, जो चेतावनी नहीं है, एक सूचना है। "PHP 5.3 या बाद में, डिफ़ॉल्ट मान E_ALL और ~ E_NOTICE & ~ E_STRICT & ~ E_DEPRECated है। यह सेटिंग E_NOTICE, E_STRICT और E_DEPRECATED स्तर की त्रुटियों को नहीं दिखाता है। ”- PHP प्रलेखन के बारे मेंerror_reporting ।

— मैनटवर्क

1

ऐसा लगता है कि str_split () बेकार है

— Crypto

1

जेली , 55 बाइट्स

“¥ḷne“¥ṇṭḲ»ẋ2ṭ“¢1$“@⁼5⁼»µẋ2;“¥ḳVo“¥ḳ'k“£Qo“£³ạ»;⁸FḊḲ
ị¢

इसे ऑनलाइन आज़माएं! (1-आधारित सूचकांक)

आओ! वास्तव में?

एक बोनस के रूप में, यह संकुचित लाइन है जिसे मैं शीर्ष पंक्ति के बजाय उपयोग करने वाला था:

“¡¦ṡb[wfe=⁺żɦ4Gƈġhḳ"ẇ⁴ż>oH¹8ṡʠʠḟṀUṿḶ>¬Þ:ĖẇrṗṁɼlDṫỤ¬ȷ⁶Dḥci*⁻³GḲOÞạṖṃ\»

दोनों इस स्ट्रिंग को एनकोड करते हैं:

head shoulders knees toes knees toes head shoulders knees toes knees toes eyes ears mouth nose head shoulders knees toes knees toes

मुझे लगता है कि मुझे अब व्यायाम करना चाहिए: पी

— आउटगोल्फर को एरिक करें
स्रोत

1

पॉवर्सशेल, 91 बाइट्स, ज़ीरो-इंडेक्सेड

$a='head shoulders '+'knees toes '*2;($a*2+'eyes ears mouth nose '+$a).Split()[$args[0]%22]

बहुत सीधा दृष्टिकोण, कुछ स्ट्रिंग गुणन का उपयोग करके पहले 22 वस्तुओं की सरणी उत्पन्न करता है, जहां संभव हो, उन्हें रिक्त स्थान के साथ संकलित करके और अंत में विभाजित करके। (बंटवारे 2 बाइट्स को एक सेटअप के रूप में एक सरणी के बराबर छोटा होता है) तो इनपुट के मापांक का उपयोग करके उस सरणी में बस बिंदु खोजें, बिल्कुल दिलचस्प या भाषा-विशेष नहीं।

परीक्षण का मामला:

PS C:\++\golf> 0..1000|%{.\hskt $_}
head
shoulders
knees
toes
knees
toes
head
shoulders
knees
toes
knees
toes
eyes
ears
mouth
nose
head
shoulders
knees
toes
knees
toes
head
shoulders
knees
toes
....

आदि।

— colsw
स्रोत

1

रूबी, 81 बाइट्स

शून्य अनुक्रमण का उपयोग करते हुए लैम्बडा फ़ंक्शन

->n{("head shoulders#{" knees toes "*2}eyes ears mouth nose".split*2)[n%22-6&15]}

व्याख्या

हम निम्नलिखित सरणी उत्पन्न करते हैं, जिनमें से हम पहले 16 तत्वों का उपयोग करते हैं, गीत की सही लाइनों 2,3,4 को कवर करते हैं:

%w{head shoulders knees toes knees toes
   eyes ears mouth nose
   head shoulders knees toes knees toes

   eyes ears mouth nose}                  #last 4 elements not used

हम इसे एक एकल कविता को कम करने के लिए n मोडुलो 22 लेते हैं, फिर हम 6. घटाते हैं। अब सूचकांक 6 (उदाहरण के लिए) को 0 में बदल दिया गया है और सही शब्द को इंगित करता है। इंद्रियां 0..5 जो गीत की पहली पंक्ति को इंगित करती हैं, अब नकारात्मक हैं। हम गीत की पहली पंक्ति को 4 वीं पंक्ति में मैप करने के लिए &15(समान %16लेकिन कोष्ठक की आवश्यकता से बचते हैं) का उपयोग करते हैं। इस प्रकार सूचकांक 0-> -6->10

परीक्षण कार्यक्रम में

f=->n{("head shoulders#{" knees toes "*2}eyes ears mouth nose".split*2)[n%22-6&15]}

#call as below to test index 0..43
44.times{|i|p f[i]}

— स्तर नदी सेंट
स्रोत

दिलचस्प सूचकांक सूत्र। लेकिन इसके बिना एक ही लंबाई हासिल की जा सकती है:->n{(((%w{head shoulders}+%w{knees toes}*2)*2+%w{eyes ears mouth nose})*2)[n%22]}

— मैनटवर्क

1

Befunge, 129 119 बाइट्स

0 अनुक्रमित

&29+2*%:2/v>00p>%#7_v
+%2\-"/"g2<|<:-1g007<"head*shoulders*knees*toes*eyes*ears*mouth*nose"p00
02202246022>$$:>7#:%#,_@

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

व्याख्या

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

&29+2*%               n = getint() % 22             // % 22 to ensure it's in range
:2/2g                 i = index_array[n/2]          // we use n/2 because words are paired
-"/"                  i -= '/'                      // convert from ASCII to 1-based value
\2%+                  i += n%2                      // get the correct word in the pair
00p                   index = i                     // save for later

"head*shoulders*knees*toes*eyes*ears*mouth*nose"    // push all the words onto the stack

700g1-:|              while (index-1 != 0) {        // the 7 is used in the drop loop   
  00p                   index = index-1             
  >%#7_                 do while (pop() % 7)        // drop up to the next '*' (%7==0)
                      }                    

$$                    pop();pop()                   // get rid of index and extra 7

: 7 % _               while ((c = pop()) % 7)       // output up to the next '*' (%7==0)
 > : ,                  putchar(c)

— जेम्स होल्डरनेस
स्रोत

1

SQL 2005 747 बाइट्स

golfed:

GO
CREATE PROCEDURE H @n INT AS BEGIN IF NOT EXISTS(SELECT*FROM R)BEGIN INSERT INTO R VALUES('head')INSERT INTO R VALUES('shoulders')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('head')INSERT INTO R VALUES('shoulders')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('eyes')INSERT INTO R VALUES('ears')INSERT INTO R VALUES('mouth')INSERT INTO R VALUES('nose')INSERT INTO R VALUES('head')INSERT INTO R VALUES('shoulders')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')END SELECT W FROM R WHERE I=@n%22 END

Ungolfed:

GO
CREATE PROCEDURE H
@n INT 
AS 
BEGIN IF NOT EXISTS(SELECT*FROM R)
BEGIN 
INSERT INTO R VALUES('head')INSERT INTO R VALUES('shoulders')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('head')INSERT INTO R VALUES('shoulders')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('eyes')INSERT INTO R VALUES('ears')INSERT INTO R VALUES('mouth')INSERT INTO R VALUES('nose')INSERT INTO R VALUES('head')INSERT INTO R VALUES('shoulders')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')INSERT INTO R VALUES('knees')INSERT INTO R VALUES('toes')
END 
SELECT W FROM R WHERE I=@n%22 END

इस तरह एक तालिका की जरूरत है, जहां पहला कॉलम ऑटो-इंक्रीज किया गया हो:

यह एक-अनुक्रमित उत्तर है। पहली बार संग्रहीत प्रक्रिया बनाई गई तालिका पॉपुलेटेड है - यह मुझे INSERTएक बयान में सभी नहीं करने देगा , निराशाजनक रूप से, यह सुविधा केवल में उपलब्ध है >=SQL 2008। इसके बाद, यह %22अन्य उत्तरों से चाल का उपयोग करता है। एक बार तालिका पॉपुलेट हो जाने के बाद, यह केवल अंतिम भाग का उपयोग करती है:

SELECT W FROM R WHERE I=@n%22

Input:  Output:
R 1       head
R 2       shoulders
R 8       shoulders
R 14      ears
R 21      knees
R 36      ears
R 38      nose
R 99      knees
R 54      nose
R 1001    knees

— पीट आर्डेन
स्रोत

" यह मुझे एक बयान में सभी INSERT नहीं करने देगा " क्यों? कुछ नहीं करना चाहिए इस तरह 2008 के बाद एसक्यूएल में संभव हो सकता है?

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

@KevinCruijssen मैं SQL Server 2008 R2 का उपयोग कर रहा हूं, इसलिए यह अजीब है ... मैंने अभी कुछ और Googling किया है, जाहिर है यह डेटाबेस के "संगतता स्तर" के साथ कुछ करना है, जिसे मैंने अभी-अभी कोशिश की है और विफल रहा है बदलने के लिए - यह 2005 के लिए सेट है और यह अधिकतम मूल्य है, इसलिए इसे यह सुविधा नहीं मिली है। क्या मुझे अपने उत्तर में SQL संस्करण निर्दिष्ट करना चाहिए, या यदि यह ठीक से छोटा नहीं किया जा सकता है, तो उत्तर को हटा दें? के रूप में मुझे बहुत पाठ बचा होगा ...

— पीट आर्डेन

या तो मेरे द्वारा ठीक है, इसलिए यह आपकी कॉल है। मैं व्यक्तिगत रूप से जावा 7 में आमतौर पर गोल्फ करता हूं, जिसे मैं निर्दिष्ट करता हूं, क्योंकि ज्यादातर मामलों में जावा 8 में छोटे उत्तर उपलब्ध हैं। आप इसे 2005 में उसी तरह से निर्दिष्ट कर सकते हैं।

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

@KevinCruijssen हाँ, मैंने लोगों को जावा और पायथन के लिए ऐसा करते देखा है। वास्तव में कोड का परीक्षण करने में सक्षम होने के बिना परिवर्तन करना पसंद नहीं करेंगे, इसलिए मैं 2005 को निर्दिष्ट करूंगा, चीयर्स :)

— पीट आर्डेन

1

बैश (एड के साथ), 83 वर्ण

1 अनुक्रमित

ed<<<"a
head
shoulders
knees
toes
eyes
ears
mouth
nose
.
3,4t4
1,6y
6x
$(($1%22))"

नमूना कॉल:

 $ bash test.sh 1001
 knees

— एडम
स्रोत

1

डीसी , 135 बाइट्स

6[head]6[:add6-r;ar:adA+r;ar:a]dshx7[shoulders]7lhx8[knees]8lhxA 2;aAlhx9[toes]9lhxB 3;aBlhx[eyes]C:a[ears]D:a[mouth]E:a[nose]F:a22%;ap

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

में सरणी dcहै एक समय में एक तत्व है, जो इस अभ्यास का खामियाजा लेता करा सकते हैं। चूंकि 'आंखें', 'कान', 'मुंह' और 'नाक' केवल एक बार हमारे एरे में दिखाई देते हैं, इसलिए हम उन्हें बस पॉप करते हैं। लेकिन दूसरों के लिए, हम कुछ बाइट्स को स्टैक पर रख कर बचाते हैं x[head]x, जैसे कि एक्स। इसके तीन मानों के बीच में है, फिर हम [:add6-r;ar:adA+r;ar:a]dshxइसे सरणी में रखने के लिए मैक्रो चलाते हैं , इसे वापस खींचते हैं, इसे समान मूल्य पर कम छह में डालते हैं, इसे वापस खींचते हैं, और फिर मूल मूल्य पर एक अंतिम समय में डालते हैं प्लस दस। हम मध्य मान का उपयोग करते हैं क्योंकि dcहमें दशमलव मोड में भी हेक्स अंकों का उपयोग करने की अनुमति देता है, और घटाना Aजोड़ने की तुलना में एक कम बाइट है16- यह भी केवल इसलिए काम करता है क्योंकि सभी मध्य मान पंद्रह से कम हैं। हमें घुटनों और पैर की उंगलियों को दो बार करना पड़ता है, और हमारे मैक्रो को यह छाँटने के लिए पर्याप्त स्मार्ट बनाना है कि केवल मैक्रो को दो बार चलाने की तुलना में अधिक महंगा है; लेकिन हम इसे फिर से लिखने के बजाय स्ट्रिंग की एक पूर्व संग्रहीत प्रति लोड करके यहाँ बाइट्स बचाते हैं ( B 3;aBबनाम B[toes]B- मुझे लगता है कि यह कुल 3 बाइट्स बचाता है)।

एक बार जब हम सरणी का निर्माण कर लेते हैं, तो हमें केवल इतना करना होता है 22%और फिर ;apइसे सरणी से खींचना और प्रिंट करना होता है।

— brhfl
स्रोत

0

सी # 6, 138 बाइट्स

string F(int i)=>(i+10)%22<4?"eyes,ears,mouth,nose".Split(',')[(i+10)%22%4]:"head,shoulders,knees,toes,knees,toes".Split(',')[(i+6)%22%6];

repl.it डेमो

Ungolfed + टिप्पणियाँ:

string F(int i)=>
    // Is it eyes/ears/mouth/nose?
    (i+10)%22<4
        // If yes, then set index to 4-word line and take modular 4
        // String array constructed by splitting comma-delimited words
        ? "eyes,ears,mouth,nose".Split(',')
            [(i+10)%22%4]
        // Else set index to last 6-word line and take modular 6
        : "head,shoulders,knees,toes,knees,toes".Split(',')
            [(i+6)%22%6];

— लिंक एनजी
स्रोत

आप स्ट्रिंग को जोड़ सकते हैं और एक एकल का उपयोग कर सकते हैं Split, और ?:वर्ग-कोष्ठक ( +4दूसरे भाग के लिए ) के अंदर टर्नरी ( ) के समान अपनी जांच कर सकते हैं , इस तरह:

string F(int i)=>"eyes,ears,mouth,nose,head,shoulders,knees,toes,knees,toes".Split(',')[(i+10)%22<4?(i+10)%22%4:(i+6)%22%6+4];

( 126 बाइट्स )

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

0

एक्सेल, 146 बाइट्स

=MID("Head     ShouldersKnees    Toes     Eyes     Ears     Mouth    Nose",CHOOSE(MOD(MOD(MOD(B1+16,22),16),10)+1,1,10,19,28,19,28,37,46,55,64),9)

बाइट MOD(MOD(MOD(B1+16,22),16),10)बचाने के लिए @ नील का उपयोग करता है 15।

— Wernisch
स्रोत

सिर, कंधे, घुटने और पैर, घुटने और पैर की उंगलियां

परिचय:

चुनौती:

चुनौती नियम:

सामान्य नियम:

परीक्षण के मामले (0-अनुक्रमित):

05AB1E , 36 35 34 बाइट्स

जावास्क्रिप्ट (ईएस 6), 91 88 87 बाइट्स

यह काम किस प्रकार करता है

परीक्षण के मामलों

अजगर 2, 158 148 137 128 114 109 104 बाइट्स

पर्ल, 74 बाइट्स

पायथन 2, 97 90 बाइट्स

जावा 7, 155 137 131 123 111 110 बाइट्स

सी, 153 बाइट्स 141 बाइट्स

जावास्क्रिप्ट (ईएस 6) 91 89 बाइट्स

आर, 95 बाइट्स

jq, 80 अक्षर

WinDbg, 207 157 151 बाइट्स

PHP, 91 102 118 128 129 बाइट्स

जेली , 55 बाइट्स

पॉवर्सशेल, 91 बाइट्स, ज़ीरो-इंडेक्सेड

रूबी, 81 बाइट्स

Befunge, 129 119 बाइट्स

SQL 2005 747 बाइट्स

बैश (एड के साथ), 83 वर्ण

डीसी , 135 बाइट्स

सी # 6, 138 बाइट्स

एक्सेल, 146 बाइट्स