A Bíblia é um dos livros mais influentes já escritos e comumente citado como o livro mais vendido de todos os tempos . Foi escrito por aproximadamente 40 autores diferentes ao longo de centenas de anos antes de ser compilado em sua forma atual. Mas o interessante da Bíblia é a maneira como ela é dividida. É dividido em 2 testamentos diferentes, divididos em 66 livros menores, divididos em capítulos menores, divididos em versos individuais.

Eu pensei que seria um desafio divertido tentar codificar o número de capítulos em cada livro no menor código possível. Portanto, para o desafio de hoje, você deve escrever um programa ou função que inclua um dos livros como entrada e produza o número de capítulos nesse livro, de acordo com a The King James Version .

Você pode fazer IO em qualquer formato razoável, por exemplo, ler / gravar STDIN / STDOUT ou um arquivo, argumentos de função / valores de retorno, solicitar ao usuário etc. são todos permitidos. A entrada será sempre um dos 66 livros da Bíblia, e apenas minúscula. Isso significa que, se você receber outra entrada, um comportamento indefinido será permitido. Como existem apenas 66 entradas e saídas possíveis, todas elas são fornecidas aqui, de acordo com a página da Wikipedia nos capítulos da Bíblia em 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

Como esse desafio é encontrar a maneira ideal de codificar todos os nomes de livros e contagens de capítulos, não é permitido o uso de quaisquer recursos internos que forneçam informações sobre a Bíblia. No entanto, como seria interessante ver quais idiomas possuem esses recursos, sinta-se à vontade para compartilhar uma segunda versão não concorrente junto com sua resposta. Buscar informações de fontes externas também não é permitido (nenhuma das brechas padrão é permitida, mas achei que seria útil mencionar explicitamente essa).

Como sempre, esse é um desafio de código-golfe , portanto, tente fazer o programa mais curto possível (medido em bytes) possível. Divirta-se jogando golfe!

Geléia , 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¤ị¢

Experimente online!

Casos de teste

Como funciona

Essencialmente, isso tenta converter as ords dos caracteres inseridos em um valor binário, por exemplo "joel"->[106, 111, 101, 108] -> 2^3*106 + 2^2*111 + 2^1*101 + 2^0*108.

Então, esse valor é obtido mod 407, mod 270, depois [mais alguns mods] e mod 160. Isso é útil porque mapeia todas as 66 entradas de string para números inteiros entre 0 e 158 (sorte no mod final).

O número inteiro é indexado na lista de números inteiros “ọḷḊḲɦ...ƙḅyẉ’b158¤para encontrar o valor de ntal forma que a entrada tenha o nmenor número de capítulos. Por acaso, Joel tem o 7º número de capítulos.

Esse valor de né indexado ainda mais na lista “£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘para encontrar o número exato de capítulos.

Possível melhoria: entradas com o mesmo número de capítulos podem ter o mesmo valor dos mods (a colisão de 0% não é necessária), mas não expliquei isso no meu programa para determinar a sequência dos mods.

Excel, 373 bytes

Reutilizando a abordagem de @ Misha da resposta do 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

Pesquisa retorna capítulos -1e, em seguida, adicione um. Isso muda 10para 9duas vezes e ,1,para,, 4 vezes.

Atualizado para a abordagem antiga. Excel, 460 401 bytes

Salvar como CSV, nome do livro inserido no final da primeira linha ( C1), resultado exibido em 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 a tabela de pesquisa, podemos deixar de fora et 10e l 24porque eles correspondem er 10e 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

Teste

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>

Formatado e 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]]]&

Como funciona

Para um livro começando com códigos de caracteres a, b, c, d, e(envolvendo em torno se necessário) calcula 6a+b+8c+5d+3emódulo 151, que passa a ser único, e, em seguida, olha para cima o número de capítulos em uma lista comprimido de comprimento 151. (entradas não utilizadas na lista são preenchido com duplicatas da entrada anterior. Isso encoraja a codificação de execução, talvez? De qualquer forma, ajuda.)

Obrigado a @numbermaniac pela idéia de compactação de lista, que é difícil de colocar um número, mas é uma grande parte da melhoria aqui.

Versão antiga: Mathematica, 548 435 407 bytes

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

Como funciona

Convertemos cada nome namenos caracteres 1, 3 e 6 de namename(por exemplo , torna- leviticusse lvi, jobtorna-se jbb) antes de procurá-lo.

A lista em que procuramos é um pouco compactada, juntando os números de capítulo de 1 e 2 dígitos em cadeias.

