Leonardo de Pisa (ca. 1175 - ca. 1245) es mejor conocido como Fibonacci . Pero esto es en realidad una abreviatura del latín "filius Bonacci" (el hijo de Bonacci) que se inventó durante el siglo XVIII (según Wikipedia ).

En este desafío, se le dará un número ordinal (en el sentido literal) entre 1 st y 20 º y tiene que devolver el término correspondiente en la secuencia de Fibonacci .

El giro es que el número ordinal se dará en latín.

Ejemplo : "duodecimus" → .$89$

Mesa de E / S 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

Reglas

• Se garantiza que la entrada sea exactamente una de las cadenas descritas anteriormente.
• Si eso ayuda, puede tomarlo en mayúsculas en su lugar. Pero debe ser consistente para todas las entradas. No se permiten casos mixtos.
• Dependiendo de su algoritmo e idioma, la codificación o el cálculo de los términos de la secuencia pueden ganar o perder bytes. Ambos enfoques están explícitamente permitidos.
• Este es el código de golf !

R , 91 86 bytes

Busque el índice de la suma de bytes en una tabla de búsqueda UTF8 forzada por fuerza bruta y use la función mágica de generación de Fibonacci para dar la respuesta.

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

Pruébalo en línea!

Editar: -2 bytes por redondeo numérico mejorado

Editar: -3 bytes con un cambio en la búsqueda (¡gracias por la pista, @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]}

Pruébalo en línea!

Simplemente toma la suma de los bytes, módulo 192 módulo 76 módulo 23, e indexa en una tabla de búsqueda. (Números mágicos encontrados por la fuerza bruta).

Limpio , 87 bytes

Todos los escapes excepto \nse tratan como un byte, ya que el compilador está bien con los valores brutos reales. (TIO y SE tienen problemas con que no sea UTF-8 válido, por lo que se ha escapado aquí)

FryAmTheEggman hizo una buena demostración / solución alternativa: aquí

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]

Pruébalo en línea!

Define la función $ :: [Char] -> Int, que utiliza la unicidad en la suma de los valores de caracteres en mayúscula para determinar qué término de la secuencia (generado por la función auxiliar k) devolver.

Código de máquina 6502 (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

Esto utiliza hashing (por supuesto), pero optimizado para una implementación corta en el 6502, aprovechando el conjunto de banderas de transporte mediante el desplazamiento y el uso adicional. Los números mágicos para el hash se encontraron mediante la fuerza bruta con un pequeño programa en C; los FFbytes son agujeros desafortunados en la tabla hash;)

Recuento de bytes: dirección de carga de 2 bytes, código de 38 bytes, tabla hash de 42 bytes para valores.

Demostración en línea

Uso: SYS49152"[ordinal]"por ejemplo SYS49152"DUODECIMUS". (tenga en cuenta que las letras aparecen en mayúsculas en la configuración predeterminada de C64).

Importante : Antes del primer inicio, emita un NEWcomando. Esto es necesario porque el LOADcomando C64 BASIC juega con algunos vectores BASIC, incluso cuando se carga un programa de máquina en una dirección absoluta (como aquí $C000/ 49152).

Desmontaje comentado :

         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

Conjunto de pruebas C64 BASIC V2

(que contiene el programa de la máquina en DATAlíneas)

Demostración en línea

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

Pruébalo en línea!

Utiliza una tabla de búsqueda en una cadena, así como un generador de secuencia de Fibonacci corto.

C (gcc) , 135 129 bytes

6 bytes hacia abajo por sugerencia de ceilingcat y 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;}

Pruébalo en línea!

Explicación:

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

Banco de pruebas

Aviso: como el código hace uso de algunos caracteres no imprimibles, es posible que no se muestre correctamente en Stack Exchange. El enlace proporcionado conduce a una fuente de trabajo y copiable.

Larga historia corta, Q[0]+Q[618%len(Q)]da resultados únicos para todas las entradas aceptadas 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)

Pruébalo en línea!

Generador de Fibonacci robado descaradamente de esta respuesta .

Desglosa cada palabra en sus partes componentes significativas y descarta el resto (en "duodevicesimus", por ejemplo, solo nos preocupamos por "duo ev es" -> "2 - 20" -> abs ("2-20") -> 18)

Pasa el valor calculado (menos 1 a 0-offset) a la función de generador de Fibonacci.

Explicación sin golf:

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

Pruébalo en línea!

Primero, queremos convertir del latín a un número n; esto se logra replicando la cadena de entrada suficientes veces para garantizar que haya al menos 11 caracteres en total; y luego los caracteres 3rd y 10th (indexados a cero) forman un par único toma el hash mod 69 y lo convierte en un carácter imprimible.

Ahora tenemos n. Para encontrar el nnúmero de Fibonacci, podemos usar el método de redondeo , usando solo tantos dígitos de precisión como necesitemos hasta Fib (20).

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

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

Pruébalo en línea!

Advertencia: FUNCIONA POR INCORRECCIÓN DEL PUNTO FLOTANTE

JavaScript no tiene una función hash incorporada ni una función de carácter ASCII lo suficientemente corta (ya String.charCodeAtes la más corta), por lo que necesito definir una función hash simple por mí mismo.

Usó el mismo método de redondeo que utilizó Chas Brown después de calcular el hash.

Después de un día entero de fuerza bruta, se encuentra un mejor:

b32_to_dec(x.length + x) % 12789 % 24 (* inexactitud de coma flotante)

b32_to_dec(x.length + x) % 353 % 27 (* inexactitud de coma flotante)

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

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

Versión sin explotación de imprecisión de coma flotante: 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

Pruébalo en línea!

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

Tabla de picadillo

 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