เลโอนาร์โดแห่งปิซา (แคลิฟอร์เนีย ค.ศ. 1175 - แคลิฟอร์เนียปี 1245) เป็นที่รู้จักกันดีในนาม Fibonacci แต่จริงๆแล้วนี่เป็นคำย่อสำหรับ "filius Bonacci" ภาษาละติน (ลูกชายของ Bonacci) ซึ่งสร้างขึ้นในช่วงศตวรรษที่ 18 (อ้างอิงจากWikipedia )

ในความท้าทายนี้คุณจะได้รับหมายเลขลำดับ (ในความรู้สึกที่แท้จริง) ระหว่าง1เซนต์และ20ปีบริบูรณ์และคุณจะต้องกลับมาในระยะที่สอดคล้องกันในลำดับฟีโบนักชี

การหมุนคือเลขลำดับจะได้รับเป็นภาษาละติน

ตัวอย่าง : "duodecimus" → $89$ 89

ตาราง I / O แบบเต็ม

 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 , 91 86 ไบต์

ค้นหาดัชนีของผลรวมของไบต์ในตารางการค้นหา UTF8 ที่ถูกบังคับและใช้ฟังก์ชันสร้าง Fibonacci เวทมนต์เพื่อให้คำตอบ

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

ลองออนไลน์!

แก้ไข: -2 ไบต์โดยการปัดเศษตัวเลขที่ดีขึ้น

แก้ไข: -3 ไบต์ด้วยการเปลี่ยนแปลงการค้นหา (ขอบคุณสำหรับคำใบ้ @Giuseppe!)

Ruby, 104 93 ไบต์

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

ลองออนไลน์!

เพียงนำผลรวมของไบต์, โมดูโล 192 โมดูโล 76 โมดูโล 23, และดัชนีลงในตารางการค้นหา (ตัวเลข Magic พบโดยกำลังดุร้าย)

สะอาด , 87 ไบต์

ยกเว้นทั้งหมดยกเว้น \nจะถือว่าเป็นหนึ่งไบต์เนื่องจากคอมไพเลอร์ของดีกับค่าดิบที่แท้จริง (TIO และ SE มีปัญหากับมันไม่ถูกต้อง UTF-8 และดังนั้นมันจึงหลบหนีที่นี่)

FryAmTheEggmanทำการสาธิต / วิธีแก้ปัญหาที่ดี: ที่นี่

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]

ลองออนไลน์!

กำหนดฟังก์ชัน$ :: [Char] -> Intซึ่งใช้ความเป็นเอกลักษณ์ในการรวมค่าอักขระตัวพิมพ์ใหญ่เพื่อกำหนดคำใดในลำดับ (สร้างโดยฟังก์ชันตัวช่วยk) เพื่อส่งคืน

รหัสเครื่อง 6502 (C64), 82 ไบต์

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

สิ่งนี้ใช้การแปลงแป้นพิมพ์ (แน่นอน) แต่ได้รับการปรับให้เหมาะสำหรับการนำไปใช้งานสั้น ๆ ใน 6502 โดยใช้ประโยชน์จากชุดแฟล็กสำหรับพกพาโดยการเลื่อนและใช้เพิ่มเติม ตัวเลขมหัศจรรย์สำหรับการแปลงแป้นพิมพ์ถูกค้นพบโดยการบังคับเดรัจฉานด้วยโปรแกรม C ตัวเล็ก ๆ ; FFไบต์หลุมที่โชคร้ายในตารางแฮช;)

จำนวนไบต์: ที่อยู่โหลด 2 ไบต์, รหัส 38 ไบต์, 42 ไบต์ hashtable สำหรับค่า

การสาธิตออนไลน์

การใช้งาน: ยกตัวอย่างเช่นSYS49152"[ordinal]" SYS49152"DUODECIMUS"(หมายเหตุตัวอักษรจะปรากฏเป็นตัวพิมพ์ใหญ่ในการกำหนดค่าเริ่มต้น C64)

สำคัญ : ก่อนที่จะเริ่มแรกให้ออกNEWคำสั่ง สิ่งนี้เป็นสิ่งจำเป็นเนื่องจากLOADคำสั่งพื้นฐานของ C64 เล่นซอกับเวกเตอร์พื้นฐานบางตัวแม้เมื่อโหลดโปรแกรมเครื่องไปยังที่อยู่แบบสัมบูรณ์ (เช่นที่นี่$C000/49152 )

