Leonardo de Pisa (ca. 1175 - ca. 1245) é mais conhecido como Fibonacci . Mas isso é realmente uma abreviação para o latim "filius Bonacci" (filho de Bonacci) que foi inventado durante o século 18 (de acordo com a Wikipedia ).

Neste desafio, você será dado um número ordinal (no sentido literal) entre 1 st e 20 th e você tem que devolver o termo correspondente na sequência de Fibonacci .

A diferença é que o número ordinal será dado em latim.

Exemplo : "duodecimus" → .$89$

Tabela 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

Regras

• A entrada é garantida como exatamente uma das seqüências descritas acima.
• Se isso ajudar, você pode colocá-lo em maiúsculas. Mas deve ser consistente para todas as entradas. Casos mistos não são permitidos.
• Dependendo do seu algoritmo e idioma, codificar ou computar os termos da sequência podem ganhar ou perder bytes. Ambas as abordagens são explicitamente permitidas.
• Isso é código-golfe !

R , 91 86 bytes

Procure o índice da soma de bytes em uma tabela de pesquisa UTF8 forçada bruta e use a função mágica de geração de Fibonacci para dar a resposta.

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

Experimente online!

Editar: -2 bytes por arredondamento numérico aprimorado

Edit: -3 bytes com uma alteração na pesquisa (obrigado pela dica, @ 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]}

Experimente online!

Simplesmente pega a soma dos bytes, módulo 192 módulo 76 módulo 23 e indexa em uma tabela de pesquisa. (Números mágicos encontrados por força bruta.)

Limpo , 87 bytes

Todas as fugas, exceto, \nsão tratadas como um byte, uma vez que o compilador está bem com os valores brutos reais. (O TIO e o SE têm problemas com o fato de não ser válido UTF-8, e por isso escapou aqui)

FryAmTheEggman fez uma bela demonstração / solução alternativa: aqui

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]

Experimente online!

Define a função $ :: [Char] -> Int, que usa a exclusividade no somatório dos valores de caracteres em maiúsculas para determinar qual termo na sequência (gerado pela função auxiliar k) deve ser retornado.

Código da 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

Isso usa hash (é claro), mas otimizado para implementação curta no 6502, aproveitando o sinalizador de transporte definido pelo deslocamento e usado adicionalmente. Números mágicos para o hash foram encontrados por força bruta com um pequeno programa C; os FFbytes são buracos infelizes na tabela de hash;)

Contagem de bytes: endereço de carregamento de 2 bytes, código de 38 bytes, hashtable de 42 bytes para valores.

Demonstração online

Uso:, SYS49152"[ordinal]"por exemplo SYS49152"DUODECIMUS". (observe que as letras aparecem em maiúsculas na configuração C64 padrão).

Importante : Antes da primeira inicialização, emita um NEWcomando. Isso é necessário porque o LOADcomando C64 BASIC brinca com alguns vetores BASIC, mesmo ao carregar um programa de máquina em algum endereço absoluto (como aqui $C000/ 49152).

Desmontagem comentada :

         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 testes C64 BASIC V2

(contendo o programa da máquina em DATA linhas)

Demonstração 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 bytes

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

Experimente online!

Usa uma tabela de pesquisa em uma cadeia de caracteres, bem como um gerador de sequência de fibonacci curto.

C (gcc) , 135 129 bytes

6 bytes abaixo por sugestão de 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;}

Experimente online!

Explicação:

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

Pitão , 54 bytes

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

Suíte de teste

Aviso: como o código utiliza alguns caracteres não imprimíveis, ele pode não ser exibido corretamente no Stack Exchange. O link fornecido leva a uma fonte de trabalho e cópia-colável.

Resumindo, Q[0]+Q[618%len(Q)]fornece resultados exclusivos para todas as entradas aceitas 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)

Experimente online!

Gerador de Fibonacci roubado descaradamente desta resposta .

Divide cada palavra em suas partes componentes significativas e descarta o restante (em "duodevicesimus", por exemplo, nos preocupamos apenas com "duo ev es" -> "2 - 20" -> abs ("2-20") -> 18)

Passa o valor calculado (menos deslocamento de 1 a 0) para a função de gerador de Fibonacci.

Explicação Ungolfed:

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

Experimente online!

Primeiro, queremos converter de latino para um número n; isso é feito replicando a sequência de entrada vezes suficientes para garantir que haja pelo menos 11 caracteres no total; e depois o 3rd e10 caracteres th (indexados a zero) formam um par único pegando o hash mod 69 e transformando isso em um caractere imprimível.

Agora nós temos n. Para encontrar o nnúmero de Fibonacci, podemos usar o método de arredondamento , usando apenas quantos dígitos de precisão precisamos até 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

Experimente online!

Aviso: OBRAS POR CAUSA DE IMPRECISÃO DE PONTO FLUTUANTE

O JavaScript não possui uma função de hash embutida, nem uma função de caractere-ASCII curta o suficiente (String.charCodeAt já é a mais curta), então eu preciso definir uma função de hash simples por mim.

Usou o mesmo método de arredondamento que Chas Brown usou após calcular o hash.

Após um dia inteiro de força bruta, é encontrado um melhor:

b32_to_dec(x.length + x) % 12789 % 24 (* imprecisão de ponto flutuante)

b32_to_dec(x.length + x) % 353 % 27 (* imprecisão de ponto flutuante)

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

Versão sem exploração da imprecisão do ponto flutuante: 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

Experimente online!

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

Tabela de 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