소개:

나는 우리 모두가 그것을 알고 있다고 생각하며 아마도 "머리, 어깨, 무릎 및 발가락"어린이 노래의 많은 다른 언어로 번역되었을 것입니다.

머리, 어깨, 무릎 및 발가락, 무릎 및 발가락
머리, 어깨, 무릎 및 발가락, 무릎 및 발가락
및 눈 및 귀 및 입 및 코
머리, 어깨, 무릎 및 발가락, 무릎 및 발가락
Wikipedia

도전:

입력 : 양의 정수.

출력 : 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 개 이상의 입력을 지원해야합니다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 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

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- 인덱싱)을 사용하여 색인을 생성합니다.

자바 스크립트 (ES6), 91 88 87 바이트

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

작동 원리

'head'는 항상 'shoulders', 'knees'는 항상 'toes'등과 같이 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을 얻기 위해 첫 번째 쌍으로 사용합니다.

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

파이썬 2 158 148 137 128 114 109 104 바이트

조회 테이블이 더 좋아 보입니다. 또한 큰 줄을 줄이고 항목을 다시 정렬했습니다. 문자열을 목록으로 사용하는 Rod 덕분에 -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()

펄, 74 바이트

73 바이트 코드 + 1 -p.

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

0 기반 인덱싱을 사용합니다. 구분 기호를 출력하지 않지만 -l플래그를 사용하여 수정할 수 있습니다 .

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

파이썬 2, 97 90 바이트

단어 목록을 만들 필요가없는 수학이있을 수 있지만 지금은 작동합니다!

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

^{7 바이트를 절약 해 준 Flp.Tkc에게 감사합니다 :)}

자바 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 덕분에 바이트 @Neil . @Arnauld 의 놀라운 답변
포트를 뻔뻔스럽게 만들어 -1 바이트 .

Java는 0 색인화되어 있으므로 내가 사용한 것입니다.

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

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

C, 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에게 감사합니다. b를 전역 적으로 선언하면 int로 캐스팅하는 것에 대해 많은 경고가 발생하지만 나에게 도움이되지 않았습니다.

언 골프 드 :

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

가장 작은 대답은 아니지만 기술을 좋아하고 몇 가지 패턴을 찾는 것이 재미있었습니다.

변경 로그:

• b피하기 위해 전역으로 이동 했습니다 char(4 바이트)
• a > 11 && a < 16=> (a & 12) > 8(2 바이트)
• i=(a-6)%10=> i=(a+4)%10그래서 i < 2 && i >= 0=> i < 2(6 바이트)

자바 스크립트 (ES6) 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')

R, 95 바이트

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

조회 테이블로 기능 할 문자형 벡터를 만듭니다. stdin ( 1-indexed) 에서 입력을 %%22받아 해당 본문 부분을 찾습니다.

보너스 : %%벡터화되어 벡터 입력에서도 작동합니다.

R-fiddle에 대한 테스트 사례 ( R-fiddlescan 에서는 작동하지 않으므로 이름이 지정된 함수 임)

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을 통한 전달 은 지원되지 않습니다 – 직접 출력 확인)

WinDbg는, 207 (157) 151 바이트

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

본문 부분의 오프셋 / 길이를 ASCII 문자로 인코딩하여 -50 바이트

오프셋 / 길이를 찾을 때 로컬 var를 사용하여 -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"

PHP 91 102 118 128 129 바이트

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

0 인덱스

str_split을 제거한 후 91까지, PHP 문자열이 char 배열 (PHP 5 이상)에 액세스 할 수 있다는 것을 알지 못했습니다.

문자열 인용 부호를 제거하고 통지를 허용하는 insertusername 제안 덕분에 102까지 감소

젤리 , 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

내가 지금 운동하러 가야 할 것 같아 : P

Powershell, 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
....

기타

루비, 81 바이트

제로 인덱싱을 사용하는 Lambda 함수.

->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을 뺍니다. 이제 인덱스 6 (예 :)이 0으로 바뀌고 올바른 단어를 가리 킵니다. 노래의 첫 줄을 가리키는 지표 0..5는 이제 음수입니다. 우리는 사용 &15(동일을 %16하지만 괄호에 대한 필요성을 피할 수) 4 선에 노래의 1 라인을 매핑 할 수 있습니다. 따라서 색인 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]}

일러스트레이션, 129 119 바이트

0 인덱스

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

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

설명

으로 Arnauld는 지적 우리가 11 값의 인덱스가 다음 쌍에서 해당 단어를 얻기 위해 단어를 번호 % 2를 추가 할 수 있도록, 단어, 쌍으로. 공간을 절약하기 위해 단어는 별표로 구분 된 단일 문자열로 스택에 푸시됩니다. 별표 만 7의 배수이므로 char 값 modulo 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)

SQL 2005 747 바이트

골프 :

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

언 골프 드 :

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

bash (에디 포함), 83 자

1- 색인

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

샘플 통화 :

 $ bash test.sh 1001
 knees

dc , 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하는 경우, X 세 값의 중간입니다. 그런 다음 매크로 [:add6-r;ar:adA+r;ar:a]dshx를 실행하여 배열에 넣고, 뒤로 당기고, 같은 값으로 6보다 작은 곳에 넣고 뒤로 당기고 원래 값으로 한 번에 넣습니다. 플러스 10 우리 dc는 십진수 모드에서도 16 진수를 사용할 수 있기 때문에 중간 값 을 사용하고 빼는 A것은 더하기 보다 1 바이트 적습니다.16-이것은 또한 중간 값이 모두 15 미만이므로 작동합니다. 우리는 무릎과 발가락을 두 번해야하고 매크로를 두 번 실행하는 것보다 비싸다는 점에서 매크로를 똑똑하게 만들어야합니다. 그러나 우리는 이전에 저장된 문자열을 다시 쓰지 않고로드하여 바이트를 저장합니다 ( B 3;aB대 B[toes]B-총 3 바이트를 절약한다고 생각합니다).

어레이를 구축 22%한 후에 ;ap는 어레이에서 가져와 인쇄하기 만하면됩니다.

C # 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 데모

언 골프 + 댓글 :

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

엑셀, 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)

@Neil을 사용 MOD(MOD(MOD(B1+16,22),16),10)하여 15바이트 를 저장 합니다.