Léonard de Pise (vers 1175 - vers 1245) est mieux connu sous le nom de Fibonacci . Mais c'est en fait un court pour le latin "filius Bonacci" (le fils de Bonacci) qui a été inventé au cours du 18ème siècle (selon Wikipedia ).

Dans ce défi, vous recevrez un nombre ordinal (au sens littéral) entre le 1 er et le 20 e et vous devrez retourner le terme correspondant dans la séquence de Fibonacci .

La torsion est que le nombre ordinal sera donné en latin.

Exemple : "duodécimus" → . $89$

Table d'E / S complète

 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ègles

L'entrée est garantie comme étant exactement l' une des chaînes décrites ci-dessus.
Si cela vous aide, vous pouvez le prendre en majuscules à la place. Mais il doit être cohérent pour toutes les entrées. Les cas mixtes ne sont pas autorisés.
Selon votre algorithme et votre langue, le codage en dur ou le calcul des termes de la séquence peut gagner ou perdre des octets. Les deux approches sont explicitement autorisées.
C'est du code-golf !

code-golf fibonacci Arnauld
la source

Fait amusant: il y a un latin.stackexchange.com

JayCe

8

R , 91 86 octets

Recherchez l'index de la somme des octets dans une table de recherche UTF8 forcée et utilisez la fonction de génération magique de Fibonacci pour donner la réponse.

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

Essayez-le en ligne!

Édition: -2 octets par arrondi numérique amélioré

Edit: -3 octets avec une modification de la recherche (merci pour l'indice, @Giuseppe!)

J.Doe
la source

Je voulais faire quelque chose de similaire avec la recherche UTF8. Si vous n'aviez aucune idée, vous pourriez Fibonnaci comme ça. probablement plus court que ce que je voulais faire ( chartrl'UTF8 de la somme avec l'UTF8 de la valeur fibonacci, puis intToUtf8la sortie de chartr.

JayCe

90 octets

Giuseppe

Semble échouer "sextus decimus", Giuseppe.

J.Doe

1

Vous étiez sur la bonne chose @Giuseppe, il s'est avéré qu'il y avait 3 modules magiques à 2 chiffres pour lesquels la somme des octets était unique, 69, 88 et 93, et 88 était celui qui n'avait besoin d'aucune constante ajoutée pour faire un chaîne intelligible.

J.Doe

9

Parfois, j'ai l'impression que la moitié de codegolf trouve la bonne utilisation des nombres comme module ...

Giuseppe

4

Rubis, 104 93 octets

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

Essayez-le en ligne!

Prend simplement la somme des octets, modulo 192 modulo 76 modulo 23, et indexe dans une table de recherche. (Nombre magique trouvé par force brute.)

Poignée de porte
la source

4

Nettoyer , 87 octets

Tous les échappements sauf \nsont traités comme un octet, car le compilateur se contente des valeurs brutes réelles. (TIO et SE ont des problèmes avec le fait qu'il ne soit pas valide UTF-8, et donc c'est échappé ici)

FryAmTheEggman a fait une belle démonstration / solution: ici

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]

Essayez-le en ligne!

Définit la fonction $ :: [Char] -> Int, qui utilise l'unicité de la somme des valeurs des caractères majuscules pour déterminer le terme de la séquence (généré par la fonction d'assistance k) à renvoyer.

Οurous
la source

4

6502 code machine (C64), 82 octets

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

Cela utilise le hachage (bien sûr), mais optimisé pour une implémentation courte sur le 6502, en profitant du drapeau de transport défini par décalage et utilisé en plus. Les nombres magiques pour le hachage ont été trouvés par le forçage brut avec un petit programme C; leFF octets sont des trous malheureux dans la table de hachage;)

Nombre d'octets: adresse de chargement de 2 octets, code de 38 octets, table de hachage de 42 octets pour les valeurs.

Démo en ligne

Utilisation:, SYS49152"[ordinal]"par exempleSYS49152"DUODECIMUS" . (notez que les lettres apparaissent en majuscules dans la configuration C64 par défaut).

