Leonardo von Pisa (ca. 1175 - ca. 1245) ist besser bekannt als Fibonacci . Dies ist jedoch eine Abkürzung für den lateinischen "Filius Bonacci" (Sohn von Bonacci), der im 18. Jahrhundert erfunden wurde (laut Wikipedia ).

In dieser Herausforderung werden Sie eine Ordnungszahl (im wörtlichen Sinne) zwischen gegeben 1 st und 20 th und Sie haben den entsprechenden Begriff in der zurück Fibonacci - Folge .

Die Wendung ist, dass die Ordnungszahl in Latein angegeben wird.

Beispiel : "duodecimus" → .$89$

Vollständige E / A-Tabelle

 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

Regeln

• Die Eingabe ist garantiert genau eine der oben beschriebenen Zeichenfolgen.
• Wenn das hilft, können Sie es stattdessen in Großbuchstaben schreiben. Sie muss jedoch für alle Einträge konsistent sein. Mischfälle sind nicht zulässig.
• Abhängig von Ihrem Algorithmus und Ihrer Sprache können beim Hardcodieren oder Berechnen der Begriffe der Sequenz Bytes gewonnen oder verloren werden. Beide Ansätze sind ausdrücklich erlaubt.
• Das ist Code-Golf !

R , 91 86 Bytes

Suchen Sie den Index der Bytesumme in einer Brute-Forced-UTF8-Nachschlagetabelle und geben Sie die Antwort mithilfe der magischen Fibonacci-Generierungsfunktion .

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

Probieren Sie es online!

Edit: -2 Bytes durch verbesserte numerische Rundung

Edit: -3 Bytes mit einer Änderung an der Suche (danke für den Hinweis, @ Giuseppe!)

Ruby, 104 93 Bytes

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

Probieren Sie es online!

Nimmt einfach die Summe der Bytes, Modulo 192, Modulo 76, Modulo 23, und indiziert in eine Nachschlagetabelle. (Magische Zahlen durch rohe Gewalt gefunden.)

Sauber , 87 Bytes

Alle Escapezeichen außer \nwerden als ein Byte behandelt, da der Compiler mit den tatsächlichen Rohwerten zufrieden ist. (TIO und SE haben Probleme damit, dass UTF-8 nicht gültig ist, und daher ist es hier ausgeblendet.)

FryAmTheEggman hat eine schöne Demonstration / Umgehung gemacht: hier

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]

Probieren Sie es online!

Definiert die Funktion $ :: [Char] -> Int, die die Eindeutigkeit in der Summe der Großbuchstaben verwendet, um zu bestimmen, welcher Term in der Sequenz (von der Hilfsfunktion generiert k) zurückgegeben werden soll.

6502 Maschinencode (C64), 82 Bytes

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

Dies verwendet Hashing (natürlich), ist jedoch für eine kurze Implementierung auf dem 6502 optimiert und nutzt das durch Verschieben gesetzte und zusätzlich verwendete Übertragsflag. Magische Zahlen für das Hashing wurden durch brachiales Forcen mit einem kleinen C-Programm gefunden; die FFbytes sind unglückliche löcher in der hashtabelle;)

Byteanzahl: 2 Bytes Ladeadresse, 38 Bytes Code, 42 Bytes Hashtabelle für Werte.

Online-Demo

Verbrauch: SYS49152"[ordinal]"zum Beispiel SYS49152"DUODECIMUS". (Beachten Sie, dass die Buchstaben in der Standard-C64-Konfiguration in Großbuchstaben angezeigt werden.)

Wichtig : Geben Sie vor dem ersten Start einen NEWBefehl aus. Dies ist erforderlich, da der C64-BASIC- LOADBefehl mit einigen BASIC-Vektoren tüftelt, selbst wenn ein Maschinenprogramm auf eine absolute Adresse geladen wird (wie hier $C000/ 49152).

Kommentierte Demontage :

         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-Testsuite

(enthält das Maschinenprogramm in DATAZeilen)

Online-Demo

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 Bytes

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

Probieren Sie es online!

Verwendet eine Nachschlagetabelle in einem String sowie einen kurzen Fibonacci-Sequenzgenerator.

C (GCC) , 135 129 Bytes

6 Bytes runter auf Vorschlag von Ceilingcat und Logern

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

Probieren Sie es online!

Erläuterung:

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 Bytes

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

Testsuite

Hinweis: Da der Code einige nicht druckbare Zeichen verwendet, wird er in Stack Exchange möglicherweise nicht richtig angezeigt. Der bereitgestellte Link führt zu einer funktionierenden und kopierfähigen Quelle.

Kurz gesagt, Q[0]+Q[618%len(Q)]liefert einzigartige Ergebnisse für alle akzeptierten Eingaben Q.

Python 2 , 292 Bytes

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)

Probieren Sie es online!

Fibonacci-Generator schamlos aus dieser Antwort gestohlen .

Zerlegt jedes Wort in seine sinnvollen Bestandteile und verwirft den Rest (in "duodevicesimus" kümmern wir uns zum Beispiel nur um "duo eves" -> "2 - 20" -> abs ("2-20") -> 18).

Übergibt den berechneten Wert (minus 1 bis 0-Offset) an die Fibonacci-Generatorfunktion.

Ungolfed Erklärung:

# 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)

Python 2 , 97 79 Bytes

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

Probieren Sie es online!

Zuerst wollen wir von Latein zu einer Zahl konvertieren n; Dies wird erreicht, indem die Eingabezeichenfolge ausreichend oft repliziert wird, um sicherzustellen, dass insgesamt mindestens 11 Zeichen vorhanden sind. und dann bilden das 3rd und das 10th Zeichen (null indiziert) ein eindeutiges Paar , das den Hash-Mod 69 nimmt und daraus ein druckbares Zeichen macht.

Jetzt haben wir n. Um die nth Fibonacci-Zahl zu finden, können wir die Rundungsmethode verwenden , wobei wir nur so viele Stellen der Genauigkeit verwenden, wie wir bis zu Fib (20) benötigen.

JavaScript (Node.js) , 100 97 95 92 91 Byte

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

Probieren Sie es online!

Warnung: ARBEITET, WEIL DER PUNKT UNGENAUIGKEIT SCHWIMMT

JavaScript hat weder eine integrierte Hash-Funktion noch eine ausreichend kurze Zeichen-zu-ASCII-Funktion ( String.charCodeAtist bereits die kürzeste). Daher muss ich selbst eine einfache Hash-Funktion definieren.

Verwendete die gleiche Rundungsmethode wie Chas Brown nach der Berechnung des Hashs.

Nach einem ganzen Tag roher Gewalt wird ein Besseres gefunden:

b32_to_dec(x.length + x) % 12789 % 24 (* Gleitkomma-Ungenauigkeit)

b32_to_dec(x.length + x) % 353 % 27 (* Gleitkomma-Ungenauigkeit)

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) Ergebnis

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

Version ohne Ausnutzung der Gleitkomma-Ungenauigkeit: 95 Bytes

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

Probieren Sie es online!

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

Hash-tabelle

 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