피사의 레오나르도 (약 1175-약 1245)는 피보나치 로 더 잘 알려져 있습니다 . 그러나 이것은 실제로 위키피디아 에 따르면 18 세기에 만들어진 라틴어 "필 리우스 보나 치"(보나 치의 아들)의 줄임말입니다 .

이 문제에서는 간 (문자 적 의미에서) 서수 주어질 것이다 1 일 및 20 일을 하고는에 대응하는 용어를 반환해야 피보나치 시퀀스 .

트위스트는 서 수가 라틴어로 주어질 것입니다.

예 : "duodecimus"→ .$89$

전체 I / O 테이블

 input              | meaning | output
--------------------+---------+--------
 "primus"           |   1st   |    0
 "secundus"         |   2nd   |    1
 "tertius"          |   3rd   |    1
 "quartus"          |   4th   |    2
 "quintus"          |   5th   |    3
 "sextus"           |   6th   |    5
 "septimus"         |   7th   |    8
 "octavus"          |   8th   |   13
 "nonus"            |   9th   |   21
 "decimus"          |  10th   |   34
 "undecimus"        |  11th   |   55
 "duodecimus"       |  12th   |   89
 "tertius decimus"  |  13th   |  144
 "quartus decimus"  |  14th   |  233
 "quintus decimus"  |  15th   |  377
 "sextus decimus"   |  16th   |  610
 "septimus decimus" |  17th   |  987
 "duodevicesimus"   |  18th   | 1597
 "undevicesimus"    |  19th   | 2584
 "vicesimus"        |  20th   | 4181

규칙

• 입력은 위에서 설명한 문자열 중 하나 여야 합니다 .
• 도움이되는 경우 대신 대문자를 사용하십시오. 그러나 모든 항목에 대해 일관성이 있어야합니다. 혼합 사례는 허용되지 않습니다.
• 알고리즘 및 언어에 따라 하드 코딩 또는 시퀀스의 용어가 바이트를이기거나 잃을 수 있습니다. 두 가지 방법 모두 명시 적으로 허용됩니다.
• 이것은 코드 골프입니다 !

R , 91 86 바이트

무차별 강제 UTF8 조회 테이블에서 바이트 합계의 색인을 찾아보고 마술 피보나치 생성 함수 를 사용하여 답을 찾으십시오 .

function(x)round(1.618^match(sum(!x)%%93,!'%(-1!5+3JOSCW6')*.2765)
"!"=utf8ToInt

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

편집 : 숫자 반올림을 개선하여 -2 바이트

편집 : 조회를 변경하여 -3 바이트 (힌트 감사합니다, @Giuseppe!)

루비, 104 93 바이트

->x{[8,4181,3,144,21,13,0,1,233,5,987,0,377,55,0,89,1,1597,34,610,0,2,2584][x.sum%192%76%23]}

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

바이트의 합, 모듈로 192 모듈로 76 모듈로 23을 간단히 찾아보기 테이블에 인덱스합니다. (무차별 대입 마법 수치가 발견되었습니다.)

클린 , 87 바이트

\n컴파일러는 실제 원시 값을 사용하기 때문에 예외를 제외한 모든 이스케이프 는 1 바이트로 처리됩니다. (TIO와 SE는 UTF-8이 유효하지 않은 문제가 있으므로 여기서 이스케이프 처리됩니다)

FryAmTheEggman는 멋진 시범 / 해결 방법을 만들어 : 여기

import StdEnv
$s=hd[i\\i<-k 1 0&c<-:"\340\152\060\065\071\354\172\045\223\n\255\362\132\137\143\026\244\051\344\270"|c==sum s]
k b a=[a:k(a+b)b]

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

$ :: [Char] -> Int대문자 문자 값의 합계에서 고유성을 사용하여 k반환 할 시퀀스 (도움말 함수에 의해 생성됨)의 용어를 결정하는 함수를 정의합니다 .

6502 머신 코드 (C64), 82 바이트

00 C0 20 9E AD 20 A3 B6 A8 88 A9 05 4A 90 02 49 B1 71 22 88 10 F6 29 1F C9 07
B0 02 69 0D A8 BE 32 C0 B9 1E C0 4C CD BD 00 00 00 00 03 00 0A 00 06 10 01 00
FF 00 02 00 00 00 00 00 08 00 15 0D DB 02 18 90 3D 55 79 05 FF E9 62 22 01 59
01 37 FF 03

