Dungeon Master to jedna z pierwszych gier fabularnych czasu rzeczywistego, pierwotnie wydana w 1987 roku na Atari ST. Wśród innych ekscytujących rzeczy na ten czas oferował dość wyrafinowany system zaklęć oparty na runach.

Twoim zadaniem dzisiaj jest napisanie programu lub funkcji, która ocenia liczbę punktów many wymaganych do rzucenia danego zaklęcia w Dungeon Master.

^{System „rzucania zaklęć” jest prawym górnym cyjanem na powyższym obrazku.}

Czary, runy i many

Czary Mistrza Lochów składają się z 2 do 4 run, wybranych spośród następujących kategorii, w dokładnie takiej kolejności:

1. Moc (obowiązkowe)
2. Wpływ żywiołów (obowiązkowy)
3. Formularz (opcjonalnie)
4. Klasa / wyrównanie (opcjonalnie)

Oznacza to, że prawidłowe zaklęcia to:

• Moc + Wpływ Żywiołów
• Moc + Wpływ Żywiołów + Forma
• Moc + Wpływ Żywiołów + Forma + Klasa / Wyrównanie

Każda kategoria zawiera 6 run, a każda runa ma powiązany podstawowy koszt many:

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

Ocena kosztu many

Koszt many zaklęcia to suma kosztu many wszystkich run:

• Koszt runy Mocy zawsze jest równy jej kosztowi podstawowemu (od 1 do 6).

• W przypadku innych run obowiązuje następująca formuła:

  

  gdzie moc jest kosztem podstawowym runy Mocy.

Przykłady

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

Wyjaśnienia i zasady

• Twój wkład będzie się składał z 2 do 4 łańcuchów oznaczających runy zaklęcia. Możesz wziąć je w dowolnym rozsądnym formacie, takim jak 4 różne parametry, tablica ciągów znaków (np. ['Lo', 'Ful']) Lub tylko jeden ciąg znaków z wybranym separatorem jednoznakowym (np 'Lo Ful'.). Podaj wybrany format wejściowy w swojej odpowiedzi.
• Runy mają gwarancję ważności.
• Kolejność kategorii musi być przestrzegana. Niewykorzystane kategorie mogą być brakujące lub zastąpione pewną wartością fałszowania.
• Możesz zaakceptować runy w dowolnym z następujących formatów: 1. Wielka litera, po której następuje mała litera ( 'Ful') 2. Wszystkie małe litery ( 'ful') 3. Wszystkie wielkie litery ( 'FUL'). Ale nie można mieszać różnych formatów.
• Oczywiście nie dbamy o to, czy zaklęcie rzeczywiście ma jakiś wpływ na grę (bo ciekawe, przydatne zaklęcia są wymienione tutaj ).
• To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.
• I pamiętaj: Lord Chaos cię obserwuje!

Przypadki testowe

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 bajtów

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

Wypróbuj tutaj!

Prawdopodobnie mógłby golfa bajt lub dwa z przerobić wszystko

Wyjaśnienie:

θ            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 bajtów

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

Wypróbuj online!

Dane wejściowe to lista ciągów ze standardowego wejścia

05AB1E , 83 82 bajty

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

Wypróbuj online!

-1 dzięki Emignie .

