Dungeon Master è stato uno dei primi giochi di ruolo in tempo reale, originariamente pubblicato nel 1987 su Atari ST. Tra le altre cose interessanti per l'epoca, offriva un sistema di incantesimi piuttosto sofisticato basato sulle rune.

Il tuo compito oggi è scrivere un programma o una funzione che valuti il ​​numero di punti Mana richiesti per lanciare un determinato incantesimo in Dungeon Master.

^{Il sistema "incantesimo" è la casella ciano in alto a destra nella figura sopra.}

Incantesimi, rune e mana

Gli incantesimi Dungeon Master sono composti da 2 a 4 rune, scelte tra le seguenti categorie, in questo preciso ordine:

1. Potenza (obbligatoria)
2. Influenza elementale (obbligatoria)
3. Modulo (facoltativo)
4. Classe / Allineamento (opzionale)

Significa che gli incantesimi validi sono:

• Potenza + Influenza elementale
• Potenza + Influenza elementale + Forma
• Potenza + Influenza elementale + Forma + Classe / Allineamento

Ogni categoria contiene 6 rune e ogni runa ha un costo di mana di base associato:

=============================================================================
| 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 |
=============================================================================

Valutazione del costo in mana

Il costo in mana dell'incantesimo è la somma del costo in mana di tutte le rune:

• Il costo della runa di potenza è sempre uguale al suo costo base (da 1 a 6).

• Per le altre rune, si applica la seguente formula:

  

  dove potere è il costo base della runa di potere.

Esempi

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

Chiarimenti e regole

• Il tuo input sarà composto da 2 a 4 stringhe che designano le rune dell'incantesimo. Puoi prenderli in qualsiasi formato ragionevole, ad esempio 4 parametri distinti, una matrice di stringhe (ad esempio ['Lo', 'Ful']) o solo una stringa con un separatore a carattere singolo di tua scelta (ad esempio 'Lo Ful'). Si prega di specificare il formato di input selezionato nella risposta.
• Le rune sono garantite per essere valide.
• L'ordine delle categorie deve essere rispettato. Le categorie non utilizzate possono essere mancanti o sostituite con un valore errato.
• Puoi accettare le rune in uno di questi formati: 1. Una lettera maiuscola seguita da lettere minuscole ( 'Ful') 2. Tutte le lettere minuscole ( 'ful') 3. Tutte le lettere maiuscole ( 'FUL'). Ma non puoi mescolare diversi formati.
• Ovviamente, non ci interessa sapere se l'incantesimo ha effettivamente qualche effetto nel gioco (per gli incantesimi curiosi e utili sono elencati qui .)
• Questo è code-golf , quindi vince il codice più breve in byte.
• E ricorda: Lord Chaos ti sta guardando!

Casi 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 byte

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

Provalo qui!

Probabilmente potrebbe golf un byte o due dal rifare tutto

Spiegazione:

θ            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 byte

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:])

Provalo online!

L'input è un elenco di stringhe da stdin

05AB1E , 83 82 byte

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

Provalo online!

-1 grazie a Emigna .

