Leonardo z Pizy (ok. 1175 - ok. 1245) jest lepiej znany jako Fibonacci . Ale tak naprawdę jest to skrót od łacińskiego „filius Bonacci” (syn Bonacciego), który powstał w XVIII wieku (według Wikipedii ).

W tym wyzwaniem, musisz być nadany numer porządkowy (w sensie dosłownym) między 1 st i 20 th i trzeba wrócić odpowiedni okres w ciągu Fibonacciego .

Skręt polega na tym, że liczba porządkowa zostanie podana w języku łacińskim.

Przykład : „duodecimus” → .$89$

Pełny stół we / wy

 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

Zasady

• Gwarantowanym wejściem jest dokładnie jeden z ciągów opisanych powyżej.
• Jeśli to pomoże, możesz zamiast tego wziąć to dużymi literami. Ale musi być spójny dla wszystkich wpisów. Mieszane przypadki są niedozwolone.
• W zależności od algorytmu i języka kodowanie na stałe lub przetwarzanie warunków sekwencji może wygrać lub utracić bajty. Oba podejścia są wyraźnie dozwolone.
• To jest golf golfowy !

R , 91 86 bajtów

Sprawdź indeks sumy bajtów w tabeli wyszukiwania UTF8 z brutalną siłą i użyj magicznej funkcji generowania Fibonacciego, aby udzielić odpowiedzi.

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

Wypróbuj online!

Edycja: -2 bajty dzięki ulepszonemu zaokrągleniu numerycznemu

Edycja: -3 bajty ze zmianą wyszukiwania (dzięki za podpowiedź, @Giuseppe!)

Rubin, 104 93 bajty

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

Wypróbuj online!

Po prostu pobiera sumę bajtów, modulo 192 modulo 76 modulo 23 i indeksuje do tabeli przeglądowej. (Liczby magiczne znalezione przez brutalną siłę.)

Czysty , 87 bajtów

Wszystkie sekwencje specjalne oprócz \ntraktowane są jako jeden bajt, ponieważ kompilator jest w porządku z rzeczywistymi wartościami raw. (TIO i SE mają jednak problemy z tym, że nie jest prawidłowy UTF-8, więc tutaj uciekł)

FryAmTheEggman wykonał niezłą demonstrację / obejście: tutaj

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]

Wypróbuj online!

Definiuje funkcję $ :: [Char] -> Int, która wykorzystuje unikalność w sumowaniu wartości wielkich liter do określenia, który termin w sekwencji (wygenerowany przez funkcję pomocnika k) ma zostać zwrócony.

Kod maszynowy 6502 (C64), 82 bajty

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

Wykorzystuje to haszowanie (oczywiście), ale jest zoptymalizowane do krótkiej implementacji w 6502, wykorzystując zestaw flagi przenoszenia przez przesunięcie i używany dodatkowo. Liczby magiczne dla haszowania zostały znalezione przez brutalne wymuszanie za pomocą małego programu C; te FFbajty są niefortunne otwory w stole mieszania;)

Liczba bajtów: adres ładowania 2 bajty, kod 38 bajtów, 42 bajty hashtable dla wartości.

Demo online

Zastosowanie: SYS49152"[ordinal]"na przykład SYS49152"DUODECIMUS". (zwróć uwagę, że litery są wyświetlane dużymi literami w domyślnej konfiguracji C64).

Ważne : przed pierwszym uruchomieniem wydaj NEWpolecenie. Jest to konieczne, ponieważ LOADkomenda C64 BASIC błąka się z niektórymi wektorami BASIC, nawet podczas ładowania programu maszynowego na jakiś adres bezwzględny (jak tutaj $C000/ 49152).

Skomentowany demontaż :

         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

Zestaw testowy C64 BASIC V2

(zawierający program maszyny w DATAwierszach)

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 bajtów

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

Wypróbuj online!

Używa tabeli odnośników w łańcuchu, a także generatora krótkich sekwencji Fibonacciego.

C (gcc) , 135 129 bajtów

6 bajtów w dół dzięki sugestii programu pułapkowego cat i 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;}

Wypróbuj online!

Wyjaśnienie:

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 bajty

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

Zestaw testowy

Ogłoszenie: ponieważ kod wykorzystuje niektóre niedrukowalne znaki, może nie być poprawnie wyświetlany na Stack Exchange. Podany link prowadzi do działającego i możliwego do skopiowania źródła.

Krótko mówiąc, Q[0]+Q[618%len(Q)]daje unikalne wyniki dla wszystkich zaakceptowanych danych wejściowych Q.

Python 2 , 292 bajty

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)

Wypróbuj online!

Generator Fibonacciego bezwstydnie skradziony z tej odpowiedzi .

Dzieli każde słowo na znaczące części składowe i odrzuca resztę (na przykład w „duodevicesimus” dbamy tylko o „duo ev es” -> „2-20” -> abs („2-20”) -> 18).

Przekazuje obliczoną wartość (minus 1 do 0-offset) do funkcji generatora Fibonacciego.

Niegolfowane Objaśnienie:

# 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 bajtów

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

Wypróbuj online!

Po pierwsze, chcemy przekonwertować z łaciny na liczbę n; osiąga się to poprzez replikację ciągu wejściowego wystarczająco wiele razy, aby zapewnić, że w sumie jest co najmniej 11 znaków; a następnie 3rd i10 znaki th (indeksowane od zera) tworzą unikalną parę, przyjmując mod skrótu 69 i przekształcając go w znak do druku.

Teraz mamy n. Aby znaleźć nliczbę Fibonacciego, możemy użyć metody zaokrąglania , używając tylko tyle cyfr precyzji, ile potrzebujemy, aż do Fib (20).

JavaScript (Node.js) , 100 97 95 92 91 bajtów

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

Wypróbuj online!

Ostrzeżenie: DZIAŁA PONIEWAŻ NIEDOKŁADNOŚCI PUNKTOWEJ

JavaScript nie ma ani wbudowanej funkcji skrótu, ani wystarczająco krótkiej funkcji znakowej do ASCII ( String.charCodeAtjest już najkrótsza), więc sam muszę zdefiniować prostą funkcję skrótu.

Zastosowano tę samą metodę zaokrąglania, co Chas Brown po obliczeniu wartości skrótu.

Po całym dniu brutalnego forsowania można znaleźć coś lepszego:

b32_to_dec(x.length + x) % 12789 % 24 (* niedokładność zmiennoprzecinkowa)

b32_to_dec(x.length + x) % 353 % 27 (* niedokładność zmiennoprzecinkowa)

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

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

Wersja bez wykorzystania niedokładności zmiennoprzecinkowej: 95 bajtów

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

Wypróbuj online!

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

Tabela mieszania

 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