En Skyrim, el personaje del jugador puede usar poderosos gritos mágicos (Thu'ums) para lograr sus objetivos. Cada grito consta de tres palabras, sin embargo, el jugador puede usar la primera o dos palabras para lograr el mismo efecto con menos poder pero con un tiempo de reutilización más corto.

Dada una frase ASCII Thu'um en minúscula sin puntuación ni espacios , devuelve cuántas palabras de poder contiene.

Ejemplo:

fusrodah   -> 3
dur        -> 1
kaandrem   -> 2
odah       -> 2
vengaarnos -> 3

La entrada siempre será una cadena ASCII en minúscula formada tomando uno de los gritos a continuación, eligiendo las primeras 1, 2 o 3 palabras de ese grito y concatenando las palabras en orden.

dur neh viir
faas ru maar
feim zii gron
fo krah diin
fus ro dah
gaan lah haas
gol hah dov
hun kaal zoor
iiz slen nus
joor zah frul
kaan drem ov
krii lun aus
laas yah nir
lok vah koor
mid vur shaan
mul qah diiv
od ah viing
raan mir tah
rii vaaz zol
strun bah qo
su grah dun
tiid klo ul
ven gaar nos
wuld nah kest
yol toor shul
zul mey gut
zun haal viik

Entonces fus, fusroy fusrodahson todas entradas válidas, pero fusroviirno porque use palabras de gritos mixtos, y rodahno porque no sea el prefijo de un grito. Tampoco tiene que manejar la entrada de cadena vacía.

El código más corto en bytes gana.

Retina, 78 42 15 14 bytes

ul
xo
[aeiou]+

Pruébalo en línea

tiidkloul es la única palabra que no tiene la misma cantidad de secuencias de vocales que el número que se supone debe imprimirse. Por lo tanto, debemos hacer coincidir la palabra para darle una secuencia vocal adicional. ousolo coincidirá con tiidkl ou l y luego podemos reemplazar ou con oxo, lo que crea la secuencia adicional.

Mi enfoque inicial no fue tan simple, sino que se basó en eliminar todas las consonantes, luego eliminar algunas secuencias de vocales ( ai|ii|aa|...) y finalmente contar los números de letras. Pero gracias a @Martin Büttner por pensar en su [aeiou]+lugar.

Retina , 313 bytes

ah|aus|bah|d(ah|ii[nv]|ov|rem|u[nr])|[fhl]aas|f(eim|o|rul|us)|g(aa[nr]|ol|rah|ron|ut)|haal|hah|hun|iiz|joor|k(aa[ln]|est|lo|oor|rah|rii)|lah|lok|lun|m(aar|ey|i[dr]|ul)|n[ae]h|nir|n[ou]s|od|ov|qah|qo|r(aan|ii|o|u)|s(haan|hul|len|trun|u)|tah|tiid|toor|ul|v(aaz|ah|en|iin?[gkr]|ur)|wuld|yah|yol|z(ah|ii|[ou][ln]|oor)

Pruébalo en línea!

Basado en algunas observaciones simples:

• Todas las palabras son únicas, independientemente de su posición.
• Ninguna palabra es un prefijo de otra palabra.
• La entrada está garantizada para ser válida.

Eso significa que simplemente podemos contar cuántas palabras aparecen en la cadena sin superposición. Eso es exactamente lo que hace una expresión regular. Intenté comprimir la expresión regular un poco más allá de concatenar todas las palabras con |(que serían 351 bytes), pero estoy seguro de que esto está lejos de ser óptimo. Para empezar, definitivamente no he explotado todas las partes comunes de manera óptima. Pero lo que es más importante, es posible comprimir la cadena aún más haciendo que coincida con más cadenas que palabras válidas, siempre que esas no puedan coincidir accidentalmente con parte de una palabra válida (porque entonces nunca coincidirán). Estoy bastante seguro de que uno debería automatizar la compresión para estar realmente seguro de que es óptima.

Perl 5, 28 bytes

El recuento de bytes incluye uno para -p.

s/ou/oxo/;$_=()=/[aeiou]+/g

Robado directamente de dev-null . (¡Gracias, dev-null!)