SOOOOOOO ungolfed :(

Spiegazione:

.•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 byte

Accetta input come una matrice di stringhe.

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

• Hai risparmiato ben 44 byte prendendo in prestito il trucco dell'indicizzazione dalla soluzione Python di ovs - se stai votando questa risposta, per favore vota anche quella.
• Risparmiato 13 byte grazie ad Arnauld sottolineando quale avrebbe dovuto essere un'ovvia opportunità di usare un ternario.

Provalo online!

Spiegazione

Ciao, ragazzo, sarà divertente - le mie spiegazioni su soluzioni banali fanno schifo nel migliore dei casi! Proviamo ...

a=>

Una funzione anonima che prende l'array come argomento tramite parametro a.

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

Ridurre gli elementi nell'array passando ciascuno attraverso una funzione; il tparametro è il totale parziale, il cparametro è la stringa corrente ed 0è il valore iniziale di t.

parseInt(c,36)

Converti l'elemento corrente da una stringa 36 di base in un numero intero decimale.

%141%83%50%23

Eseguire alcune operazioni del modulo su di esso.

+`27169735 2  4567 435262`[]

Prendi il carattere dalla stringa in quell'indice e convertilo in un numero.

v=

Assegna quel numero alla variabile v.

+a?

Controlla se la variabile aè un numero. Poiché il primo elemento asarà l'array di stringhe, verrà restituito il tentativo di convertirlo in un numero NaN, il che è falso. Ad ogni passaggio successivo, asarà un numero intero positivo, il che è vero.

a*v+v>>1

Se aè un numero, lo moltiplichiamo per il valore di v, aggiungiamo il valore di ve spostiamo i bit del risultato di 1 bit a destra, il che dà lo stesso risultato della divisione per 2 e pavimentazione.

:a=v

Se anon è un numero, ne assegniamo il valore v, che ci darà anche un valore 0da aggiungere al nostro totale al primo passaggio.

t+

Infine, aggiungiamo il risultato dal ternario sopra al nostro totale corrente.

Originale, 156 byte

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 byte

Algoritmo di ricerca diretto, le stringhe di ricerca stanno solo contribuendo ai byte totali.

Codice

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')

Formato di input

Serie di stringhe, ogni elemento è una stringa in maiuscolo. Esempio: ["Mon", "Zo", "Ir", "Neta"]

Spiegazione

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

Ciò richiede i costi di base.

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

Inizializza 2 variabili con il primo elemento dal risultato della matrice sopra e rimuove quell'elemento. Deve essere castato per primo, altrimenti verrà considerato come concatenazione di stringhe nella parte successiva.

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

Aggiunge i costi delle rune non elettriche alla potenza di base. Shifting è usato al posto di floor (blah) / 2.

eval(/*blah*/;p)

Valuta l'ultimo risultato. (Credito: Step Hen)

Casi 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

Modifica 1: 212> 210 - Rimosso un paio di parentesi graffe

Modifica 2: 210> 207 - Grazie Step Hen per il promemoria sulle regole JS e qualche suggerimento sull'uso della funzione eval (). Poiché AS3 vieta l'uso di eval () non lo uso da molto tempo

Modifica 3: 207> 206 - Grazie a Shaggy per l'idea di sostituire indexOf () con search ()

Haskell , 159 156 148 133 130 127 byte

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

Provalo online!

Python 2 , 320 318 314 311 307 byte

Formato di input - Elenco di stringhe. Programma completo:

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)

Provalo online!

Excel, 339 byte

Ingressi immessi A1attraverso D1. Formula in qualsiasi altra cella.

=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)

In alternativa, importando come CSV:

Excel e CSV, 228 byte

,,,
=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)

Input inserito nella prima riga, SPACEper valori null. Il risultato è visualizzato in A3.

SCALA, 1106 caratteri, 1106 byte

Questo è piuttosto lungo, probabilmente ottimizzabile, ma è stato divertente da fare :)

Formato di input : rune separate da spazi in una stringa. Se ci sono solo 2 ingressi (come "Lo Ful") il mio codice lo completa while(k.length<4)k:+=""(quindi posso salvare 24 byte modificando i parametri, se ho bisogno che sia "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}}}}

Grazie per questa fantastica sfida. Provalo online!

Shakespeare Programming Language , 4420 byte

,.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]

Accetta l'input come una stringa maiuscola.

Spiegazione in arrivo ... Per ora, Curiosità: Microsoft è un sostantivo negativo in SPL. Tutte le altre parole accettate sono apparse nelle opere di Shakespeare.

Provalo online!

Java (OpenJDK 8) , 252 byte

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;}

Provalo online!

Le rune sono inserite come un String[](array di String), nel primo caso (la prima lettera è maiuscola, il resto è minuscolo).

È il metodo standard "trova la lettera n-esima", con il twist che entrambi Rosed Raesistono nel quarto segmento. L'ho trattato con una sostituzione in linea ed esplicita diRa a X.

Retina , 124 123 byte

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

Provalo online! Il link include casi di test. Prende rune separate da spazi. Spiegazione: Le fasi iniziali convertono semplicemente ciascuna runa in una cifra, che viene quindi convertita in unaria. I numeri dopo il primo vengono moltiplicati per uno in più rispetto al primo numero, dopo di che il primo numero viene raddoppiato. L'intero stadio finale divide tutto il risultato per 2 e prende la somma.

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));}

Più 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));
}

È necessario fornire quattro argomenti della riga di comando, quindi per il primo caso di test è necessario eseguire ./a.out Lo Ful "" ""

Vai, 205 byte

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}

È una funzione richiamabile, prende le rune come una fetta di stringhe, ad es []string{"Um", "Ful"} .

Provalo sul Go Playground .

Haskell, 623 byte

Usando gli ADT invece del voodoo numerico.

NOTA: aggiungere 36 per {-# LANGUAGE GADTs,ViewPatterns #-}

• Il punteggio viene calcolato assumendo che sia compilato / eseguito con -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

Input: un singolo incantesimo come una normale stringa ad es

Lo Ful

Um Ful

La multilinea può essere effettuata sostituendo l'ultima riga con

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

Ma questo aggiungerebbe byte al conteggio