La Bible est l'un des livres les plus influents jamais écrits et couramment cité comme le livre le plus vendu de tous les temps . Il a été écrit par environ 40 auteurs différents sur des centaines d'années avant d'être compilé dans sa forme actuelle. Mais ce qui est intéressant dans La Bible, c'est la façon dont elle est divisée. Il est divisé en 2 testaments différents, qui sont divisés en 66 livres plus petits, qui sont chacun divisés en chapitres plus petits, qui sont chacun divisés en versets individuels.

J'ai pensé que ce serait un défi amusant d'essayer de coder le nombre de chapitres de chaque livre dans le code le plus court possible. Donc, pour le défi d'aujourd'hui, vous devez écrire un programme ou une fonction qui prend l'un des livres en entrée et génère le nombre de chapitres de ce livre selon The King James Version .

Vous pouvez prendre IO dans n'importe quel format raisonnable, par exemple lire / écrire STDIN / STDOUT ou un fichier, les arguments de fonction / valeurs de retour, inviter l'utilisateur, etc. sont tous autorisés. L'entrée sera toujours l'un des 66 livres de la Bible, et seulement en minuscules. Cela signifie que si vous disposez d'une autre entrée, un comportement non défini est autorisé. Puisqu'il n'y a que 66 entrées et sorties possibles, elles sont toutes fournies ici, selon la page de Wikipedia sur les chapitres de la Bible dans 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

