La Biblia es uno de los libros más influyentes jamás escritos, y comúnmente citado como el libro más vendido de todos los tiempos . Fue escrito por aproximadamente 40 autores diferentes durante cientos de años antes de compilarse en su forma actual. Pero lo interesante de La Biblia es la forma en que está dividida. Se divide en 2 testamentos diferentes, que se dividen en 66 libros más pequeños, que se dividen en capítulos más pequeños, que se dividen en versos individuales.

Pensé que sería un desafío divertido tratar de codificar el número de capítulos de cada libro en el código más corto posible. Entonces, para el desafío de hoy, debe escribir un programa o función que tome uno de los libros como entrada y genere el número de capítulos en ese libro de acuerdo con la versión King James .

Puede tomar IO en cualquier formato razonable, por ejemplo, leer / escribir STDIN / STDOUT o un archivo, argumentos de función / valores de retorno, preguntar al usuario, etc. están permitidos. La entrada siempre será uno de los 66 libros de La Biblia, y solo en minúsculas. Esto significa que si recibe cualquier otra entrada, se permite un comportamiento indefinido. Dado que solo hay 66 posibles entradas y salidas, todas se proporcionan aquí, de acuerdo con la página de Wikipedia en los capítulos de la Biblia en The King James Version :

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

Dado que este desafío se trata de encontrar la manera óptima de codificar el nombre de cada libro y el recuento de capítulos, no se permite el uso de ningún componente integrado que brinde información sobre la Biblia. Sin embargo, dado que sería interesante ver qué idiomas tienen tales incorporados, no dude en compartir una segunda versión no competitiva junto con su respuesta. Tampoco está permitido obtener información de fuentes externas (ninguna de las lagunas estándar está permitida, pero pensé que sería útil mencionarla explícitamente).

Como de costumbre, este es un desafío de código de golf , así que trate de hacer el programa más corto posible (medido en bytes) como pueda. Diviértete jugando al golf!

Jalea , 127 bytes

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

Pruébalo en línea!

Casos de prueba

Cómo funciona

Básicamente, esto intenta convertir los ords de los caracteres ingresados ​​en un valor binario, por ejemplo "joel"-> [106, 111, 101, 108]-> 2^3*106 + 2^2*111 + 2^1*101 + 2^0*108.

Luego, este valor se toma mod 407, luego mod 270, luego [algunas modificaciones más], luego mod 160. Esto es útil porque asigna las 66 entradas de cadena a enteros entre 0 y 158 (afortunado en el mod final).

El entero se indexa desde la lista de enteros “ọḷḊḲɦ...ƙḅyẉ’b158¤ para encontrar el valor de ntal manera que la entrada tenga el nmenor número de capítulos. Joel tiene el séptimo número mínimo de capítulos.

Este valor de n se indexa más en la lista “£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘para encontrar el número exacto de capítulos.

Posible mejora: las entradas con el mismo número de capítulos pueden hacer hash con el mismo valor de los mods (no es necesaria una colisión del 0%), pero no lo tomé en cuenta en mi programa para determinar la secuencia de los mods.

Excel, 373 bytes

Reutilizando el enfoque de @ Misha de la respuesta de 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

La búsqueda devuelve capítulos -1y luego agrega el uno. Esto cambia 10en 9dos veces y ,1,en ,,4 veces.

Actualizado al antiguo enfoque. Excel, 460 401 bytes

Guardar como CSV, Nombre del libro ingresado al final de la primera línea ( C1), el resultado se muestra en 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

Para la tabla de búsqueda, podemos omitir et 10y l 24porque estos coinciden en er 10y js 24respectivamente.

JavaScript (ES6), 251 197 bytes

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

Prueba

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>

Formateado y comentado

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 bytes

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

Cómo funciona

Para un libro que comienza con códigos de caracteres a, b, c, d, e(envolver en torno a si es necesario) computa6a+b+8c+5d+3e modulo 151, que pasa a ser único, y luego mira hacia arriba el número de capítulos en una lista comprimida de longitud 151. (entradas no utilizadas en la lista están completado con duplicados de la entrada anterior. Esto fomenta la codificación de longitud de ejecución, tal vez? De todos modos, ayuda.)

Gracias a @numbermaniac por la idea de compresión de la lista, que es difícil asignar un número pero es una gran parte de la mejora aquí.

Versión anterior: Mathematica, 548 435 407 bytes

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

Cómo funciona

Convertimos cada nombre namea los caracteres 1, 3 y 6 de namename(por ejemplo , se leviticusconvierte lvi, se jobconvierte jbb) antes de buscarlo.

La lista en la que buscamos está ligeramente comprimida al unir los números de capítulo de 1 y 2 dígitos en cadenas.

