Leonardo da Pisa (circa 1175 - circa 1245) è meglio conosciuto come Fibonacci . Ma questo in realtà è l'abbreviazione del latino "filius Bonacci" (figlio di Bonacci) che fu inventato durante il XVIII secolo (secondo Wikipedia ).

In questa sfida, ti verrà dato un numero ordinale (in senso letterale) tra il 1 ° e il 20 ° e si deve restituire il termine corrispondente nella sequenza di Fibonacci .

La svolta è che il numero ordinale sarà dato in latino.

Esempio : "duodecimus" → .$89$

Tabella I / O completa

 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

Regole

• L'input è garantito esattamente una delle stringhe sopra descritte.
• Se questo aiuta, puoi invece prenderlo in maiuscolo. Ma deve essere coerente per tutte le voci. Non sono ammessi casi misti.
• A seconda dell'algoritmo e della lingua, l'hardcoding o il calcolo dei termini della sequenza può vincere o perdere byte. Entrambi gli approcci sono esplicitamente consentiti.
• Questo è code-golf !

R , 91 86 byte

Cerca l'indice della somma dei byte in una tabella di ricerca UTF8 forzata e usa la magica funzione di generazione di Fibonacci per dare la risposta.

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

Provalo online!

Modifica: -2 byte migliorando l'arrotondamento numerico

Modifica: -3 byte con una modifica alla ricerca (grazie per il suggerimento, @Giuseppe!)

Rubino, 104 93 byte

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

Provalo online!

Prende semplicemente la somma dei byte, modulo 192 modulo 76 modulo 23 e gli indici in una tabella di ricerca. (Numeri magici trovati dalla forza bruta.)

Pulito , 87 byte

Tutte le escape tranne quelle \nvengono trattate come un byte, poiché il compilatore va bene con i valori grezzi effettivi. (TIO e SE hanno problemi con il fatto che non è valido UTF-8, quindi è sfuggito qui)

FryAmTheEggman ha fatto una bella dimostrazione / soluzione alternativa: qui

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]

Provalo online!

Definisce la funzione $ :: [Char] -> Int, che utilizza l'unicità nella somma dei valori dei caratteri maiuscoli per determinare quale termine della sequenza (generato dalla funzione helper k) da restituire.

6502 codice macchina (C64), 82 byte

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

Questo utilizza l'hashing (ovviamente), ma ottimizzato per una breve implementazione sul 6502, sfruttando il flag di carry impostato spostando e usato in aggiunta. I numeri magici per l'hashing sono stati trovati forzando brutalmente con un piccolo programma C; ilFF byte sono sfortunati buchi nella tabella hash;)

Conteggio byte: indirizzo di caricamento 2 byte, codice 38 byte, hashtable 42 byte per i valori.

Demo online

Utilizzo: SYS49152"[ordinal]"ad esempio SYS49152"DUODECIMUS". (notare che le lettere appaiono in maiuscolo nella configurazione C64 predefinita).

Importante : prima del primo avvio, emettere un NEWcomando. Ciò è necessario perché il LOADcomando BASIC C64 alterna alcuni vettori BASIC, anche quando si carica un programma macchina su un indirizzo assoluto (come qui $C000/ 49152).

Smontaggio commentato :

         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

Suite di test C64 BASIC V2

(contenente il programma della macchina in DATArighe)

Demo online

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 byte

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

Provalo online!

Utilizza una tabella di ricerca in una stringa, nonché un generatore di sequenza fibonacci breve.

C (gcc) , 135 129 byte

6 byte in basso su suggerimento di ceilingcat e 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;}

Provalo online!

Spiegazione:

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 byte

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

Suite di test

Avviso: poiché il codice utilizza alcuni caratteri non stampabili, potrebbe non essere visualizzato correttamente su Stack Exchange. Il collegamento fornito porta a una fonte funzionante e copiabile.

Per farla breve, Q[0]+Q[618%len(Q)]offre risultati unici per tutti gli input accettati Q.

Python 2 , 292 byte

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)

Provalo online!

Il generatore di Fibonacci rubato senza vergogna questa risposta .

Suddivide ogni parola nelle sue parti componenti significative e scarta il resto (in "duodevicesimus", ad esempio, ci preoccupiamo solo di "duo ev es" -> "2 - 20" -> abs ("2-20") -> 18).

Passa il valore calcolato (meno 1 a 0-offset) alla funzione del generatore di Fibonacci.

Spiegazione non golfata:

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

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

Provalo online!

Innanzitutto, vogliamo convertire dal latino in un numero n; ciò si ottiene replicando la stringa di input abbastanza volte per garantire che ci siano almeno 11 caratteri in totale; e quindi i caratteri 3rd e 10th (zero indicizzati) formano una coppia unica prende l'hash mod 69 e lo trasforma in un carattere stampabile.

Adesso abbiamo n. Per trovare il nnumero di Fibonacci, possiamo usare il metodo di arrotondamento , usando solo tutte le cifre di precisione di cui abbiamo bisogno fino a Fib (20).

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

Provalo online!

Avvertenza: FUNZIONA A CAUSA DELL'ACCACCACIA DEL PUNTO GALLEGGIANTE

JavaScript non ha né una funzione hash integrata, né una funzione da carattere a ASCII abbastanza breve ( String.charCodeAtè già la più breve), quindi devo definire una semplice funzione hash da sola.

Ha usato lo stesso metodo di arrotondamento di Chas Brown dopo aver calcolato l'hash.

Dopo un'intera giornata di brute force si trova un migliore:

b32_to_dec(x.length + x) % 12789 % 24 (* imprecisione in virgola mobile)

b32_to_dec(x.length + x) % 353 % 27 (* imprecisione in virgola mobile)

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

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

Versione senza sfruttamento della precisione in virgola mobile: 95 byte

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

Provalo online!

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

Tabella hash

 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