La Bibbia è uno dei libri più influenti mai scritti e comunemente citato come il libro più venduto di tutti i tempi . È stato scritto da circa 40 autori diversi nel corso di centinaia di anni prima di essere compilato nella sua forma attuale. Ma la cosa interessante di The Bible è il modo in cui è divisa. È diviso in 2 diversi testamenti, che sono suddivisi in 66 libri più piccoli, che sono ciascuno suddiviso in capitoli più piccoli, che sono ciascuno suddiviso in versi individuali.

Ho pensato che sarebbe stata una sfida divertente provare a codificare il numero di capitoli in ciascun libro nel codice più breve possibile. Quindi, per la sfida di oggi, devi scrivere un programma o una funzione che accetta uno dei libri come input e genera il numero di capitoli in quel libro secondo The King James Version .

È possibile prendere IO in qualsiasi formato ragionevole, ad esempio leggere / scrivere STDIN / STDOUT o un file, sono ammessi argomenti di funzione / valori di ritorno, richiesta all'utente, ecc. L'input sarà sempre uno dei 66 libri di The Bible, e solo in minuscolo. Ciò significa che se ti viene dato qualsiasi altro input, è consentito un comportamento indefinito. Poiché ci sono solo 66 possibili input e output, sono tutti forniti qui, secondo la pagina di Wikipedia sui capitoli della Bibbia in 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

Poiché questa sfida consiste nel trovare il modo ottimale per codificare ogni nome di libro e conteggio di capitoli, non è consentito l'uso di alcun builtin che fornisca informazioni sulla Bibbia. Tuttavia, poiché sarebbe interessante vedere quali lingue hanno tali builtin, sentiti libero di condividere una seconda versione non competitiva insieme alla tua risposta. Anche il recupero di informazioni da fonti esterne non è consentito (nessuna delle scappatoie standard è consentita, ma ho pensato che sarebbe utile menzionarlo esplicitamente).

Come al solito, si tratta di una sfida di code-golf , quindi cerca di creare il programma più breve possibile (misurato in byte) il più possibile. Divertiti a giocare a golf!

Gelatina , 127 byte

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

Provalo online!

Casi test

Come funziona

In sostanza, questo tenta di convertire gli ordini dei caratteri immessi in un valore binario, ad esempio "joel"-> [106, 111, 101, 108]->2^3*106 + 2^2*111 + 2^1*101 + 2^0*108 .

Quindi, questo valore viene preso dalla mod 407, quindi dalla mod 270, quindi [qualche altra mod], quindi dalla mod 160. Ciò è utile perché mappa tutti gli 66 input di stringa su numeri interi compresi tra 0 e 158 (fortunato sulla mod finale).

Il numero intero viene indicizzato dall'elenco di numeri interi “ọḷḊḲɦ...ƙḅyẉ’b158¤per trovare il valore in modo ntale che l'input abbia il nnumero minimo di capitoli. Joel sembra avere il 7 ° numero minimo di capitoli.

Questo valore di nviene ulteriormente indicizzato nell'elenco “£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘per trovare il numero esatto di capitoli.

Possibile miglioramento: gli input con lo stesso numero di capitoli possono hash allo stesso valore dalle mod (non è necessaria una collisione dello 0%), ma non ho tenuto conto di ciò nel mio programma per determinare la sequenza delle mod.

Excel, 373 byte

Riutilizzando l'approccio di @ Misha dalla risposta di 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 ricerca restituisce i capitoli -1e quindi aggiunge quello. Questo cambia 10in 9due volte e ,1,in ,,4 volte.

Aggiornato al vecchio approccio. Excel, 460 401 byte

Salva come CSV, Nome libro inserito alla fine della prima riga ( C1), il risultato viene visualizzato in 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

Per la tabella di ricerca, possiamo tralasciare et 10e l 24perché questi corrispondono rispettivamente er 10e su js 24.

JavaScript (ES6), 251 197 byte

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

Test

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>

Formattato e commentato

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 byte

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

Come funziona

