In Skyrim, il personaggio del giocatore può usare potenti grida magiche (Thu'ums) per raggiungere i propri obiettivi. Ogni grido è composto da tre parole, tuttavia, il giocatore può usare la prima o due parole per ottenere lo stesso effetto con meno potenza ma con un tempo di recupero più breve.

Data una frase ASCII minuscola senza punteggiatura o spazi , restituisci quante parole di potere contiene.

Esempio:

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

L'input sarà sempre una stringa ASCII minuscola formata prendendo uno dei grida seguenti, scegliendo le prime 1, 2 o 3 parole da quel grido e concatenando le parole in ordine.

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

Quindi fus, fusroe fusrodahsono tutti input validi, ma fusroviirnon è perché utilizza parole da grida miste, e rodahnon è perché non è un prefisso di un grido. Inoltre, non è necessario gestire l'input di stringa vuoto.

Vince il codice più breve in byte.

Retina, 78 42 15 14 byte

ul
xo
[aeiou]+

Provalo online

tiidkloul è l'unica parola che non ha la stessa quantità di sequenze vocali del numero che si suppone debba essere stampato. Pertanto dobbiamo abbinare la parola per darle una sequenza vocale in più. oucorrisponderà solo a tiidkl ou e potremo quindi sostituire ou con oxo che crea la sequenza aggiuntiva.

Il mio approccio iniziale non era così semplice, ma si basava sulla rimozione di tutte le consonanti, quindi sulla rimozione di alcune sequenze vocaliche ( ai|ii|aa|...) e infine sul conteggio del numero di lettere. Ma grazie a @Martin Büttner per aver pensato [aeiou]+invece.

Retina , 313 byte

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)

Provalo online!

Sulla base di alcune semplici osservazioni:

• Tutte le parole sono uniche, indipendentemente dalla loro posizione.
• Nessuna parola è un prefisso di un'altra parola.
• L'input è garantito per essere valido.

Ciò significa che possiamo semplicemente contare quante parole compaiono nella stringa senza sovrapposizioni. Questo è esattamente ciò che fa una regex. Ho provato a comprimere il regex un po 'oltre il concatenare tutte le parole con |(che sarebbe 351 byte), ma sono sicuro che questo non è ottimale. Per cominciare, sicuramente non ho sfruttato in modo ottimale tutte le parti comuni. Ma ancora più importante, è possibile comprimere ulteriormente la stringa facendola corrispondere a più stringhe di parole valide, purché queste non possano accidentalmente corrispondere a parti di una parola valida (perché in questo caso non verranno mai abbinate). Sono abbastanza sicuro che uno dovrebbe automatizzare la compressione per essere davvero sicuro che sia ottimale.

Perl 5, 28 byte

Il conteggio dei byte ne include uno per -p.

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

Rubato direttamente da dev-null . (Grazie, dev-null!)