이것은 물론 해싱을 사용하지만 6502에서의 짧은 구현에 최적화되어 있으며 시프트 및 추가로 사용되는 캐리 플래그를 활용합니다. 해싱을위한 마법의 숫자는 약간의 C 프로그램으로 무차별 강제 실행에 의해 발견되었다. FF바이트 해시 테이블 불행 구멍이다)

바이트 수 : 2 바이트로드 주소, 38 바이트 코드, 42 바이트 해시 테이블 값.

온라인 데모

사용법 : SYS49152"[ordinal]"예를 들어 SYS49152"DUODECIMUS". 기본 C64 구성에서는 문자가 대문자로 표시됩니다.

중요 사항 : 처음 시작하기 전에 NEW명령을 발행하십시오 . 이것은 C64 BASIC LOAD명령이 머신 프로그램을 절대 주소 (여기 $C000/ 와 같은 49152)로 로드 할 때에도 일부 BASIC 벡터와 함께 바이올린으로 보이기 때문에 필요합니다 .

주석 처리 된 분해 :

         00 C0                          ; load address
.C:c000  20 9E AD    JSR $AD9E          ; evaluate expression
.C:c003  20 A3 B6    JSR $B6A3          ; evaluate as string
.C:c006  A8          TAY                ; length to y register
.C:c007  88          DEY                ; decrement (start at last char)
.C:c008  A9 05       LDA #$05           ; start value for hash
.C:c00a   .hashloop:
.C:c00a  4A          LSR A              ; shift right
.C:c00b  90 02       BCC .skip          ; shifted bit zero? -> skip xor
.C:c00d  49 B1       EOR #$B1           ; xor "magic" value
.C:c00f   .skip:
.C:c00f  71 22       ADC ($22),Y        ; add current character (plus carry)
.C:c011  88          DEY                ; previous character
.C:c012  10 F6       BPL .hashloop      ; pos >= 0? -> repeat
.C:c014  29 1F       AND #$1F           ; mask lowest 5 bits
.C:c016  C9 07       CMP #$07           ; larger than 7 ?
.C:c018  B0 02       BCS .output        ; -> to output
.C:c01a  69 0D       ADC #$0D           ; add 13
.C:c01c   .output:
.C:c01c  A8          TAY                ; hash to y register
.C:c01d  BE 32 C0    LDX .lb-8,Y        ; load low byte from hashtable
.C:c020  B9 1E C0    LDA .hb-8,Y        ; load high byte from hashtable
.C:c023  4C CD BD    JMP $BDCD          ; to output of 16bit number
.C:c026   .hb:
.C:c026  00 00 00 00 .BYTE $00,$00,$00,$00
.C:c02a  03 00 0A 00 .BYTE $03,$00,$0A,$00
.C:c02e  06 10 01 00 .BYTE $06,$10,$01,$00
.C:c032  FF 00 02 00 .BYTE $FF,$00,$02,$00
.C:c036  00 00 00 00 .BYTE $00,$00,$00,$00
.C:c03a   .lb:
.C:c03a  08 00 15 0D .BYTE $08,$00,$15,$0D  ; second byte used in .hb as well
.C:c03e  DB 02 18 90 .BYTE $DB,$02,$18,$90
.C:c042  3D 55 79 05 .BYTE $3D,$55,$79,$05
.C:c046  FF E9 62 22 .BYTE $FF,$E9,$62,$22
.C:c04a  01 59 01 37 .BYTE $01,$59,$01,$37
.C:c04e  FF 03       .BYTE $FF,$03

C64 기본 V2 테스트 스위트

( DATA라인에 기계 프로그램 포함 )

온라인 데모

0fOa=49152to49231:rEb:pOa,b:nE
1?"primus",:sY49152"primus":?
2?"secundus",:sY49152"secundus":?
3?"tertius",:sY49152"tertius":?
4?"quartus",:sY49152"quartus":?
5?"quintus",:sY49152"quintus":?
6?"sextus",:sY49152"sextus":?
7?"septimus",:sY49152"septimus":?
8?"octavus",:sY49152"octavus":?
9?"nonus",:sY49152"nonus":?
10?"decimus",:sY49152"decimus":?
11?"undecimus",:sY49152"undecimus":?
12?"duodecimus",:sY49152"duodecimus":?
13?"tertius decimus",:sY49152"tertius decimus":?
14?"quartus decimus",:sY49152"quartus decimus":?
15?"quintus decimus",:sY49152"quintus decimus":?
16?"sextus decimus",:sY49152"sextus decimus":?
17?"septimus decimus",:sY49152"septimus decimus":?
18?"duodevicesimus",:sY49152"duodevicesimus":?
19?"undevicesimus",:sY49152"undevicesimus":?
20?"vicesimus",:sY49152"vicesimus":?
21dA32,158,173,32,163,182,168,136,169,5,74,144,2,73,177,113,34,136,16,246,41,31
22dA201,7,176,2,105,13,168,190,50,192,185,30,192,76,205,189,0,0,0,0,3,0,10,0,6
23dA16,1,0,255,0,2,0,0,0,0,0,8,0,21,13,219,2,24,144,61,85,121,5,255,233,98,34,1
24dA89,1,55,255,3