Mathematica: 40 bytes, no competitivos

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

Si.

Python 2 , 244183 bytes

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

Pruébalo en línea!

Gelatina ,  117115  114 bytes

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

Pruébalo en línea! o ver el conjunto de pruebas

¿Cómo?

Comprime el producto de los ordinales de los caracteres de la cadena de entrada tomando tres dos tres restos de división, busca el resultado en una lista de listas y usa el índice encontrado para buscar el resultado en una lista de longitudes de libros.

Al encontrar una función hash, solo consideré aquellos que dieron como resultado un grupo con resultados superiores a 255 para permitir la indexación de la página de códigos y luego elegí los que minimizaran el número total de valores para codificar (después de eliminar el grupo "ofensivo" o si ninguno existió el cubo más largo). De 66 con tres módulos encontré un 59 ( %731%381%258) a 58 (%731%399%239 ) y luego uno con 56 entradas ( %1241%865%251) [haciendo 117 bytes] ... Luego encontré un 58 usando solo dos restos ( %1987%251) [haciendo 115 bytes]
.. .entonces encontré un 55 usando tres restos, que cuando se agregan dos entradas ficticias permite una mayor compresión de la lista de búsqueda ...

El código:

1)

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

es una lista de cinco listas de índices de página de códigos ( “...“...“...“...“...“...‘):

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

Esto se transpone usando el átomo Zpara obtener los cubos; llama a esto 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]

(el 0y1 son las teclas ficticias, que permiten[179,5,111] que estén dos más a la derecha; la transposición requiere entradas más largas a la izquierda)

2)

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

Llame a esto C (el capítulo cuenta): es una lista de enteros:

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

y se construye de la siguiente manera (las dos teclas ficticias anteriores permiten, por lo tanto, 10,12,13estar en orden ascendente):

“£Ẇ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]

Ahora la versión simplificada del código es:

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 bytes

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]

Pruébalo en línea!

Funciona cambiando la entrada a Título de caso y buscando la última subcadena coincidente en la lista.

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

P.ej. '1 samuel' -> '1 Samuel'el cual partidos ('m', 9), ('2', 36), ('S', 8), ('Sa', 31), ('2 S', 24). El último partido es ('2 S', 24), entonces la respuesta es24

6502 código máquina (C64), 204 bytes

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

Explicacion :

La clave aquí es utilizar una función de hashing especial que asigne sin colisiones a valores 0para125 *). Los números de los capítulos se colocan en una tabla de 126 bytes. El hash se realiza en 8 bits completos, el valor final se ajusta buscando los nibbles altos en otra tabla, combinando así diferentes nibbles altos donde los nibbles bajos no chocan.

Aquí hay una lista de desmontaje comentada de la parte del código:

.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

después de eso sigue una tabla de los números de los capítulos y, finalmente, una tabla de los nibbles altos para el valor hash.

Demostración en línea

Uso: sys49152,"name" por ejemplo sys49152,"genesis"(salida 50).

Importante: si el programa se cargó desde el disco (como en la demostración en línea), ¡emita newprimero un comando! Esto es necesario porque cargar un programa de máquina destruye algunos punteros BÁSICOS C64.

Sugerencia sobre la carcasa: en el modo predeterminado del C64, la entrada aparecerá en mayúscula. De hecho, esto es minúscula, pero el C64 tiene dos modos y en el modo predeterminado superior / gráfico, los caracteres en minúscula aparecen como mayúsculas y los mayúsculas como símbolos gráficos.

*) por supuesto, esto no es tan denso como podría ser ... bueno, tal vez encuentre una solución aún mejor más tarde;)

Java 8, 623 597 590 bytes

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 bytes gracias a @Nevay cambiando el ciclo for a una secuencia.

Definitivamente se puede jugar más golf. Solo necesito hacer más pruebas.
Puede que no sea la respuesta más corta por una posibilidad remota, y podría jugarse al portar alguna respuesta existente, pero todavía estoy orgulloso de encontrar algo yo mismo ... :)

Explicación:

Pruébalo aquí

1. Toma la potencia de 3 de cada carácter (como valor ASCII) en la cadena de entrada
2. Toma la suma de esos
3. Divide el resultado entre una 13595división entera (en Java, esto trunca / coloca automáticamente el resultado).
4. Esto deja 65 valores únicos (solo habakkuky matthewambos tienen un valor de 674)
5. Y luego un ternario gigante para devolver el resultado correcto (con algunos valores combinados en una sola declaración ternaria donde sea posible ( 381y 382ambos 1; 425y 436ambos 4; 649y 663ambos 13; 952y 1018ambos 4; 1122y 1229ambos 5).