Библия является одной из самых влиятельных книг, когда-либо написанных, и обычно цитируется как самая продаваемая книга всех времен . Он был написан примерно 40 различными авторами за сотни лет до того, как был скомпилирован в его нынешнюю форму. Но в Библии интересно то, как она разделена. Он разделен на 2 разных завета, которые разбиты на 66 небольших книг, каждая из которых разбита на более мелкие главы, каждая из которых разбита на отдельные стихи.

Я подумал, что было бы забавно попытаться закодировать количество глав в каждой книге в кратчайший возможный код. Таким образом, для сегодняшнего испытания вы должны написать программу или функцию, которая принимает одну из книг в качестве входных данных и выводит количество глав в этой книге в соответствии с версией короля Джеймса .

Вы можете использовать IO в любом разумном формате, например, чтение / запись STDIN / STDOUT или файла, аргументы функции / возвращаемые значения, запрос пользователя и т. Д. - все это разрешено. Ввод всегда будет одной из 66 книг Библии и только в нижнем регистре. Это означает, что если вам дается какой-либо другой ввод, допускается неопределенное поведение. Поскольку существует только 66 возможных входов и выходов, все они представлены здесь, согласно странице Википедии о библейских главах в версии короля Джеймса :

genesis         50
exodus          40
leviticus       27
numbers         36
deuteronomy     34
joshua          24
judges          21
ruth            4
1 samuel        31
2 samuel        24
1 kings         22
2 kings         25
1 chronicles    29
2 chronicles    36
ezra            10
nehemiah        13
esther          10
job             42
psalms          150
proverbs        31
ecclesiastes    12
song of solomon 8
isaiah          66
jeremiah        52
lamentations    5
ezekiel         48
daniel          12
hosea           14
joel            3
amos            9
obadiah         1
jonah           4
micah           7
nahum           3
habakkuk        3
zephaniah       3
haggai          2
zechariah       14
malachi         4
matthew         28
mark            16
luke            24
john            21
acts            28
romans          16
1 corinthians   16
2 corinthians   13
galatians       6
ephesians       6
philippians     4
colossians      4
1 thessalonians 5
2 thessalonians 3
1 timothy       6
2 timothy       4
titus           3
philemon        1
hebrews         13
james           5
1 peter         5
2 peter         3
1 john          5
2 john          1
3 john          1
jude            1
revelation      22

Поскольку эта задача заключается в поиске оптимального способа кодирования каждого названия книги и количества глав, использование любых встроенных функций, дающих информацию о Библии, не допускается. Однако, поскольку было бы интересно узнать, на каких языках есть такие встроенные функции, не стесняйтесь поделиться второй неконкурентной версией вместе с вашим ответом. Получение информации из внешних источников также недопустимо (ни одна из стандартных лазеек не допускается, но я подумал, что было бы полезно явно упомянуть об этом).

Как обычно, это задача для игры в гольф , поэтому постарайтесь создать как можно более короткую программу (измеряемую в байтах). Удачи в гольф!

Желе , 127 байт