펄 6 , 62 바이트

{(0,1,*+*...*)[index '%(-1!5+3JOSCW6',chr .ords.sum%93]}

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

짧은 피보나치 시퀀스 생성기뿐만 아니라 문자열에서 찾아보기 테이블을 사용합니다.

C (GCC) , 135 (129) 바이트

ceilingcat 및 Logern의 제안으로 6 바이트 감소

f;i;b;o;n(char*a){for(f=i=b=o=0;*a;o+=21*b+++*a++-70);for(b=1,o="TACIHAAJQFSAAARCAMGKDANPEAOAAL"[o%30];--o>65;f=b,b=i)i=f+b;a=i;}

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

설명:

f; i; b; o; // Variables

n (char *a)
{
     // Calculate a silly hash of incoming string
     for (f = i = b = o = 0; *a; o += 21 * b++ + *a++ - 70);

     // Use the hash to index into the array of number values
     // and calculate the corresponding Fibonacci sequence element
     for
     (
         b = 1, 
         o = "TACIHAAJQFSAAARCAMGKDANPEAOAAL"[o % 30]; 

         --o > 65; 
         f = b, b = i
     )
         i = f + b;

     // implicit return
     a = i;
}

Pyth , 54 바이트

L?>b1+ytbyttbbyxc."axnÛ±r†XVW‹(„WîµÏ£"2+hQ@Q618

테스트 스위트

참고 : 코드에서 인쇄 할 수없는 일부 문자를 사용하므로 Stack Exchange에서 올바르게 표시되지 않을 수 있습니다. 제공된 링크는 작동 가능한 복사 가능 소스로 연결됩니다.

긴 이야기는 짧고 Q[0]+Q[618%len(Q)]받아 들여진 모든 입력에 고유 한 결과를 제공합니다 Q.

파이썬 2 , 292 바이트

f=lambda x:x>1and f(x-1)+f(x-2)or x
def g(t):
	for i,c in zip("pr secun ter qua qui sex sep oc no ec".split(),range(1,11))+zip("un duo es ev".split(),(1,2,20,"-")):t=t.replace(i,str(c))
	return f(abs(eval("+".join("".join((" ",c)[c in"0123456789-"]for c in t).split()).replace("+-+","-")))-1)

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

피보나치 발전기는 이 답변 에서 뻔뻔스럽게 도난당했습니다 .

각 단어를 의미있는 구성 요소로 나누고 나머지를 버립니다 (예 : "duodevicesimus"에서 "duo ev es"-> "2-20"-> abs ( "2-20")-> 18).

계산 된 값 (마이너스 1-0 오프셋)을 피보나치 생성기 함수에 전달합니다.

풀리지 않은 설명 :

# Fibonacci function
f=lambda x:x>1and f(x-1)+f(x-2)or x

def g(t):
    # generates a list of key, value pairs like [("pr", 1, ..., ("ec", 10)] +
    values = zip("pr secun ter qua qui sex sep oc no ec".split(), range(1,11))

    # adds values to existing list
    values += zip("un duo es ev".split(),(1,2,20,"-"))

    # replace the matching values in the string with the appropriate number/sign.
    # ORDER MATTERS - if "un" is searched for before "secun", this generates incorrect values.
    for i,c in values:
        t = t.replace(i,str(c))

    # replace each non-digit, non-minus character in string with "c"
    t = [(" ",c)[c in"0123456789-"]for c in t]

    # convert space-replaced array back to a string
    # then split it on spaces, creating an array of values
    t = "".join(t).split()

    # turn the array back into a string, with each individual item separated by "+"
    # this will cause "-" to become "+-+" (since "-" is ALWAYS between two numbers), so prelace that sequence with "-"
    t = "+".join(t).replace("+-+","-")

    # evaluate the string as an expression, and take the absolute value for when - occurs
    t = abs(eval(t))

    # pass the value, minus 1 for 0-offset, to the Fibonacci function.
    return f(t-1)

파이썬 2 , 97 79 바이트