ความคิดเห็นถอดแยกชิ้นส่วน :

         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

ชุดทดสอบ C64 BASIC V2

(มีโปรแกรมเครื่องเป็นDATAบรรทัด)

การสาธิตออนไลน์

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 ไบต์

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

ลองออนไลน์!

ใช้ตารางการค้นหาในสตริงเช่นเดียวกับตัวสร้างลำดับฟีโบนักชีสั้น ๆ

C (gcc) , 135 129 ไบต์

6 ไบต์ลดลงตามคำแนะนำของ ceilingcat และ 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;}

ลองออนไลน์!

คำอธิบาย:

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 ไบต์

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

ชุดทดสอบ

หมายเหตุ:เนื่องจากรหัสใช้อักขระที่ไม่สามารถพิมพ์ได้บางอย่างมันอาจไม่แสดงอย่างถูกต้องใน Stack Exchange ลิงก์ที่ให้นั้นนำไปสู่แหล่งที่ทำงานและคัดลอกได้

เรื่องยาวสั้น, ให้ผลลัพธ์ที่ไม่ซ้ำกันสำหรับปัจจัยการผลิตที่ได้รับการยอมรับทั้งหมดQ[0]+Q[618%len(Q)]Q

Python 2 , 292 ไบต์

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)

ลองออนไลน์!

เครื่องกำเนิด Fibonacci ถูกขโมยลงคอจากคำตอบนี้

แบ่งคำแต่ละคำออกเป็นส่วนที่มีความหมายและละทิ้งส่วนที่เหลือ (ใน "duodevicesimus" ตัวอย่างเช่นเราสนใจเฉพาะ "duo ev es" -> "2 - 20" -> abs ("2-20") -> 18)

ส่งค่าที่คำนวณได้ (ลบ 1 ถึง 0-offset) ไปยังฟังก์ชันตัวสร้าง Fibonacci

คำอธิบายไม่ดี

# 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 ไบต์

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

ลองออนไลน์!

ครั้งแรกที่เราต้องการแปลงมาจากภาษาละตินเป็นตัวเลขn; สิ่งนี้สามารถทำได้โดยการเรพลิเคทสตริงอินพุตให้เพียงพอเพื่อให้แน่ใจว่ามีอักขระทั้งหมดอย่างน้อย 11 ตัว และจากนั้น310อักขระrd และth (ดัชนีเป็นศูนย์) จะสร้างคู่ที่ไม่ซ้ำกันใช้ hash mod 69 และเปลี่ยนให้เป็นอักขระที่พิมพ์ได้

nตอนนี้เรามี ในการค้นหาnหมายเลขฟีโบนักชีครั้งที่หนึ่งเราสามารถใช้วิธีการปัดเศษโดยใช้ความแม่นยำเพียงหลักเดียวเท่าที่เราต้องการได้ถึง Fib (20)

JavaScript (Node.js) , 100 97 95 92 91 ไบต์

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

ลองออนไลน์!

คำเตือน: ใช้งานได้เนื่องจากความไม่แม่นยำของจุดลอยตัว

จาวาสคริปต์ไม่มีฟังก์ชั่นแฮชในตัวหรือฟังก์ชั่น character-to-ASCII สั้น ๆ ( String.charCodeAtสั้นที่สุดแล้ว) ดังนั้นฉันจำเป็นต้องกำหนดฟังก์ชั่นแฮชแบบง่ายด้วยตัวเอง

ใช้วิธีการปัดเศษแบบเดียวกับที่ Chas Brown ทำหลังจากคำนวณแฮช

หลังจากทั้งวันของการเดรัจฉานบังคับทั้งวันพบที่ดีกว่า:

b32_to_dec(x.length + x) % 12789 % 24 (* ความไม่แม่นยำจุดลอยตัว)

b32_to_dec(x.length + x) % 353 % 27 (* ความไม่แม่นยำจุดลอยตัว)

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) ผลลัพธ์

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

รุ่นที่ไม่มีการใช้ประโยชน์จากความไม่ถูกต้องของจุดลอยตัว: 95 ไบต์

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

ลองออนไลน์!

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

ตารางแฮช

 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