Леонардо Пизанский (ок. 1175 - ок. 1245) более известен как Фибоначчи . Но это на самом деле сокращение от латинского «filius Bonacci» (сын Bonacci), который был составлен в 18 веке (согласно Википедии ).

В этом задании вам дадут порядковый номер (в буквальном смысле) от 1- го до 20- го, и вы должны вернуть соответствующий член в последовательности Фибоначчи .

Суть в том, что порядковый номер будет дан на латыни.

Пример : "двенадцатиперстная кишка" → .$89$

Полная таблица ввода / вывода

 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 с грубым принуждением и используйте волшебную функцию генерации Фибоначчи, чтобы дать ответ.

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

Попробуйте онлайн!

Редактировать: -2 байта за счет улучшенного округления чисел

Изменить: -3 байта с изменением поиска (спасибо за подсказку, @Giuseppe!)

Рубин, 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 и индексирует в таблицу поиска. (Магические числа, найденные грубой силой.)

Чисто , 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, используя преимущество флага переноса, установленного путем сдвига и используемого дополнительно. Магические числа для хеширования были найдены при помощи грубой форсировки с помощью небольшой программы на Си; в FFбайты несчастными отверстия в хэш - таблице;)

Количество байтов: 2-байтовый адрес загрузки, 38-байтовый код, 42-байтовая хеш-таблица для значений.

Онлайн демо

Использование: SYS49152"[ordinal]"например SYS49152"DUODECIMUS". (обратите внимание, что буквы отображаются заглавными буквами в конфигурации C64 по умолчанию).

Важно : перед первым запуском введите NEWкоманду. Это необходимо, потому что команда C64 BASIC работает LOADс некоторыми векторами BASIC, даже при загрузке машинной программы по некоторому абсолютному адресу (как здесь $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 байтов по предложению потолка и Логерна

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)

Попробуйте онлайн!

Генератор Фибоначчи бесстыдно украден из этого ответа .

Разбивает каждое слово на его значимые составные части и отбрасывает остальные (например, в «duodevicesimus» мы заботимся только о «duo ev es» -> «2 - 20» -> abs («2-20») -> 18).

Передает вычисленное значение (от смещения от 1 до 0) в функцию генератора Фибоначчи.

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 байт

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

Попробуйте онлайн!

Во-первых, мы хотим конвертировать из латинского в число n; это достигается путем репликации входной строки достаточное количество раз, чтобы обеспечить общее количество не менее 11 символов; и затем 3rd и 10th символы (с нулевым индексом) образуют уникальную пару, взяв хеш-мод 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

Попробуйте онлайн!

Предупреждение: РАБОТАЕТ ИЗ-ЗА НЕТОЧНОСТИ ПЛАВУЩЕЙ ТОЧКИ

В JavaScript нет ни встроенной хеш-функции, ни достаточно короткой символьно-ASCII-функции ( String.charCodeAtуже самая короткая), поэтому мне нужно самостоятельно определить простую хеш-функцию.

Использовал тот же метод округления, что и Час Браун после вычисления хеша.

После целого дня перебора найдено лучшее:

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