Mathematica: 40 bytes, não concorrente

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

Sim.

Python 2 , 244 183 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

Experimente online!

Geléia ,  117 115  114 bytes

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

Experimente online! ou veja a suíte de testes

Quão?

Hashes o produto dos ordinais dos caracteres da sequência de entrada, usando três dois restos de três divisões, procura o resultado em uma lista de listas e usa o índice encontrado para procurar o resultado em uma lista de comprimentos de livros.

Ao encontrar uma função de hash, considerei apenas aqueles que resultaram em no máximo um depósito com resultados acima de 255 para permitir a indexação da página de códigos e, em seguida, escolhi aqueles que minimizassem o número total de valores a serem codificados (após remover o depósito "ofensivo" ou se não existia o balde mais longo). De 66 com três módulos, encontrei um 59 ( %731%381%258) a 58 ( %731%399%239) e um com 56 entradas ( %1241%865%251) [com 117 bytes] ... Encontrei um 58 usando apenas dois restos ( %1987%251) [com 115 bytes]
.. .Encontrei um 55 usando três remanescentes, que quando duas entradas fictícias são adicionadas permitem uma compressão ainda maior da lista de pesquisa ...

O código:

1

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

é uma lista de cinco listas de índices de página de código ( “...“...“...“...“...“...‘):

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

Isso é transposto usando o átomo Zpara obter os baldes; chame isso de 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]

(as teclas dummy 0e 1são, permitindo que elas [179,5,111]sejam duas mais à direita - a transposição requer entradas mais longas à esquerda)

2)

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

Chame isso de C (o capítulo conta) - é uma lista de números inteiros:

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

e é construído da seguinte maneira (as duas chaves fictícias acima, portanto, permitem 10,12,13estar em ordem crescente):

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

Agora a versão simplificada do código é:

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]

Experimente online!

Funciona alterando a entrada para Título e encontrando a última substring correspondente na lista.

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

Por exemplo. '1 samuel' -> '1 Samuel'qual combina ('m', 9), ('2', 36), ('S', 8), ('Sa', 31), ('2 S', 24). A última partida é ('2 S', 24), então a resposta é24

Código da máquina 6502 (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

Explicação :

A chave aqui é usar uma função de hash especial que mapeia sem colisões os valores 0para 125*). Os números dos capítulos são então colocados em uma tabela de 126 bytes. O hash é feito em 8 bits completos, o valor final é ajustado observando as mordidelas altas em outra tabela, dessa maneira combinando diferentes mordidinhas altas nas quais as mordidinhas baixas não colidem.

Aqui está uma lista de desmontagem comentada da parte do 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

depois disso segue uma tabela com os números dos capítulos e, finalmente, uma tabela com os mais altos petiscos para o valor do hash.

Demonstração online

Uso:, sys49152,"name" por exemplo sys49152,"genesis"(saída 50).

Importante: Se o programa foi carregado a partir do disco (como na demonstração online), emita um newcomando primeiro! Isso é necessário porque o carregamento de um programa de máquina elimina alguns ponteiros C64 BASIC.

Dica sobre a caixa: No modo padrão do C64, a entrada aparecerá como maiúscula. Na verdade, isso está em minúsculas, mas o C64 possui dois modos e, no modo gráfico / superior, os caracteres minúsculos aparecem como maiúsculos e os maiúsculos, como símbolos gráficos.

*) é claro, isso não é tão denso quanto poderia ser ... oh bem, talvez eu encontre uma solução ainda melhor depois;)

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 graças a @Nevay , alterando o loop for para um fluxo.

Definitivamente pode ser jogado mais. Só preciso fazer mais alguns testes.
Pode não ser a resposta mais curta a longo prazo, e pode ser jogada de golfe com alguma resposta existente, mas ainda estou orgulhoso de ter alguma coisa .. :)

Explicação:

Experimente aqui.

1. Toma o poder de 3 de cada caractere (como valor ASCII) na entrada String
2. Toma a soma daqueles
3. Divide o resultado por 13595divisão inteira (em Java, isso trunca / pisa automaticamente o resultado).
4. Isso deixa 65 valores únicos (apenas habakkuke matthewambos têm um valor de 674)
5. E então um gigante ternário-se para retornar o resultado correto (com alguns valores combinados em uma única declaração ternária sempre que possível ( 381e 382ambos 1; 425e 436ambos 4; 649e 663ambos 13; 952e 1018ambos 4; 1122e 1229ambos 5)).