lambda s:int(1.618**('RV3NJ^[KDP=Z62AWeG<C'.find(chr(hash(s)%69+48)))*.4474+.5)

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

먼저 라틴어를 숫자로 변환하려고합니다 n. 이 작업은 총 11 자 이상이되도록 입력 문자열을 충분한 시간 동안 복제하여310 수행됩니다 . 그런 다음 rd 및 th 문자 (0 인덱스) 는 해시 모드 69를 사용하여 인쇄 가능한 문자로 바꾸는 고유 한 쌍 을 형성합니다 .

이제 우리는 n. 찾기 위해 n번째 피보나치 수를, 우리가 사용할 수있는 반올림 방법을 우리가 FIB (20)까지 필요로하는 정밀 많은 숫자로만 사용.

자바 스크립트 (Node.js) , 100 97 95 92 91 바이트

x=>1.618**(p=parseInt)("1 jgf7  ei 490dbch62385a"[p(x.length+x,32)%12789%24],36)*.4474+.5|0

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

경고 : 부동 소수점 부정확 때문에 작동합니다

JavaScript에는 해시 함수가 내장되어 있지 않으며 문자 대 ASCII 함수 (짧은 문자) 함수도 없습니다. String.charCodeAt따라서 간단한 해시 함수를 직접 정의해야합니다.

해시를 계산 한 후 Chas Brown과 동일한 반올림 방법을 사용했습니다.

무차별 강제 하루 종일 더 나은 것이 발견됩니다.

b32_to_dec(x.length + x) % 12789 % 24 (* 부동 소수점 부정확)

b32_to_dec(x.length + x) % 353 % 27 (* 부동 소수점 부정확)

b36_to_dec(x.length + x[2]) % 158 % 29 - 4

b36_to_dec(x[2] + x.length) % 741 % 30

b36_to_dec(x[0] + x[2] + x.length) % 4190 % 27

parseInt(x.length + x, 32) 결과

primus 7310236636
secundus 9773632960476
tertius 272155724764
quartus 269453490140
quintus 269461747676
sextus 7054
septimus 9774067964892
octavus 266721394652
nonus 192700380
decimus 254959770588
undecimus 350449413217244
duodecimus 36520018280274912 **NOT PRECISE**
tertius decimus 1302947875804
quartus decimus 1300245641180
quintus decimus 1300253898716
sextus decimus 37774
septimus decimus 42759416798172
duodevicesimus 43016381192006637977600 **NOT PRECISE**
undevicesimus 1326703556626028691456 **NOT PRECISE**
vicesimus 351376069188572

부동 소수점 부정확성을 이용하지 않는 버전 : 95 바이트

x=>1.618**(p=parseInt)("52d7i 6  he 8309jafc 41bg"[p(x.length+x[2],36)%158%29-4],36)*.4474+.5|0

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

b36_to_dec(x.length + x[2]) % 158 % 29 - 4

해시 테이블

 Latin word           | Length | 3rd | Hash | Decimal | %158 | %29-4
----------------------+--------+-----+------+---------+------+-------
 primus               |      6 | i   | 6i   |     234 |   76 |    14
 secundus             |      8 | c   | 8c   |     300 |  142 |    22
 tertius              |      7 | r   | 7r   |     279 |  121 |     1
 quartus              |      7 | a   | 7a   |     262 |  104 |    13
 quintus              |      7 | i   | 7i   |     270 |  112 |    21
 sextus               |      6 | x   | 6x   |     249 |   91 |     0
 septimus             |      8 | p   | 8p   |     313 |  155 |     6
 octavus              |      7 | t   | 7t   |     281 |  123 |     3
 nonus                |      5 | n   | 5n   |     203 |   45 |    12
 decimus              |      7 | c   | 7c   |     264 |  106 |    15
 undecimus            |      9 | d   | 9d   |     337 |   21 |    17
 duodecimus           |     10 | o   | 10o  |    1320 |   56 |    23
 tertius decimus      |     15 | r   | 15r  |    1503 |   81 |    19
 quartus decimus      |     15 | a   | 15a  |    1486 |   64 |     2
 quintus decimus      |     15 | i   | 15i  |    1494 |   72 |    10
 sextus decimus       |     14 | x   | 14x  |    1473 |   51 |    18
 septimus decimus     |     16 | p   | 16p  |    1537 |  115 |    24
 duodevicesimus       |     14 | o   | 14o  |    1464 |   42 |     9
 undevicesimus        |     13 | d   | 13d  |    1417 |  153 |     4
 vicesimus            |      9 | c   | 9c   |     336 |   20 |    16