“£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘
OḄ;407;270;“ọḷḊḲɦ‘%/i@“¡Ṙ×!⁸Ọ5`ỊV-ṙQȷṖÞ(sĿȮ^k³M"ɓmEf¤*0C[ạƇŻȥ#BṚñİmZẓeȦUƈ!ċ€@Ȧʋ)ƙḅyẉ’b158¤ị¢

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

Тестовые случаи

Как это устроено

По сути, это пытается преобразовать орды ввода символов в двоичное значение, например "joel"-> [106, 111, 101, 108]->2^3*106 + 2^2*111 + 2^1*101 + 2^0*108 .

Затем это значение берется мод 407, затем мод 270, затем [еще несколько модов], затем мод 160. Это полезно, потому что он отображает все 66 строковых входов в целые числа от 0 до 158 (удачно в финальном моде).

Целое число индексируется из списка целых чисел, “ọḷḊḲɦ...ƙḅyẉ’b158¤чтобы найти значение nтак, чтобы ввод имел nнаименьшее число глав. Джоэл, случается, имеет 7-е наименьшее количество глав.

Это значение nдополнительно индексируется в списке, “£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘чтобы найти точное количество глав.

Возможное улучшение: входные данные с одинаковым количеством глав могут хэшировать одно и то же значение из модов (коллизия 0% не требуется), но я не учел это в моей программе для определения последовательности модов.

Excel, 373 байта

Повторное использование подхода @ Миши из ответа Mathematica ( 6a+b+8c+5d+3e modulo 151):

=CHOOSE(MOD(6*CODE(LEFT(A1,1))+CODE(MID(A1,2,1))+8*CODE(MID(A1,3,1))+5*CODE(MID(A1&A1,4,1))+3*CODE(MID(A1&A1,5,1)),151)+1,30,,,,27,,,,3,12,,,9,,149,,,28,,,13,,,35,3,,35,7,,8,,20,,49,23,13,4,,,4,,,,,,,2,,,39,,,15,3,,3,9,,12,27,,,,,,51,15,,,,70,,65,,21,11,,,4,,24,,,6,,2,1,,,,,,2,,,30,,,,,,23,,,33,,20,,,15,,,4,,4,,,12,2,,2,47,23,,2,,,,,41,,,3,,,5,,,,,11,,21,5,,,,5,2,3,26)+1

Lookup возвращает главы -1, а затем добавить одну. Это меняется 10в 9два раза, и ,1,в ,,4 раза.

Обновлен до старого подхода. Excel, 460 401 байт

Сохранить как CSV, имя книги вводится в конце первой строки ( C1), результат отображается в C2:

1c,16,revelation
1co,29,"=VLOOKUP(LEFT(C1,1)&MID(C1,3,1)&MID(C1,6,1),A:B,2)"
1j,5
1k,22
1p,5
1s,31
1t,6
1ts,5
2c,13
2co,36
2j,1
2k,25
2p,3
2s,24
2t,4
2ts,3
3j,1
a,9
at,28
c,4
d,12
du,34
e,12
ee,48
eh,6
eo,40
er,10
g,6
gn,50
h,3
hbw,13
hg,2
hs,14
i,66
j,42
jd,1
jds,21
je,3
jh,21
jm,5
jn,4
jr,52
js,24
lm,5
lv,27
m,7
ml,4
mr,16
mt,28
n,3
nhi,13
nm,36
o,1
p,150
pi,1
pip,4
po,31
r,16
rt,4
rv,22
s,8
t,3
zc,14
zp,3

Для таблицы поиска мы можем опустить et 10и l 24потому, что они совпадают er 10и js 24соответственно.

JavaScript (ES6), 251 197 байт

s=>`-  cE1$ " +%&  %  &!!· $!#&!!)!'=6 &!6".!  -!!Q$"/  779@@= % & $'1 U( I>!!  K * "S< :  9$!C %  . $. 9E1/ %!!'" + $ % `.split`!`.join`   `.charCodeAt(parseInt(s[2]+s[0]+s[5],36)%913%168%147)-33

Тестовое задание

let f =

s=>`-  cE1$ " +%&  %  &!!· $!#&!!)!'=6 &!6".!  -!!Q$"/  779@@= % & $'1 U( I>!!  K * "S< :  9$!C %  . $. 9E1/ %!!'" + $ % `.split`!`.join`   `.charCodeAt(parseInt(s[2]+s[0]+s[5],36)%913%168%147)-33

o.innerText = [
  ["genesis",         50 ],
  ["exodus",          40 ],
  ["leviticus",       27 ],
  ["numbers",         36 ],
  ["deuteronomy",     34 ],
  ["joshua",          24 ],
  ["judges",          21 ],
  ["ruth",            4  ],
  ["1 samuel",        31 ],
  ["2 samuel",        24 ],
  ["1 kings",         22 ],
  ["2 kings",         25 ],
  ["1 chronicles",    29 ],
  ["2 chronicles",    36 ],
  ["ezra",            10 ],
  ["nehemiah",        13 ],
  ["esther",          10 ],
  ["job",             42 ],
  ["psalms",          150],
  ["proverbs",        31 ],
  ["ecclesiastes",    12 ],
  ["song of solomon", 8  ],
  ["isaiah",          66 ],
  ["jeremiah",        52 ],
  ["lamentations",    5  ],
  ["ezekiel",         48 ],
  ["daniel",          12 ],
  ["hosea",           14 ],
  ["joel",            3  ],
  ["amos",            9  ],
  ["obadiah",         1  ],
  ["jonah",           4  ],
  ["micah",           7  ],
  ["nahum",           3  ],
  ["habakkuk",        3  ],
  ["zephaniah",       3  ],
  ["haggai",          2  ],
  ["zechariah",       14 ],
  ["malachi",         4  ],
  ["matthew",         28 ],
  ["mark",            16 ],
  ["luke",            24 ],
  ["john",            21 ],
  ["acts",            28 ],
  ["romans",          16 ],
  ["1 corinthians",   16 ],
  ["2 corinthians",   13 ],
  ["galatians",       6  ],
  ["ephesians",       6  ],
  ["philippians",     4  ],
  ["colossians",      4  ],
  ["1 thessalonians", 5  ],
  ["2 thessalonians", 3  ],
  ["1 timothy",       6  ],
  ["2 timothy",       4  ],
  ["titus",           3  ],
  ["philemon",        1  ],
  ["hebrews",         13 ],
  ["james",           5  ],
  ["1 peter",         5  ],
  ["2 peter",         3  ],
  ["1 john",          5  ],
  ["2 john",          1  ],
  ["3 john",          1  ],
  ["jude",            1  ],
  ["revelation",      22 ]
]
.every(s => (log += s[0] + ' --> ' +  (res = f(s[0])) + '\n', res == s[1]), log = '')
? log + '\nSUCCESS' : log + '\nFAIL'

