ピサのレオナルド（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を法とする23を法とする192を法とするバイトの合計を取得し、ルックアップテーブルにインデックスを付けます。（ブルートフォースによって発見された魔法の数字。）

クリーン、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コマンドを発行します。これはLOAD、マシンプログラムを絶対アドレス（ここ$C000/など49152）にロードする場合でも、C64 BASIC コマンドが一部の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 BASIC 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

Perl 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ます。

Python 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文字（ゼロインデックス）は、ハッシュmod 69を取り、それを印刷可能な文字に変換する一意のペアを形成します。

今、ありnます。n番目のフィボナッチ数を見つけるには、Fib（20）まで必要な桁数だけ精度を使用して、丸め方法を使用できます。

JavaScript（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