Em Skyrim, o personagem do jogador pode usar poderosos gritos de mágica (Qui) para alcançar seus objetivos. Cada grito consiste em três palavras, no entanto, o jogador pode usar as primeiras uma ou duas palavras para obter o mesmo efeito com menos potência, mas com um tempo de espera mais curto.

Dada uma frase ASCII Thu'um minúscula sem pontuação ou espaços , retorne quantas palavras de poder ela contém.

Exemplo:

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

A entrada sempre será uma sequência ASCII em minúscula, formada por um dos gritos abaixo, escolhendo as primeiras 1, 2 ou 3 palavras desse grito e concatenando as palavras em ordem.

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

Assim fus, fusroe fusrodahsão todas as entradas válidas, mas fusroviirnão é porque ele usa palavras de gritos mistos, e rodahnão é porque não é um prefixo de um grito. Você também não precisa lidar com a entrada de string vazia.

O menor código em bytes vence.

Retina, 78 42 15 14 bytes

ul
xo
[aeiou]+

Experimente online

tiidkloul é a única palavra que não possui a mesma quantidade de seqüências de vogais que o número que deve ser impresso. Portanto, precisamos corresponder à palavra para fornecer uma sequência de vogal extra. ousó irá corresponder tiidkl OU l e que pode então substituir UO com oxo , que cria a sequência adicional.

Minha abordagem inicial não foi tão simples, mas foi criada para remover todas as consoantes, remover algumas sequências de vogais ( ai|ii|aa|...) e, finalmente, contar o número de letras. Mas obrigado a @Martin Büttner por pensar nisso[aeiou]+ .

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)

Experimente online!

Com base em algumas observações simples:

• Todas as palavras são únicas, independentemente de sua posição.
• Nenhuma palavra é um prefixo de outra palavra.
• A entrada é garantida como válida.

Isso significa que podemos simplesmente contar quantas palavras aparecem na string sem sobreposição. Isso é exatamente o que um regex faz. Eu tentei compactar o regex um pouco além de concatenar todas as palavras com |(que seriam 351 bytes), mas tenho certeza que isso está longe de ser o ideal. Para começar, definitivamente não explorei todas as partes comuns de maneira otimizada. Mais importante, porém, é possível compactar ainda mais a string, fazendo com que ela corresponda a mais strings do que palavras válidas, desde que essas palavras não possam coincidir acidentalmente com parte de uma palavra válida (porque elas nunca serão correspondidas). Tenho certeza de que seria necessário automatizar a compactação para ter certeza de que é ideal.

Perl 5, 28 bytes

A contagem de bytes inclui um para -p.

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

Roubado direto do dev-null . (Obrigado, dev-null!)