Important : avant le premier démarrage, exécutez une NEWcommande. Cela est nécessaire car la LOADcommande C64 BASIC joue avec certains vecteurs BASIC, même lors du chargement d'un programme machine à une adresse absolue (comme ici $C000/49152 ).

Démontage commenté :

         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 de tests C64 BASIC V2

(contenant le programme machine en DATAlignes)

Démo en ligne

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

Felix Palmen
la source

3

Perl 6 , 62 octets

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

Essayez-le en ligne!

Utilise une table de recherche dans une chaîne, ainsi qu'un court générateur de séquences fibonacci.

Jo King
la source

3

C (gcc) , 135 129 octets

6 octets en moins par suggestion de plafond et 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;}

Essayez-le en ligne!

Explication:

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

Max Yekhlakov
la source

Vous pouvez remplacer return i;para=i;

Logern

2

Pyth , 54 octets

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

Suite de tests

Remarque: comme le code utilise certains caractères non imprimables, il peut ne pas s'afficher correctement sur Stack Exchange. Le lien fourni mène à une source fonctionnelle et collable.

Bref, Q[0]+Q[618%len(Q)]donne des résultats uniques pour toutes les entrées acceptées Q.

hakr14
la source

1

Python 2 , 292 octets

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)

Essayez-le en ligne!

Générateur Fibonacci volé sans vergogne à cette réponse .

Décompose chaque mot en ses parties significatives et élimine le reste (dans "duodevicesimus", par exemple, nous ne nous soucions que de "duo ev es" -> "2 - 20" -> abs ("2-20") -> 18).

Transmet la valeur calculée (moins 1 à 0 offset) à la fonction de générateur de Fibonacci.

Explication non golfée:

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

Triggernométrie
la source

1

Python 2 , 97 79 octets

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

Essayez-le en ligne!

Tout d'abord, nous voulons convertir le latin en nombre n; ceci est accompli en ~~répliquant la chaîne d'entrée suffisamment de fois pour s'assurer qu'il y a au moins 11 caractères au total; puis les 3rd et 10e caractères (indexés zéro) forment une paire unique~~ prenant le mod de hachage 69 et le transformant en un caractère imprimable.

Maintenant, nous l'avons n. Pour trouver le nnombre de Fibonacci, nous pouvons utiliser la méthode d'arrondi , en utilisant seulement autant de chiffres de précision que nécessaire jusqu'à Fib (20).

Chas Brown
la source

1

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

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

Essayez-le en ligne!

Avertissement: FONCTIONNEMENT EN RAISON DE L'EXACTITUDE DU POINT FLOTTANT

JavaScript n'a ni fonction de hachage intégrée, ni fonction de conversion de caractères en ASCII suffisamment courte (elle String.charCodeAtest déjà la plus courte), j'ai donc besoin de définir moi-même une simple fonction de hachage.

A utilisé la même méthode d'arrondi que Chas Brown a fait après le calcul du hachage.

Après une journée entière de force brute, on trouve mieux:

b32_to_dec(x.length + x) % 12789 % 24 (* inexactitude en virgule flottante)

~~b32_to_dec(x.length + x) % 353 % 27 (* inexactitude en virgule flottante)~~

~~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) résultat

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 sans exploitation de l'inexactitude en virgule flottante: 95 octets

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

Essayez-le en ligne!

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

Table de hachage

 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

Shieru Asakoto
la source

Sequentia Filii Bonacci

Table d'E / S complète

Règles

Réponses:

R , 91 86 octets

Rubis, 104 93 octets

Nettoyer , 87 octets

6502 code machine (C64), 82 octets

Démo en ligne

Suite de tests C64 BASIC V2

Démo en ligne

Perl 6 , 62 octets

C (gcc) , 135 129 octets

Pyth , 54 octets

Python 2 , 292 octets

Explication non golfée:

Python 2 , 97 79 octets

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

Version sans exploitation de l'inexactitude en virgule flottante: 95 octets