Per un libro che inizia con i codici di carattere a, b, c, d, e(avvolgendo intorno se necessario) calcola6a+b+8c+5d+3e modulo 151, che risulta essere unico, e quindi cerca il numero di capitoli in una lista di lunghezza compresso 151. (voci inutilizzate nell'elenco vengono compilato con i duplicati della voce precedente. Questo incoraggia la codifica di lunghezza, forse? Comunque, aiuta.)

Grazie a @numbermaniac per l'idea di compressione dell'elenco, che è difficile mettere un numero ma è una parte enorme del miglioramento qui.

Vecchia versione: Mathematica, 548 435 407 byte

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

Come funziona

Convertiamo ogni nome namein caratteri 1, 3 e 6 di namename(ad esempio leviticusdiventa lvi, jobdiventa jbb) prima di cercarlo.

L'elenco in cui cerchiamo le cose è leggermente compresso mettendo insieme i numeri dei capitoli a 1 e 2 cifre in stringhe.

Mathematica: 40 byte, non competitiva

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

Si.

Python 2 , 244 183 byte

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

Provalo online!

Gelatina ,  117 115  114 byte

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

Provalo online! o vedere il suite di test

Come?

Hash il prodotto degli ordinali dei caratteri della stringa di input prendendo tre due rimanenti tre divisioni, cerca il risultato in un elenco di elenchi e utilizza l'indice trovato per cercare il risultato in un elenco di lunghezze del libro.

Quando ho trovato una funzione hash ho considerato solo quelli che hanno portato al massimo un bucket con risultati superiori a 255 per consentire l'indicizzazione della tabella codici e quindi ho scelto quelli che minimizzavano il numero totale di valori da codificare (dopo aver rimosso il bucket "offensivo" o se nessuno esisteva il secchio più lungo). Da 66 con tre moduli ho trovato un 59 ( %731%381%258) un 58 ( %731%399%239) e poi uno con 56 voci ( %1241%865%251) [per 117 byte] ... Ho quindi trovato un 58 usando solo due resti ( %1987%251) [per 115 byte]
.. .quindi ho trovato un 55 usando tre resti, che quando vengono aggiunte due voci fittizie consente un'ulteriore compressione dell'elenco di ricerca ...

Il codice:

1.

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

è un elenco di cinque elenchi di indici di code page (“...“...“...“...“...“...‘ ):

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

Questo viene trasposto usando l'atomo Z per ottenere i secchi; chiama questo 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]

(il 0 e 1sono i tasti fittizi, consentendo il[179,5,111] di essere due più a destra - la trasposizione richiede voci più lunghe per essere a sinistra)

2.

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

Chiama questo C (il capitolo conta) - è un elenco di numeri interi:

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

ed è costruito come segue (le due chiavi fittizie sopra riportate consentono quindi 10,12,13di essere in ordine 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]

Ora la versione semplificata del codice è:

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 byte

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]

Provalo online!

Funziona modificando l'input in Title Case e trovando l'ultima sottostringa corrispondente nell'elenco.

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

Per esempio. '1 samuel' -> '1 Samuel'che corrisponde ('m', 9), ('2', 36), ('S', 8), ('Sa', 31), ('2 S', 24). L'ultima partita è ('2 S', 24), quindi la risposta è24

6502 codice macchina (C64), 204 byte

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

Spiegazione :

La chiave qui è usare una speciale funzione di hashing che mappa senza collisioni con valori 0a 125*). I numeri dei capitoli vengono quindi inseriti in una tabella di 126 byte. L'hashing viene eseguito per intero a 8 bit, il valore finale viene regolato osservando gli stuzzichini alti in un'altra tabella, in questo modo combinando diversi stuzzichini alti in cui i stuzzichini bassi non si scontrano.

Ecco un elenco di smontaggio commentato della parte di codice:

.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

successivamente segue una tabella dei numeri dei capitoli e infine una tabella degli stuzzichini alti per il valore hash.

Demo online

Utilizzo: sys49152,"name" ad esempio sys49152,"genesis"(output 50).

Importante: se il programma è stato caricato dal disco (come nella demo online), emettere newprima un comando! Ciò è necessario perché il caricamento di un programma macchina elimina alcuni puntatori BASIC C64.

Suggerimento sull'involucro: nella modalità predefinita del C64, l'ingresso apparirà in maiuscolo. Questo è in realtà minuscolo, ma il C64 ha due modalità e nella modalità superiore / grafica predefinita, i caratteri minuscoli vengono visualizzati come caratteri maiuscoli e maiuscoli come simboli grafici.

*) ovviamente, non è così denso come potrebbe essere ... vabbè, forse troverò una soluzione ancora migliore in seguito;)

Java 8, 623 597 590 byte

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 byte grazie a @Nevay modificando il for-loop in uno stream.

Può sicuramente giocare a golf di più .. Ho solo bisogno di fare qualche altro test.
Potrebbe non essere la risposta più breve da un colpo lungo, e potrebbe essere giocata a golf portando una risposta esistente, ma sono ancora orgoglioso di trovare qualcosa da solo .. :)

Spiegazione:

Provalo qui.

1. Prende la potenza di 3 di ogni carattere (come valore ASCII) nella stringa di input
2. Prende la somma di quelli
3. Divide il risultato per 13595 come divisione intera (in Java questo tronca / pavimenta automaticamente il risultato).
4. Questo lascia 65 valori univoci (solo habakkuked matthewentrambi hanno un valore di 674)
5. E poi un gigantesco ternario - se per restituire il risultato corretto (con alcuni valori che si combinano in una singola dichiarazione ternaria ove possibile ( 381ed 382entrambi 1; 425ed 436entrambi 4; 649ed 663entrambi 13; 952ed 1018entrambi 4; 1122ed 1229entrambi 5).