Leonardo của Pisa (khoảng năm 1175 - khoảng năm 1245) được biết đến nhiều hơn với tên gọi là Fibonacci . Nhưng đây thực sự là một từ viết tắt của "filius Bonacci" Latin (con trai của Bonacci) được tạo thành trong thế kỷ 18 (theo Wikipedia ).

Trong thử thách này, bạn sẽ được cấp một số thứ tự (theo nghĩa đen) giữa 1 st và 20 ngày và bạn phải trả lại hạn tương ứng trong dãy Fibonacci .

Điều khó hiểu là số thứ tự sẽ được đưa ra bằng tiếng Latin.

Ví dụ : "duodecimus" → .$89$

Bảng I / O đầy đủ

 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

Quy tắc

• Đầu vào được đảm bảo chính xác là một trong các chuỗi được mô tả ở trên.
• Nếu điều đó có ích, bạn có thể lấy nó bằng chữ hoa thay thế. Nhưng nó phải phù hợp cho tất cả các mục. Trường hợp hỗn hợp không được phép.
• Tùy thuộc vào thuật toán và ngôn ngữ của bạn, mã hóa cứng hoặc tính toán các thuật ngữ của chuỗi có thể thắng hoặc mất byte. Cả hai cách tiếp cận đều được cho phép rõ ràng.
• Đây là môn đánh gôn !

R , 91 86 byte

Tra cứu chỉ số của tổng số byte trong bảng tra cứu UTF8 bắt buộc và sử dụng hàm tạo Fibonacci ma thuật để đưa ra câu trả lời.

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

Hãy thử trực tuyến!

Chỉnh sửa: -2 byte bằng cách làm tròn số được cải thiện

Chỉnh sửa: -3 byte với thay đổi tra cứu (cảm ơn vì gợi ý, @Giuseppe!)

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

Hãy thử trực tuyến!

Đơn giản chỉ cần lấy tổng số byte, modulo 192 modulo 76 modulo 23 và lập chỉ mục vào bảng tra cứu. (Số ma thuật được tìm thấy bởi lực lượng vũ phu.)

Sạch , 87 byte

Tất cả các lần thoát ngoại trừ \nđược coi là một byte, vì trình biên dịch tốt với các giá trị thô thực tế. (TIO và SE có vấn đề với việc nó không phải là UTF-8 hợp lệ, và vì vậy nó đã thoát ở đây)

FryAmTheEggman đã thực hiện một cuộc biểu tình / giải pháp tốt đẹp: tại đây

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]

Hãy thử trực tuyến!

Xác định hàm $ :: [Char] -> Int, sử dụng tính duy nhất trong tổng các giá trị ký tự chữ hoa để xác định thuật ngữ nào trong chuỗi (được tạo bởi hàm trợ giúp k) để trả về.

Mã máy 6502 (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

Điều này sử dụng băm (tất nhiên), nhưng được tối ưu hóa để thực hiện ngắn trên 6502, tận dụng cờ mang được đặt bằng cách dịch chuyển và sử dụng thêm vào. Số ma thuật để băm được tìm thấy bằng cách cưỡng bức bằng một chương trình C nhỏ; các FFbyte là các lỗ đáng tiếc trong bảng băm;)

Số byte: địa chỉ tải 2 byte, mã 38 byte, hashtable 42 byte cho các giá trị.

Bản demo trực tuyến

Cách sử dụng: SYS49152"[ordinal]"ví dụ SYS49152"DUODECIMUS". (lưu ý các chữ cái xuất hiện chữ hoa trong cấu hình C64 mặc định).

Quan trọng : Trước khi bắt đầu đầu tiên, hãy ra NEWlệnh. Điều này là cần thiết bởi vì lệnh C64 BASIC thay đổi LOADvới một số vectơ BASIC, ngay cả khi tải một chương trình máy đến một số địa chỉ tuyệt đối (như ở đây $C000/ 49152).

Nhận xét tháo gỡ :

         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

Bộ kiểm tra C64 BASIC V2

(chứa chương trình máy theo DATAdòng)

Bản demo trực tuyến

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

Hãy thử trực tuyến!

Sử dụng bảng tra cứu trong một chuỗi, cũng như một trình tạo chuỗi ngắn của Wikipedia.

C (gcc) , 135 129 byte

Giảm 6 byte theo gợi ý của Barecat và 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;}

Hãy thử trực tuyến!

Giải trình:

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

Bình thường , 54 byte

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

Bộ kiểm tra

Lưu ý: vì mã sử dụng một số ký tự không thể in được, nên nó có thể không hiển thị chính xác trên Stack Exchange. Liên kết được cung cấp dẫn đến một nguồn làm việc và sao chép.

Câu chuyện dài, Q[0]+Q[618%len(Q)]cho kết quả độc đáo cho tất cả các đầu vào được chấp nhận 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)

Hãy thử trực tuyến!

Máy phát điện Fibonacci bị đánh cắp một cách đáng xấu hổ từ câu trả lời này .

Chia từng từ thành các phần thành phần có ý nghĩa của nó và loại bỏ phần còn lại (trong "duodevicesimus", ví dụ, chúng tôi chỉ quan tâm đến "bộ đôi ev es" -> "2 - 20" -> abs ("2-20") -> 18).

Truyền giá trị được tính toán (trừ 1 đến 0-offset) cho hàm tạo Fibonacci.

Giải thích lộn xộn:

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

Hãy thử trực tuyến!

Đầu tiên, chúng tôi muốn chuyển đổi từ tiếng Latin sang một số n; điều này được thực hiện bằng cách sao chép chuỗi đầu vào đủ số lần để đảm bảo có tổng ít nhất 11 ký tự; và sau đó các ký tự thứ 1 3và 10thứ 0 (không được lập chỉ mục) tạo thành một cặp duy nhất lấy mod băm 69 và biến nó thành một char có thể in được.

Bây giờ chúng tôi có n. Để tìm nsố Fibonacci thứ, chúng ta có thể sử dụng phương pháp làm tròn , chỉ sử dụng bao nhiêu chữ số chính xác khi chúng ta cần tối đ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

Hãy thử trực tuyến!

Cảnh báo: CÔNG TRÌNH TRỞ THÀNH ĐIỂM NỔI BẬT INACCURACY

JavaScript không có hàm băm dựng sẵn, cũng không có hàm ký tự-ASCII đủ ngắn (String.charCodeAt là ngắn nhất), vì vậy tôi cần tự xác định hàm băm đơn giản.

Đã sử dụng phương pháp làm tròn giống như Chas Brown đã làm sau khi tính toán hàm băm.

Sau cả một ngày vũ phu buộc một thứ tốt hơn được tìm thấy:

b32_to_dec(x.length + x) % 12789 % 24 (* không chính xác điểm nổi)

b32_to_dec(x.length + x) % 353 % 27 (* không chính xác điểm nổi)

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) kết quả

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

Phiên bản không khai thác điểm không chính xác: 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

Hãy thử trực tuyến!

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

Bảng băm

 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