Dungeon Master a été l’un des tout premiers jeux de rôle en temps réel, sorti en 1987 sur Atari ST. Entre autres choses excitantes pour le moment, il proposait un système de sorts plutôt sophistiqué basé sur les runes.

Votre tâche aujourd'hui est d'écrire un programme ou une fonction qui évalue le nombre de points de mana nécessaires pour lancer un sort donné dans Dungeon Master.

^{Le système de 'distribution de sorts' est la boîte cyan en haut à droite dans l'image ci-dessus.}

Sorts, runes et mana

Les sorts de Maître de donjon sont composés de 2 à 4 runes, sélectionnées dans les catégories suivantes, dans cet ordre exact:

1. Puissance (obligatoire)
2. Influence élémentaire (obligatoire)
3. Formulaire (optionnel)
4. Classe / Alignement (optionnel)

Cela signifie que les périodes valides sont soit:

• Puissance + Influence élémentaire
• Puissance + Influence élémentaire + Forme
• Puissance + Influence élémentaire + Forme + Classe / Alignement

Chaque catégorie contient 6 runes et chaque rune a un coût en mana de base associé:

=============================================================================
| Power               | Rune      |   Lo |   Um |   On |   Ee |  Pal |  Mon |
|                     +-----------+------+------+------+------+------+------+
|                     | Base cost |    1 |    2 |    3 |    4 |    5 |    6 |
=============================================================================
| Elemental Influence | Rune      |   Ya |   Vi |   Oh |  Ful |  Des |   Zo |
|                     +-----------+------+------+------+------+------+------+
|                     | Base cost |    2 |    3 |    4 |    5 |    6 |    7 |
=============================================================================
| Form                | Rune      |  Ven |   Ew | Kath |   Ir |  Bro |  Gor |
|                     +-----------+------+------+------+------+------+------+
|                     | Base cost |    4 |    5 |    6 |    7 |    7 |    9 |
=============================================================================
| Class / Alignment   | Rune      |   Ku |  Ros | Dain | Neta |   Ra |  Sar |
|                     +-----------+------+------+------+------+------+------+
|                     | Base cost |    2 |    2 |    3 |    4 |    6 |    7 |
=============================================================================

Évaluation du coût en mana

Le coût en mana du sort correspond à la somme du coût en mana de toutes les runes:

• Le coût de la rune Power est toujours égal à son coût de base (de 1 à 6).

• Pour les autres runes, la formule suivante s'applique:

  

  où le pouvoir est le coût de base de la rune Power.

Exemples

Spell: Lo Ful
Cost : 1 + floor((1 + 1) * 5 / 2) = 1 + 5 = 6

Spell: Um Ful
Cost : 2 + floor((2 + 1) * 5 / 2) = 2 + 7 = 9

Spell: Pal Vi Bro
Cost : 5 + floor((5 + 1) * 3 / 2) + floor((5 + 1) * 7 / 2) = 5 + 9 + 21 = 35

Clarifications et règles

• Votre saisie consistera en 2 à 4 chaînes désignant les runes du sort. Vous pouvez les prendre dans n'importe quel format raisonnable, tels que 4 paramètres distincts, un tableau de chaînes (par exemple ['Lo', 'Ful']) ou une seule chaîne avec un séparateur de caractère unique de votre choix (par exemple 'Lo Ful'). Veuillez spécifier le format de saisie sélectionné dans votre réponse.
• Les runes sont garanties d'être valides.
• L'ordre des catégories doit être respecté. Les catégories non utilisées peuvent être manquantes ou remplacées par une valeur de fausseté.
• Vous pouvez accepter les runes dans l’un des formats suivants: 1. Une lettre majuscule suivie de minuscules ( 'Ful') 2. Toutes les minuscules ( 'ful') 3. Toutes les majuscules ( 'FUL'). Mais vous ne pouvez pas mélanger différents formats.
• Bien évidemment, nous ne nous soucions pas de savoir si le sort a réellement un effet sur le jeu (pour les sorts curieux et utiles , ils sont listés ici .)
• C'est le code-golf , donc le code le plus court en octets gagne.
• Et rappelez-vous: Lord Chaos vous observe!

Cas de test

Spell          | Output
---------------+-------
Lo Ful         | 6
Um Ful         | 9
On Ya          | 7
Lo Zo Ven      | 12
Pal Vi Bro     | 35
Ee Ya Bro Ros  | 31
On Ful Bro Ku  | 31
Lo Zo Kath Ra  | 20
On Oh Ew Sar   | 35
Ee Oh Gor Dain | 43
Mon Zo Ir Neta | 68
Mon Des Ir Sar | 75

SOGL V0.12 , 110 78 octets

θKKι"LUOEPM”;W:A≤{B"⁶Μ↓§QΕņj“L─"¶Ζq«╝γDyΜ2¶S◄Μ$‘č¹I6nēwι{_Cb:ƧRA=┌*ΚKι=?aIc*»+

Essayez-le ici!

Pourrait probablement jouer au golf un octet ou deux en refaisant tout

Explication:

θ            split on spaces
 K           pop the 1st item
  K          pop from the string the 1st character
   ι         remove the original string from stack
    "”;W     get the chars index in "LUOEPM"
        :A   save a copy to variable A
          ≤  put the power (used as the mana) on the bottom of the stack (with the thing above being the input array)

{            for the leftover items in the input do
 B             save the current name on B
  "..“         push 456779223467234567
      L─       base-10 decode it (yes, silly, but it converts it to an array of digits)
        ".‘    push "VEKIBGKRDN-SYVOFDZ"

      č        chop to characters
       ¹       create an array of those two
        I      rotate clockwise
         6n    group to an array with sub-arrays of length 6 (so each array in the array contains 3 items, corresponding to the categories, each with 6 arrays with the runes 1st letter (or "-" in the case of Ra) and base cost)
           ē   push variable e (default = user input number, which errors and defaults to 0) and after that increase it (aka `e++`)
            w  get that item in the array (the array is 1-indexed and the variable is not, so the array was created shifted (which somehow saves 0.9 ≈ 1 byte in the compression))

 ι             remove the original array
  {            for each in that (current category) array
   _             dump all contents on stack (so pushing the runes name and then base cost)
    C            save pop (base cost) on variable B
     b:          duplicate the name
       ƧRA=      push if pop = "RA"
           ┌*    get that many (so 0 or 1) dashes
             Κ   prepend the "" or "-" to the name
              K  pop the 1st letter of the name
               ι remove the modified name, leaving the 1st letter on the stack

         =?      if top 2 are equal (one of the dumped items and the 1st letter of the current inputs)
           a       push variable A (the power)
            I      increase it
             c     push variable C (the current base cost)
              *    multiply
               »   floor-divide by 2
                +  add that to the power

Python 2 , 135 119 115 octets

b=[int('27169735 2  4567 435262'[int(x,36)%141%83%50%23])for x in input()]
print b[0]+sum(a*-~b[0]/2for a in b[1:])

Essayez-le en ligne!

L'entrée est une liste de chaînes de stdin

05AB1E , 83 82 octets

.•Y<εΔ•¹нk©.•M₄P畲нkÌ.•Jrû •³нkD(i\ë4 3‡4+}.•A1Δ#•I4èkD(i\ë3LJ012‡Ì})ćsv®>y*;(î(+

Essayez-le en ligne!

-1 grâce à Emigna .

SOOOOOOO ungolfed :(

Explication:

.•Y<εΔ•¹нk©.•M₄P畲нkÌ.•Jrû •³нkD(i\ë4 3‡4+}.•A1Δ#•I4èkD(i\ë3LJ012‡Ì})ćsv®>y*;(î(+ Accepts four runes as separate lines, lowercase. Use Ø for missing runes.
.•Y<εΔ•¹нk©                                                                        Index first letter of first rune into "aluoepm" ("a" makes 1-indexed)
           .•M₄P畲нkÌ                                                             Index first letter of second rune into "yvofdz", 2-indexed.
                      .•Jrû •³нkD(i\ë4 3‡4+}                                       Index first letter of third rune into "vekibg", 0-indexed, if it's not there pop, else, if index is 4 replace with 3, else keep as-is, then increment by 4.
                                            .•A1Δ#•I4èkD(i\ë3LJ012‡Ì}              Index fourth letter (modular wrapping) of fourth rune into "kodnra", if it's not there pop, else, if index is one of 1, 2 or 3, replace with 0, 1 or 2 respectively, else keep as-is, then increment by 2.
                                                                     )ćs           Wrap all numbers into a list, keeping the power rune behind.
                                                                        v          For each
                                                                         ®>y*;(î(   Apply the formula
                                                                                 +  Add to total sum

JavaScript (ES6), 157 156 116 112 100 99 97 octets

Prend l'entrée comme un tableau de chaînes.

a=>a.map(c=>t+=(v=+`27169735020045670435262`[parseInt(c,36)%141%83%50%23],+a?a*v+v>>1:a=v),t=0)|t

• Vous avez économisé un nombre considérable de 44 octets en empruntant l'astuce d' indexation à la solution Python d' ovs - si vous votez positivement pour cette réponse, votez également pour celle-ci.
• Économisé 13 octets grâce à Arnauld soulignant ce qui aurait dû être une occasion évidente d’utiliser un ternaire.

Essayez-le en ligne!

Explication

Hoo, mec, ça va être amusant - mes explications à des solutions triviales sont nulles dans le meilleur des cas! Essayons ...

a=>

Une fonction anonyme prenant le tableau en argument avec paramètre a.

a.reduce((t,c)=>,0)

Réduisez les éléments du tableau en les faisant passer chacun à travers une fonction. le tparamètre est le total cumulé, le cparamètre est la chaîne en cours et 0la valeur initiale de t.

parseInt(c,36)

Convertit l’élément actuel d’une chaîne en base 36 en un entier décimal.

%141%83%50%23

Effectuez quelques opérations modulo dessus.

+`27169735 2  4567 435262`[]

Saisissez le caractère de la chaîne à cet index et convertissez-le en nombre.

v=

Attribuez ce numéro à la variable v.

+a?

Vérifiez si variable aest un nombre. Pour le premier élément asera le tableau de chaînes, essayer de convertir cela en un nombre va revenir NaN, ce qui est falsey. À chaque passage suivant, asera un entier positif, ce qui est la vérité.

a*v+v>>1

Si a est un nombre, on le multiplie par la valeur de v, on ajoute la valeur de vet on décale les bits du résultat 1 bit vers la droite, ce qui donne le même résultat que la division par 2 et le revêtement de sol.

:a=v

Si an'est pas un nombre on attribue la valeur dev , ce qui nous donnera également la possibilité 0d’ajouter à notre total lors du premier passage.

t+

Enfin, nous ajoutons le résultat du ternaire ci-dessus à notre total cumulé.

Original, 156 octets

a=>a.reduce((t,c)=>t+(p+1)*g(c)/2|0,p=(g=e=>+`123456234567456779223467`["LoUmOnEePaMoYaViOhFuDeZoVeEwKaIrBrGoKuRoDaNeRaSa".search(e[0]+e[1])/2])(a.shift()))

JavaScript, 212 210 207 206 octets

Algorithme de recherche simple, les chaînes de recherche ne font que contribuer au nombre total d'octets.

Code

s=>eval('p=q=+(e=s.map(r=>"1 2 3 4 5  6  2 3 4 5  6  7 4  5 6   7 7  9  2 2  3   4   6 7"["LoUmOnEePalMonYaViOhFulDesZoVenEwKathIrBroGorKuRosDainNetaRaSar".search(r)])).shift();e.map(c=>p+=((q+1)*c)>>1);p')

Format d'entrée

Tableau de chaînes, chaque élément est une chaîne en majuscule. Exemple: ["Mon", "Zo", "Ir", "Neta"]

Explication

e=s.map(r=>"1 2 3 4 5  6  2 3 4 5  6  7 4  5 6   7 7  9  2 2  3   4   6 7"["LoUmOnEePalMonYaViOhFulDesZoVenEwKathIrBroGorKuRosDainNetaRaSar".search(r)])

Cette demande pour les coûts de base.

p=q=+(/*blah*/).shift() 

Initialise 2 variables avec le premier élément du résultat du tableau ci-dessus et supprime cet élément. Doit être converti d'abord en nombre, sinon il sera considéré comme une concaténation de chaîne dans la partie suivante.

e.map(c=>p+=((q+1)*c)>>1);

Ajoute les coûts des runes non puissantes à la puissance de base. Le changement est utilisé à la place du sol (blah) / 2.

eval(/*blah*/;p)

Évaluez le dernier résultat. (Crédit: Step Hen)

Cas de test

Lo Ful | 6
Um Ful | 9
On Ya | 7
Lo Zo Ven | 12
Pal Vi Bro | 35
Ee Ya Bro Ros | 31
On Ful Bro Ku | 31
Lo Zo Kath Ra | 20
On Oh Ew Sar | 35
Ee Oh Gor Dain | 43
Mon Zo Ir Neta | 68
Mon Des Ir Sar | 75

Edit 1: 212> 210 - Suppression d'une paire d'accolades

Edit 2: 210> 207 - Merci à Step Hen de nous avoir rappelé les règles JS et de nous aider à utiliser la fonction eval (). Comme AS3 interdit l’utilisation de eval (), cela fait longtemps que je ne l’utilise pas

Edit 3: 207> 206 - Merci Shaggy pour l'idée de remplacer indexOf () par search ()

Haskell , 159 156 148 133 130 127 octets

k(p:y)=sum$floor<$>c p:map(\x->c x*(c p+1)/2)y
c s=read["3764529516342767"!!(foldl(\c n->c*94+fromEnum n-9)0s%7086%17)]
(%)=mod

Essayez-le en ligne!

Python 2 , 320 318 314 311 307 octets

Format d'entrée - Liste de chaînes. Programme complet:

i=input()
t=[x.split()for x in"Lo Um On Ee Pal Mon|Ya Vi Oh Ful Des Zo|Ven Ew Kath Ir Bro Gor|Ku Ros Dain Neta Ra Sar".split('|')]
c=t[0].index(i[0])+1;r=c+1;s=c+r*(t[1].index(i[1])+2)/2
if len(i)>2:s+=r*(t[2].index(i[2])+4-(i[2]=='Bro'))/2
if len(i)>3:s+=r*(t[3].index(i[3])+1+(i[3]in'KuRaSar'))/2
print(s)

Essayez-le en ligne!

Excel, 339 octets

Entrées entrées A1par D1. Formule dans n'importe quelle autre cellule.

=CHOOSE(MOD(CODE(A1),12),2,,,1,6,,3,5,4)+INT((CHOOSE(MOD(CODE(A1),12),2,,,1,6,,3,5,4)+1)*CHOOSE(MOD(CODE(B1),12),,3,,,2,7,4,6,,5)/2)+INT((CHOOSE(MOD(CODE(A1),12),2,,,1,6,,3,5,4)+1)*CHOOSE(MOD(CODE(C1),12),7,4,6,,,7,,,5,,9)/2)+INT((CHOOSE(MOD(CODE(A1),12),2,,,1,6,,3,5,4)+1)*CHOOSE(MOD(CODE(SUBSTITUTE(D1,"Ra","E")),11),4,3,6,,2,7,,,2,0)/2)

Vous pouvez également importer en tant que CSV:

Excel et CSV, 228 octets

,,,
=CHOOSE(MOD(CODE(A1),12),2,,,1,6,,3,5,4)+1
=A2-1+INT(A2*CHOOSE(MOD(CODE(B1),12),,3,,,2,7,4,6,,5)/2)+INT(A2*CHOOSE(MOD(CODE(C1),12),7,4,6,,,7,,,5,,9)/2)+INT(A2*CHOOSE(MOD(CODE(SUBSTITUTE(D1,"Ra","E")),11),4,3,6,,2,7,,,2,0)/2)

Entrée entrée dans la première ligne, SPACEpour les valeurs nulles. Résultat affiché en A3.

SCALA, 1106 caractères, 1106 octets

C'est assez long, probablement optimisable, mais c'était amusant à faire :)

Format d'entrée : runes séparées par des espaces dans une chaîne. S'il n'y a que 2 entrées (comme "Lo Ful"), mon code le complète while(k.length<4)k:+=""(je peux donc économiser 24 octets en modifiant les paramètres, si je le souhaite "ABC D").

def n(i:Int,p:String):Int={Math.floor(i*((""+p(0)).toInt+1)/2).toInt}
def m(s:String):Int={var k=s.split(' ')

while(k.length<4)k:+=""

k match{case Array(p,i,f,a)=>{p match{case "Lo"=>1+m(1+"/ "+i+" "+f+" "+a)
case "Um"=>2+m(2+"/ "+i+" "+f+" "+a)
case "On"=>3+m(3+"/ "+i+" "+f+" "+a)
case "Ee"=>4+m(4+"/ "+i+" "+f+" "+a)
case "Pal"=>5+m(5+"/ "+i+" "+f+" "+a)
case "Mon"=>6+m(6+"/ "+i+" "+f+" "+a)
case _ if p.contains("/")=>i match{case "Ya"=>n(2,p)+m(p+" / "+f+" "+a)
case "Vi"=>n(3,p)+m(p+" / "+f+" "+a)
case "Oh"=>n(4,p)+m(p+" / "+f+" "+a)
case "Ful"=>n(5,p)+m(p+" / "+f+" "+a)
case "Des"=>n(6,p)+m(p+" / "+f+" "+a)
case "Zo"=>n(7,p)+m(p+" / "+f+" "+a)
case _ if p.contains("/")=>f match{case "Ven"=>n(4,p)+m(p+" / "+"/ "+a)
case "Ew"=>n(5,p)+m(p+" / "+"/ "+a)
case "Kath"=>n(6,p)+m(p+" / "+"/ "+a)
case "Ir"=>n(7,p)+m(p+" / "+"/ "+a)
case "Bro"=>n(7,p)+m(p+" / "+"/ "+a)
case "Gor"=>n(9,p)+m(p+" / "+"/ "+a)
case _ if p.contains("/")=>a match{case "Ku"=>n(2,p)
case "Ros"=>n(2,p)
case "Dain"=>n(3,p)
case "Neta"=>n(4,p)
case "Ra"=>n(6,p)
case "Sar"=>n(7,p)
case _=>0}
case _=>0}
case _=>0}
case _=>0}}}}

Merci pour ce superbe challenge. Essayez-le en ligne!

Langage de programmation Shakespeare , 4420 octets

,.Ajax,.Ford,.Page,.Puck,.Romeo,.Act I:.Scene I:.[Enter Romeo and Page]Page:You big big big big big big cat.[Exit Romeo][Enter Ajax]Page:Open thy mind!Ajax:Open thy mind!Open thy mind!You is the sum of Romeo and the sum of a big big cat and a cat.Am I as big as you?If not,let us return to Scene V.Page:You is the sum of a big big cat and a cat.Let us return to Act V.Scene V:.Ajax:You is the sum of you and the sum of a big big big cat and a pig.Am I as big as you?If not,let us return to Scene X.Page:You big cat.Let us return to Act V.Scene X:.Ajax:You is the sum of you and the sum of a big cat and a cat.Am I as big as you?If not,let us return to Scene L.Page:You big big cat.Let us return to Act V.Scene L:.Ajax:You is the sum of you and the sum of a big big cat and a big cat.Am I as big as you?If not,let us return to Scene C.Page:You is the sum of a big cat and a cat.Let us return to Act V.Scene C:.Ajax:Am I as big as the sum of you and a big big big pig?Page:You is the sum of a big big cat and a big cat.If so,you is the sum of you and a cat.Ajax:Open thy mind!Act V:.Scene I:.[Exit Ajax][Enter Ford]Page:Open thy mind!Ford:Open thy mind!Open thy mind!You is the sum of Romeo and the sum of a big big big big cat and a pig.Am I as big as you?If not,let us return to Scene V.Page:You big big cat.Let us return to Act X.Scene V:.Ford:You is the sum of you and the sum of a big big big cat and a pig.Am I as big as you?If not,let us return to Scene X.Page:You is the sum of a big cat and a cat.Let us return to Act X.Scene X:.Ford:You is the sum of you and a big big cat.Am I as big as you?If not,let us return to Scene L.Page:You is the sum of a big big big cat and a pig.Let us return to Act X.Scene L:.Ford:Am I as big as the sum of you and a pig?If not,let us return to Scene C.Page:You big cat.Let us return to Act X.Scene C:.Ford:Am I as big as the sum of Romeo and a big big cat?Page:You is the sum of a big big cat and a cat.If so,you is the sum of you and a cat.Ford:Open thy mind!Act X:.Scene I:.[Exit Page][Enter Puck]Ford:You is the sum of the sum of Ajax and a pig and the quotient between the product of Ajax and I and a big cat.Puck:Open thy mind!Is you as big as a pig?If so,let us return to Act D.[Exit Puck][Enter Page]Ford:Open thy mind!Open thy mind!You is the sum of Romeo and the sum of a big big cat and a cat.Am I as big as you?If not,let us return to Scene V.Page:You is the sum of a big big cat and a cat.Let us return to Act L.Scene V:.Ford:Am I as big as the sum of you and a big big cat?If not,let us return to Scene X.Page:You is the sum of a big big big cat and a pig.Let us return to Act L.Scene X:.Ford:Open thy mind!Am I as big as the sum of Romeo and a big cat?If not,let us return to Scene L.Page:You is the sum of a big big big cat and a pig.Let us return to Act L.Scene L:.Ford:You is the sum of Romeo and the sum of a big big big cat and a pig.Am I as big as you?If not,let us return to Scene C.Page:You is the sum of a big big big cat and a cat.Let us return to Act L.Scene C:.Ford:Am I as big as the sum of you and a big big cat?If so,let us return to Scene D.Page:You big big cat.Let us return to Act L.Scene D:.Page:Open thy mind!You is the sum of a big big cat and a big cat.Act L:.Scene I:.[Exit Page][Enter Puck]Ford:You is the sum of you and the quotient between the product of Ajax and I and a big cat.Puck:Open thy mind!Is you as big as a pig?If so,let us return to Act D.[Exit Puck][Enter Page]Ford:You is the sum of Romeo and a big big cat.Am I as big as you?If not,let us return to Scene V.Page:You is the sum of a big cat and a cat.Let us return to Act C.Scene V:.Ford:You is the sum of you and the sum of a big big big cat and a pig.Am I as big as you?If not,let us return to Scene X.Page:You big cat.Let us return to Act C.Scene X:.Ford:Am I as big as the sum of you and the sum of a big cat and a cat?If not,let us return to Scene L.Page:You big big cat.Let us return to Act C.Scene L:.Ford:Am I as big as the sum of you and a big big big cat?If not,let us return to Scene C.Page:You is the sum of a big big big cat and a pig.Let us return to Act C.Scene C:.Page:Open thy mind!Is you as big as the sum of Romeo and a cat?You big cat.If so,you is the sum of you and a big big cat.Act C:.Scene I:.[Exit Page][Enter Puck]Ford:You is the sum of you and the quotient between the product of Ajax and I and a big cat.Act D:.Scene I:.Ford:Open thy heart![Exeunt]

Prend l'entrée en tant que chaîne majuscule.

Explication à venir ... Pour le moment, fait amusant: Microsoft est un nom négatif en SPL. Tous les autres mots acceptés sont apparus dans les œuvres de Shakespeare.

Essayez-le en ligne!

Java (OpenJDK 8) , 252 octets

r->{int c[][]={{2,3,4,5,6,7},{4,5,6,7,7,9},{2,2,3,4,6,7}},l=r.length,p="LUOEPM".indexOf(r[0].charAt(0))+1,a=p,i=0;String[]s={"YVOFDZ","VEKIBG","KRDNXS"};for(;i<l-1;)a+=(p+1)*c[i][s[i++].indexOf((l>3?r[i].replace("Ra","X"):r[i]).charAt(0))]/2;return a;}

Essayez-le en ligne!

Les runes sont entrées en tant que String[](tableau deString ), dans le premier cas (première lettre en majuscule, reste en minuscule).

C'est la méthode standard "trouver la n-ième lettre", avec le twist qui existe Roset qui Raexiste dans le 4ème segment. J'ai traité cela avec un remplacement en ligne et explicite de Raà X.

Retina , 124 123 octets

Gor
9
[ZIBS]\w+
7
Mon|Des|Kath|Ra
6
..l|Ew
5
Ee|Oh|Ven|Neta
4
[OVD]\w+
3
[UYKR]\w+
2
Lo
1
\d
$*
(?<=^(1+) .*1)
$1
\G1
11
11

Essayez-le en ligne! Le lien inclut des cas de test. Prend des runes séparées par des espaces. Explication: Les étapes initiales convertissent simplement chaque rune en un chiffre, qui est ensuite converti en unaire. Les nombres qui suivent le premier sont multipliés par un de plus que le premier, puis le premier est doublé. L'entier final divise tout le résultat par 2 et prend la somme.

C, 274

#define c(p,r,x)(p+1)*b(r[x+1],x*17)/2
i;char*a="& ; $ # 4 %        ; B * 6 $ 8          6 5 - >3  +  A@( .   6 5    ";b(r,s)char*r;{for(i=0;i<17;i++)if(a[i+s]-3==(r[0]^r[1]))return i/2+1;return 0;}main(n,r)char**r;{n=b(r[1],0);printf("%d\n",n+c(n,r,1)+c(n,r,2)+c(n,r,3));}

Plus ungolfed:

#include<stdio.h>
char*a="& ; $ # 4 %      "
       "  ; B * 6 $ 8    "
       "      6 5 - >3  +"
       "  A@( .   6 5    ";
int b(char*r,int s){
  for(int i=0;i<17;i++)
    if(a[i+s]-3==(r[0]^r[1]))
      return i/2+1;
  return 0;
}
#define c(p,r,i)(p+1)*b(r[i+1],i*17)/2
int main(int n,char**r){
  int x=b(r[1],0);
  printf("%d\n",x+c(x,r,1)+c(x,r,2)+c(x,r,3));
}

Vous devez fournir quatre arguments en ligne de commande - vous devez donc exécuter le premier cas de test ./a.out Lo Ful "" ""

Go, 205 octets

func c(s []string)int{f,l:=strings.IndexByte,len(s)
p:=f("UOEPM",s[0][0])+3
r:=p-1+p*(f("VOFDZ",s[1][0])+3)/2
if l>2{r+=p*(f("war o",s[2][1])+5)/2}
if l>3{r+=p*(f("it Ra",s[3][len(s[3])-2])+3)/2}
return r}

C'est une fonction appelable, prend les runes comme une tranche de chaînes, par exemple []string{"Um", "Ful"}.

Essayez-le sur le terrain de jeu .

Haskell, 623 octets

Utiliser des ADT au lieu du vaudou numérique.

REMARQUE: Ajoutez 36 pour {-# LANGUAGE GADTs,ViewPatterns #-}

• Le score est calculé en supposant qu'il est compilé / exécuté avec -XGADTs -XViewPatterns

data P=Lo|Um|On|Ee|Pal|Mon deriving(Enum,Read,Eq)
data E=Ya|Vi|Oh|Ful|Des|Zo deriving(Enum,Read,Eq)
data F=Ven|Ew|Kath|Ir|Bro|Gor deriving(Enum,Read,Eq)
data C=Ku|Ros|Dain|Neta|Ra|Sar deriving(Enum,Read,Eq)
data S where
  S::P->E->S
  Q::P->E->F->S
  R::P->E->F->C->S
k(a:b:x)=let{p=read a;e=read b}in case x of{[]->S p e;[c]->Q p e(read c);[c,d]->R p e(read c)(read d)}
c,d::Enum a=>a->Int
c=succ.fromEnum
d=(+2).fromEnum
e Bro=7
e x=(+2).d$x
f x|c x`elem`[1,5,6]=d x|2>1=c x
g p f x =(`div`2).(*f x).succ$c p
h(S x y)=c x+g x d y
h(Q x y z)=h(S x y)+g x e z
h(R x y z t)=h(Q x y z)+g x f t
main=print.h.k.words=<<getLine

Entrée: un seul sort sous forme de chaîne normale, par exemple

Lo Ful

Um Ful

La multiplication peut être effectuée en remplaçant la dernière ligne par

main=interact$unlines.map(show.h.k.words).lines

Mais cela ajouterait des octets au compte