SOOOOOOO bez golfa :(

Wyjaśnienie:

.•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 bajtów

Pobiera dane wejściowe jako tablicę ciągów.

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

• Zaoszczędził masywne 44 bajty, pożyczając sztuczkę indeksowania z rozwiązania Python firmy ovs - jeśli popierasz tę odpowiedź, również ją oceń.
• Oszczędność 13 bajtów dzięki Arnauldowi wskazującemu, co powinno być oczywistą okazją do użycia trójki.

Wypróbuj online!

Wyjaśnienie

Hoo, chłopcze, będzie fajnie - moje objaśnienia do trywialnych rozwiązań są do bani! Spróbujmy ...

a=>

Anonimowa funkcja przyjmująca tablicę jako argument za pomocą parametru a.

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

Zmniejsz elementy w tablicy, przepuszczając każdy przez funkcję; tparametrem jest uruchomiony sumie w cparametrem jest prąd i łańcuch 0jest wartość początkowa t.

parseInt(c,36)

Konwertuj bieżący element z ciągu podstawowego 36 na liczbę całkowitą dziesiętną.

%141%83%50%23

Wykonaj na nim kilka operacji modulo.

+`27169735 2  4567 435262`[]

Chwyć znak z ciągu o tym indeksie i przekonwertuj go na liczbę.

v=

Przypisz tę liczbę do zmiennej v.

+a?

Sprawdź, czy zmienna ajest liczbą. Pierwszym elementem abędzie tablica ciągów, próba konwersji tego na liczbę zwróci NaN, co jest falsey. Przy każdym kolejnym przejściu abędzie dodatnia liczba całkowita, co jest zgodne z prawdą.

a*v+v>>1

Jeśli ajest liczbą, mnożymy ją przez wartość v, dodajemy wartość vi przesuwamy bity wyniku o 1 bit w prawo, co daje taki sam wynik jak dzielenie przez 2 i podłogę.

:a=v

Jeśli anie jest liczbą, przypisujemy jej wartość v, co da nam również 0dodanie do naszej sumy przy pierwszym przejściu.

t+

Na koniec dodajemy wynik z trójki powyżej do naszej sumy bieżącej.

Oryginalny, 156 bajtów

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 bajtów

Prosty algorytm wyszukiwania, ciągi wyszukiwania po prostu przyczyniają się do całkowitej liczby bajtów.

Kod

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 wejściowy

Tablica ciągów, każdy element jest ciągiem wielkich liter. Przykład: [„Pon”, „Zo”, „Ir”, „Neta”]

Wyjaśnienie

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

To pytanie o podstawowe koszty.

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

Inicjuje 2 zmienne pierwszym elementem z powyższego wyniku tablicy i usuwa ten element. Najpierw musi być rzutowany na numer, w przeciwnym razie będzie traktowany jako konkatenacja łańcucha w następnej części.

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

Dodaje koszty run innych niż moc do mocy podstawowej. Przesunięcie stosuje się zamiast podłogi (bla) / 2.

eval(/*blah*/;p)

Oceń ostatni wynik. (Źródło: Step Hen)

Przypadki testowe

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

Edycja 1: 212> 210 - Usunięto parę aparatów ortodontycznych

Edycja 2: 210> 207 - Dziękuję Krok Hen za przypomnienie zasad JS i podpowiedź na temat korzystania z funkcji eval (). Ponieważ AS3 zabrania używania eval (), nie używałem tego przez długi czas

Edytuj 3: 207> 206 - Dzięki Shaggy za pomysł zamiany indexOf () na search ()

Haskell , 159 156 148 133 130 127 bajtów

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

Wypróbuj online!

Python 2 , 320 318 314 311 307 bajtów

Format wejściowy - lista ciągów. Pełny program:

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)

Wypróbuj online!

Excel, 339 bajtów

Wprowadzone dane wejściowe A1za pośrednictwem D1. Formuła w dowolnej innej komórce.

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

Alternatywnie, importowanie jako CSV:

Excel i CSV, 228 bajtów

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

Dane wejściowe wprowadzone w pierwszym wierszu SPACEdla wartości null. Wynik wyświetlany w A3.

SCALA, 1106 znaków, 1106 bajtów

To jest dość długie, prawdopodobnie możliwe do zoptymalizowania, ale fajnie było to zrobić :)

Format wejściowy : runy rozdzielone spacjami w ciągu. Jeśli są tylko 2 dane wejściowe (np. „Lo Ful”), mój kod uzupełnia je while(k.length<4)k:+=""(dzięki czemu mogę zapisać 24 bajty , zmieniając parametry, jeśli wymagam, aby było to „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}}}}

Dzięki za to wspaniałe wyzwanie. Wypróbuj online!

Język programowania Szekspira , 4420 bajtów

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

Pobiera dane wejściowe jako ciąg wielkich liter.

Wyjaśnienie już wkrótce ... Zabawny fakt: Microsoft to rzeczownik przeczący w języku SPL. Wszystkie inne przyjęte słowa pojawiły się w dziełach Szekspira.

Wypróbuj online!

Java (OpenJDK 8) , 252 bajty

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

Wypróbuj online!

Runy są wprowadzane jako String[](tablicaString ), w pierwszej formie (pierwsza litera to duża litera, reszta to małe litery).

Jest to standard „znaleźć n-tej litery” metoda, przy skręcie, że zarówno Rosi Rawystępują w 4 segmencie. Traktowałem to z bezpośrednim zastąpieniem Rado X.

Siatkówka , 124 123 bajty

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

Wypróbuj online! Link zawiera przypadki testowe. Wykonuje runy rozdzielone spacjami. Objaśnienie: Początkowe etapy po prostu zamieniają każdą runę na cyfrę, która jest następnie konwertowana na unarną. Liczby po pierwszym są pomnożone przez jeden więcej niż pierwszy numer, po czym pierwsza liczba zostaje podwojona. Liczba całkowita z ostatniego etapu dzieli wynik przez 2 i przyjmuje sumę.

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

Więcej nie golfistów:

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

Musisz podać cztery argumenty wiersza poleceń - więc w pierwszym przypadku testowym musisz uruchomić ./a.out Lo Ful "" ""

Idź, 205 bajtów

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}

Jest to funkcja wywoływalna, pobiera runy jako kawałek ciągów znaków, np []string{"Um", "Ful"}.

Wypróbuj na Play Playground .

Haskell, 623 bajty

Używanie narzędzi ADT zamiast numerycznego voodoo.

UWAGA: Dodaj 36 dla {-# LANGUAGE GADTs,ViewPatterns #-}

• Wynik jest obliczany przy założeniu, że jest on kompilowany / uruchamiany -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

Dane wejściowe: pojedynczy czar jako zwykły ciąg znaków, np

Lo Ful

Um Ful

Multilinowanie można wykonać, zamieniając ostatni wiersz na

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

Ale to dodałoby bajty do liczby