Étant donné que ce défi consiste à trouver le moyen optimal d'encoder chaque nom de livre et nombre de chapitres, il n'est pas autorisé d'utiliser des éléments intégrés qui fournissent des informations sur la Bible. Cependant, comme il serait intéressant de voir quelles langues ont de telles fonctionnalités, n'hésitez pas à partager une deuxième version non concurrente avec votre réponse. La récupération d'informations à partir de sources externes n'est pas non plus autorisée (aucune des failles standard n'est autorisée, mais j'ai pensé qu'il serait utile de mentionner explicitement celle-ci).

Comme d'habitude, c'est un défi de code-golf , alors essayez de faire le programme le plus court possible (mesuré en octets) comme vous le pouvez. Amusez-vous au golf!

Gelée , 127 octets

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

Essayez-le en ligne!

Cas de test

Comment ça fonctionne

Essentiellement, cela essaie de convertir les ords des caractères saisis en une valeur binaire, par exemple "joel"-> [106, 111, 101, 108]-> 2^3*106 + 2^2*111 + 2^1*101 + 2^0*108.

Ensuite, cette valeur est prise mod 407, puis mod 270, puis [quelques mods de plus], puis mod 160. Ceci est utile car il mappe les 66 entrées de chaîne à des entiers compris entre 0 et 158 ​​(chanceux sur le dernier mod).

L'entier est indexé à partir de la liste des entiers “ọḷḊḲɦ...ƙḅyẉ’b158¤pour trouver la valeur de ntelle que l'entrée ait le- nmoins de chapitres. Il se trouve que Joel possède le 7e moins de chapitres.

Cette valeur de nest davantage indexée dans la liste “£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘pour trouver le nombre exact de chapitres.

Amélioration possible: les entrées avec le même nombre de chapitres peuvent hacher à la même valeur à partir des mods (0% de collision n'est pas nécessaire), mais je n'en ai pas tenu compte dans mon programme pour déterminer la séquence des mods.

Excel, 373 octets

Réutilisation de l'approche de @ Misha à partir de la réponse 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 recherche renvoie des chapitres -1, puis ajoutez celui-ci. Cela se transforme 10en 9deux fois et ,1,en ,,4 fois.

Mise à jour à l'ancienne approche. Excel, 460 401 octets

Enregistrer au format CSV, nom du livre entré à la fin de la première ligne ( C1), résultat affiché dans 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

Pour la table de recherche, nous pouvons laisser de côté et 10et l 24car ils correspondent respectivement er 10et js 24.

JavaScript (ES6), 251 197 octets

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

Tester

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>

Formaté et commenté

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 octets

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

Comment ça fonctionne

Pour un livre en commençant par les codes de caractère a, b, c, d,e (enroulant autour si nécessaire) calcule 6a+b+8c+5d+3emodulo 151, qui se trouve être unique, et examine ensuite le nombre de chapitres dans une liste compressée de longueur 151. ( Les entrées non utilisées dans la liste sont rempli avec des doublons de l'entrée précédente. Cela encourage peut-être l'encodage de la longueur d'exécution? Quoi qu'il en soit, cela aide.)

Merci à @numbermaniac pour l'idée de compression de liste, qui est difficile à chiffrer mais qui représente une grande partie de l'amélioration ici.

Ancienne version: Mathematica, 548 435 407 octets

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

Comment ça fonctionne

Nous convertissons chaque nom nameen caractères 1, 3 et 6 de namename(par exemple leviticusdevient lvi, jobdevientjbb ) avant de le rechercher.

La liste dans laquelle nous regardons les choses est légèrement compressée en rassemblant les numéros de chapitre à 1 et 2 chiffres dans des chaînes.

Mathematica: 40 octets, sans compétition

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

Ouais.

Python 2 , 244 183 octets

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

Essayez-le en ligne!

Gelée ,  117 115  114 octets

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

Essayez-le en ligne! ou voir la suite de tests

Comment?

Hache le produit des ordinaux des caractères de la chaîne d'entrée en prenant trois deux trois divisions, recherche le résultat dans une liste de listes et utilise l'index trouvé pour rechercher le résultat dans une liste de longueurs de livre.

Lors de la recherche d'une fonction de hachage, je n'ai pris en compte que celles qui ont abouti à au plus un compartiment avec des résultats supérieurs à 255 pour permettre l'indexation de la page de codes, puis j'ai choisi celles qui minimisaient le nombre total de valeurs à coder (après avoir supprimé le compartiment "incriminé" ou si aucun n'existait le plus long seau). De 66 avec trois modules, j'ai trouvé un 59 ( %731%381%258) un 58 (%731%399%239 ) puis un avec 56 entrées ( %1241%865%251) [pour 117 octets] ... J'ai ensuite trouvé un 58 en utilisant seulement deux restes ( %1987%251) [pour 115 octets]
.. .puis j'ai trouvé un 55 en utilisant trois restes, qui lorsque deux entrées factices sont ajoutées permet une compression supplémentaire de la liste de recherche ...

Le code:

1.

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

est une liste de cinq listes d'index de pages de codes ( “...“...“...“...“...“...‘):

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

Ceci est transposé en utilisant l'atome Z pour obtenir les seaux; appelons ce 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]

(le 0 et 1sont les touches factices, permettant[179,5,111] à deux d'être plus à droite - la transposition nécessite des entrées plus longues à gauche)

2.

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

Appelez ce C (le chapitre compte) - c'est une liste d'entiers:

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

et est construit comme suit (les deux clés factices ci-dessus permettent donc 10,12,13d'être dans l'ordre croissant):

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

Maintenant, la version simplifiée du code est:

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 octets

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]

Essayez-le en ligne!

Fonctionne en changeant l'entrée en Titre et en trouvant la dernière sous-chaîne correspondante dans la liste.

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

Par exemple. '1 samuel' -> '1 Samuel'qui correspond ('m', 9), ('2', 36), ('S', 8), ('Sa', 31), ('2 S', 24). Le dernier match est ('2 S', 24), donc la réponse est24

6502 code machine (C64), 204 octets

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

Explication :

La clé ici est d'utiliser une fonction de hachage spéciale qui mappe sans collision avec des valeurs 0 à 125*). Les numéros de chapitre sont ensuite placés dans une table de 126 octets. Le hachage est effectué en 8 bits complets, la valeur finale est ajustée en recherchant les grignotages élevés dans une autre table, de cette façon, en combinant différents grignotages élevés où les grignotements bas ne se heurtent pas.

Voici une liste commentée de démontage de la partie de code:

.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

après cela suit un tableau des numéros de chapitre et enfin un tableau des grignotages élevés pour la valeur de hachage.

Démo en ligne

Utilisation:, sys49152,"name" par exemple sys49152,"genesis"(sortie 50).

Important: Si le programme a été chargé à partir du disque (comme dans la démo en ligne), émettez unnew commande! Cela est nécessaire car le chargement d'un programme machine met à la corbeille certains pointeurs C64 BASIC.

Astuce sur le boîtier: dans le mode par défaut du C64, l'entrée apparaîtra en majuscules. Il s'agit en fait de minuscules, mais le C64 a deux modes et dans le mode supérieur / graphique par défaut, les caractères minuscules apparaissent en majuscules et les caractères majuscules apparaissent en tant que symboles graphiques.

*) bien sûr, ce n'est pas aussi dense qu'il pourrait l'être ... eh bien, peut-être que je trouverai une solution encore meilleure plus tard;)

Java 8, 623 597 590 octets

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 octets grâce à @Nevay en changeant la boucle for en un flux.

Peut certainement être joué plus. Il suffit de faire plus de tests.
Ce n'est peut-être pas la réponse la plus courte à long terme, et pourrait être joué en portant une réponse existante, mais je suis toujours fier de trouver quelque chose moi-même .. :)

Explication:

Essayez-le ici.

1. Prend la puissance de 3 de chaque caractère (en tant que valeur ASCII) dans la chaîne d'entrée
2. Prend la somme de ceux
3. Divise le résultat par 13595 division entière (en Java, cela tronque / étage automatiquement le résultat).
4. Cela laisse 65 valeurs uniques (seulement habakkuket les matthewdeux ont une valeur de 674)
5. Et puis un ternaire géant-if pour retourner le résultat correct (avec quelques valeurs combinées dans une seule instruction ternaire si possible ( 381et les 382deux 1; 425et les 436deux 4; 649et les 663deux 13; 952et les 1018deux 4; 1122et les 1229deux 5).