<pre id=o></pre>

Отформатировано и прокомментировано

s =>                                 // s = book name
  `-  cE1$ " +%&  %  &!!· (...)`     // data string (truncated)
  .split`!`.join`   `                // inflate padding characters '!' -> 3 spaces
  .charCodeAt(                       // read the ASCII code at the position found by
    parseInt(s[2] + s[0] + s[5], 36) // parsing 3 characters of the input in this exact
    % 913 % 168 % 147                // order as base 36 and applying three consecutive
  ) - 33                             // modulo operations, then subtract 33

Mathematica: 323 294 байта

Uncompress["1:eJxTTMoPSpvOwMBQzAIkfDKLSzJlgAwCBEhtJi8qwQUnpqESsqgEHyqhAjePBc7lgBOccEIUThiBCAm4AayECUZUghmV0EAlBFAdxILqN17CgWMCNwUn4QQnxEAEDyqBcLgkKsGO6gUmLAROX8rjJSRQCSU4IYpKILzAiDfEebG4wADVDmZchBYqgRYVbLgIRPiJ4VXHDDdKGuZ9AAP6TUg="][[Mod[ToCharacterCode@StringTake[#<>#,5].{6,1,8,5,3},151,1]]]&

Как это устроено

Для книги , начиная с кодами символов a, b, c, d, e(обтекание при необходимости) вычисляет6a+b+8c+5d+3e по модулю 151, который случается быть уникальным, а затем смотрит на количество глав в сжатом списке длина 151. (Неиспользуемые в списке заполнены дубликатами предыдущей записи. Это поощряет кодирование длин серий, может быть? В любом случае, это помогает.)

Спасибо @numbermaniac за идею сжатия списка, которую сложно назвать цифрой, но это огромная часть улучшения.

Старая версия: Mathematica, 548 435 407 байт

Join["111112333333344444455555666789"~(p=StringPartition)~1,"1010121213131314141616162121222224242425272828293131343636404248505266"~p~2,{"150"}][[Max@StringPosition["2jn3jnjduoaapimhgi2pe2tshbkjeonhntttzpn2toclsjnjmlhpiprtu1jn1pe1tsjmjlmt1toehiglimcmsnoaometrerzdnlecs2cihbwnhihshzcr1cimrarmsjhojds1kgrva2sujsalku2kglviatcmte1co1supordur2conmreosjbbeeegnijriiahpas",""<>#&@Characters[#<>#][[{1,3,6}]]]/3]]&

Как это устроено

Мы преобразуем каждое имя nameв символы 1, 3 и 6 из namename(например, leviticusстановится lvi, jobстановится jbb), прежде чем искать его.

Список, в котором мы смотрим, немного сжат, сложив 1-значные и 2-значные номера глав вместе в строки.

Mathematica: 40 байтов, не конкурирует

WolframAlpha["# chapters "<>#,"Result"]&

Да.

Python 2 , 244 183 байта

lambda n:ord('A("4,|O|;|>||_ /\xb5$+_>| _7|a|5-##_"_G"_/|7) $_$-|<|$_"&|||_;S_% |:_45_#||#|%7"_,_\'_)|_"|C_#|/_I|$_ "|,|_%|_8_Q|+||||_!|_C#'.replace('|','__')[hash(n)%839%434%152])-31

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

Желе ,  117 115  114 байтов

OP%⁽µW%⁽£İ%237
“ĿḊƘ⁹ƙƬṂ;ɓṭ6-ạʋ⁵%$Ẋf,¥ÆÑƈø¬ȦṘd⁾“ʂụṿⱮẆƊ¦ẠLjƒ~Ḅr©“Ẏw|!¡¢o“ŻɗṢ“3ɠ‘Zċ€ÇTḢị“£ẆJQ+k⁽’ḃ6¤+\;“£¬®µıñø"BƝ¤‘¤

Попробуйте онлайн! или увидеть набор тестов

Как?

Хэширует произведение порядковых чисел символов входной строки, беря три два три остатка деления, ищет результат в списке списков и использует найденный индекс, чтобы найти результат в списке длин книг.

При поиске хеш-функции я учитывал только те, которые давали не более одного сегмента с любыми результатами более 255, чтобы разрешить индексацию кодовой страницы, а затем выбирал те, которые минимизировали общее количество значений для кодирования (после удаления «ошибочного» сегмента или если ни одного не было самого длинного ведра). Из 66 с тремя модулями я нашел 59 ( %731%381%258) и 58 ( %731%399%239), а затем один с 56 записями ( %1241%865%251) [делающий для 117 байтов] ... Затем я нашел 58, используя только два остатка ( %1987%251) [делая для 115 байтов]
.. Затем я нашел 55, используя три остатка, которые при добавлении двух фиктивных записей позволяют дополнительно сжать список поиска ...

Код:

1.

“ĿḊƘ⁹ƙƬṂ;ɓṭ6-ạʋ⁵%$Ẋf,¥ÆÑƈø¬ȦṘd⁾“ʂụṿⱮẆƊ¦ẠLjƒ~Ḅr©“Ẏw|!¡¢o“ŻɗṢ“3ɠ‘

список из пяти списков индексов кодовых страниц ( “...“...“...“...“...“...‘):

[[199,193,148,137,161,152,179,59,155,224,54,45,211,169,133,37,36,208,102,44,4,13,16,156,29,7,190,204,100,142],[167,225,226,149,207,145,5,171,76,106,158,126,172,114,6],[209,119,124,33,0,1,111],[210,157,183],[51,159]]

Это транспонируется с использованием атома, Zчтобы получить ведра; назовите это B:

[[199,167,209,210,51],[193,225,119,157,159],[148,226,124,183],[137,149,33],[161,207,0],[152,145,1],[179,5,111],[59,171],[155,76],[224,106],[54,158],[45,126],[211,172],[169,114],[133,6],37,36,208,102,44,4,13,16,156,29,7,190,204,100,142]

( 0и 1являются фиктивными ключами, позволяющими[179,5,111] быть двумя дальше вправо - для транспонирования требуются более длинные записи слева)

2.

“£ẆJQ+k⁽’ḃ6¤+\;“£¬®µıñø"BƝ¤‘¤

Назовите это C (количество глав) - это список целых чисел:

[1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52,2,7,8,9,25,27,29,34,66,150,3]

и строится следующим образом (поэтому два фиктивных ключа выше позволяют располагаться 10,12,13в порядке возрастания):

“£ẆJQ+k⁽’ḃ6¤+\;“£¬®µıñø"BƝ¤‘¤
                            ¤ - nilad followed by link(s) as a nilad:
           ¤                  -   nilad followed by link(s) as a nilad:
“£ẆJQ+k⁽’                     -     base 250 number = 935841127777142
         ḃ6                   -     converted to bijective base 6 = [1,3,1,1,4,2,1,1,2,5,1,2,4,3,5,4,2,6,2,2]
            +\                -     cumulative reduce with addition = [1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52]
               “£¬®µıñø"BƝ¤‘  -   code-page indices = [2,7,8,9,25,27,29,34,66,150,3]
              ;               -   concatenate = [1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52,2,7,8,9,25,27,29,34,66,150,3]

Теперь упрощенная версия кода:

OP%⁽µW%⁽£İ%237 - Link 1, hash function: list of characters   e.g. "genesis"
O              - cast to ordinals             [103,101,110,101,115,105,115]
 P             - product                                    160493569871250
   ⁽µW         - base 250 literal                                      3338
  %            - modulo                                                1050
       ⁽£İ     - base 250 literal                                      1699
      %        - modulo                                                1050
           237 - literal                                                237
          %    - modulo                                                 102

Bċ€ÇTḢịC - Main link: list of characters                     e.g. "genesis"
B        - the list of buckets, B, described  in (1) above
   Ç     - call the last link as a monad (get the hashed value)         102
 ċ€      - count for €ach - yields 29 zeros and a one or 30 zeros       [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]
    T    - truthy indexes - yields a list of length one or zero         [19]
     Ḣ   - head - extracts that value or zero if it was empty            19  ----------------------------------------------v
       C - the list of chapter lengths, C, described in (2) above       [1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52,2,7,8,9,25,27,29,34,66,150,3]
      ị  - index (the head value) into (the chapter list, c)             50
         -       - 1-indexed and modular so 0 yields 3 (the rightmost)

Python 2 , 438 429 416 411 409 байт

lambda s:[c for x,c in zip('A|m|C|h|2|th|2 Co|D|y|E|Ep|Ec|x|ze|G|Ge|H|gg|He|Ho|I|Jo|oe|oh|na|sh|Ju|dg|Ja|Je| J|1 J|K|2 K|L|Le|Lu|M|ch|rk|tt|N|Ne|Nu|O|P|Pr|Ph|pp|Pe|2 P|R|Ro|Ru|S|Sa|2 S|T| T|2 T| Ti|2 Ti|Z|Zep'.split('|'),(28,9,4,29,36,16,13,12,34,10,6,12,40,48,6,50,3,2,13,14,66,42,3,21,4,24,1,21,5,52,1,5,22,25,5,27,24,7,4,16,28,3,13,36,1,150,31,1,4,5,3,22,16,4,8,31,24,3,5,3,6,4,14,3))if x in s.title()][-1]

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

Работает, изменив ввод на Case Case и найдя последнюю подходящую подстроку в списке.

[('A', 28), ('m', 9), ('C', 4), ('h', 29), ('2', 36), ('th', 16), ('2 Co', 13), ...

Например. '1 samuel' -> '1 Samuel'который соответствует ('m', 9), ('2', 36), ('S', 8), ('Sa', 31), ('2 S', 24). Последнее совпадение ('2 S', 24), поэтому ответ24

6502 машинный код (C64), 204 байта

00 C0 20 FD AE 20 9E AD 85 FD 20 A3 B6 A9 1E 85 FB A9 00 85 FC A8 B1 22 18 69
4A 65 FC 45 FB 85 FC E6 FB C8 C4 FD D0 EE A5 FC 4A 4A 4A 4A A8 A5 FC 29 0F 19
BA C0 A8 BE 3D C0 A9 00 4C CD BD 16 34 42 0D 01 00 04 03 04 1C 0A 00 06 15 07
00 16 00 22 03 02 0E 00 24 00 00 01 00 08 03 00 1C 03 01 00 00 00 00 00 03 03
00 00 00 24 10 1F 18 0E 10 00 00 00 32 30 1F 2A 00 0D 00 05 00 1B 00 0A 00 01
28 00 00 0C 96 00 10 00 00 00 18 00 00 03 00 00 00 00 00 00 15 09 00 05 00 04
00 00 04 00 00 04 00 00 18 00 1D 05 00 00 19 00 0D 00 00 06 06 0C 00 00 00 00
05 00 01 00 05 00 04 30 10 20 10 40 70 00 00 20 50 00 10 60 30 20

Пояснение :

Ключевым моментом здесь является использование специальной функции хеширования, которая отображает без коллизий значения 0 к 125*). Номера глав затем помещаются в таблицу 126 байтов. Хеширование выполняется в полных 8 битах, окончательное значение корректируется путем поиска больших полубайтов в еще одной таблице, таким образом комбинируя различные верхние полубайты, где нижние полубайты не сталкиваются.

Вот закомментированный список разборки части кода:

.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate argument
.C:c006  85 FD       STA $FD            ; remember string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string ....
.C:c00b  A9 1E       LDA #$1E           ; initial xor key for hash
.C:c00d  85 FB       STA $FB
.C:c00f  A9 00       LDA #$00           ; initial hash value
.C:c011  85 FC       STA $FC
.C:c013  A8          TAY
.C:c014   .hashloop:
.C:c014  B1 22       LDA ($22),Y        ; load next string character
.C:c016  18          CLC                ; clear carry for additions
.C:c017  69 4A       ADC #$4A           ; add fixed offset
.C:c019  65 FC       ADC $FC            ; add previous hash value
.C:c01b  45 FB       EOR $FB            ; xor with key
.C:c01d  85 FC       STA $FC            ; store hash value
.C:c01f  E6 FB       INC $FB            ; increment xor key
.C:c021  C8          INY                ; next character
.C:c022  C4 FD       CPY $FD            ; check for string length
.C:c024  D0 EE       BNE .hashloop      ; end of string not reached -> repeat
.C:c026   .hashadjust:
.C:c026  A5 FC       LDA $FC            ; load hash
.C:c028  4A          LSR A              ; shift left four times
.C:c029  4A          LSR A
.C:c02a  4A          LSR A
.C:c02b  4A          LSR A
.C:c02c  A8          TAY                ; and copy to y index register
.C:c02d  A5 FC       LDA $FC            ; load hash again
.C:c02f  29 0F       AND #$0F           ; mask low nibble
.C:c031  19 BA C0    ORA $C0BA,Y        ; and add high nibble from table
.C:c034  A8          TAY                ; copy to y index register
.C:c035  BE 3D C0    LDX .chapters,Y    ; load chapter number from table
.C:c038  A9 00       LDA #$00           ; accu must be 0 for OS function:
.C:c03a  4C CD BD    JMP $BDCD          ; print 16bit value in A/X

после этого следует таблица номеров глав и, наконец, таблица высоких полубайтов для значения хеш-функции.

Онлайн демо

Использование: sys49152,"name" например sys49152,"genesis"(вывод50 ).

Важно: если программа была загружена с диска (как в онлайн-демонстрации), введитеnew сначала введите команду! Это необходимо, потому что при загрузке машинной программы перегружаются некоторые основные указатели C64.

Подсказка о корпусе: в режиме C64 по умолчанию ввод будет отображаться в верхнем регистре. Эта является на самом деле в нижнем регистре, но C64 имеет два режима работы, а в верхнем по умолчанию / графический режим, строчные символы отображаются в виде заглавных и прописные символы отображаются в виде графических символов.

*) конечно, это не так плотно, как могло бы быть ... ну, может быть, я найду еще лучшее решение позже;)

Java 8 623 597 590 байт

s->{int i=s.chars().map(c->c*c*c).sum()/13595;return s.contains("tt")?28:i<258?42:i<355?1:i<357?3:i<362?16:i<366?28:i<369?21:i<375?9:i<377?24:i<380?5:i<382?1:i<386?10:i<402?7:i<436?4:i<438?5:i<439?14:i<461?3:i<463?2:i<477?22:i<478?25:i<490?5:i<491?3:i<493?12:i<500?66:i<545?3:i<546?1:i<548?21:i<562?4:i<568?24:i<570?10:i<572?31:i<573?24:i<582?16:i<583?150:i<607?40:i<629?48:i<639?50:i<663?13:i<675?3:i<677?36:i<679?52:i<734?1:i<735?6:i<736?4:i<775?14:i<785?6:i<796?3:i<800?31:i<812?6:i<876?27:i<910?29:i<911?36:i<940?22:i<1018?4:i<1035?16:i<1036?13:i<1066?12:i<1092?34:i<1229?5:i<1230?3:8;}

-7 байт благодаря @Nevay , изменив цикл for на поток.

Можно определенно больше играть в гольф. Просто нужно сделать еще несколько испытаний.
Это может быть не самый короткий ответ из длинных, и его можно сыграть в гольф, перенеся какой-то существующий ответ, но я все еще горжусь тем, что смог придумать что-то сам ... :)

Объяснение:

Попробуй это здесь.

1. Принимает мощность 3 каждого символа (как значение ASCII) во входной строке
2. Принимает сумму тех
3. Делит результат на 13595 как целочисленное деление (в Java это автоматически обрезает / выравнивает результат).
4. Это оставляет 65 уникальных значений (только habakkukи matthewоба имеют значение 674)
5. И затем один гигантский троичный - если вернуть правильный результат (с несколькими значениями, объединяющимися в одном троичном выражении, где это возможно ( 381и 382оба 1; 425и 436оба 4; 649и 663оба 13; 952и 1018оба 4; 1122и 1229оба 5).