Dato un input di un verbo spagnolo nella sua forma infinita, emette il verbo coniugato in tutte e 6 le forme dell'imperfetto indicativo.

Per coniugare un infinito nell'imperfetto, rimuovere la desinenza infinita (-ar, -er, -ir e talvolta -ír) e aggiungere le desinenze imperfette elencate di seguito. Ci sono tre verbi irregolari nell'imperfetto, elencati anche di seguito.

Verb ending    Replace with...
--------------------------------------------------------
-ar            -aba, -abas, -aba, -ábamos, -abais, -aban
-er, -ir, -ír  -ía,  -ías,  -ía,  -íamos,  -íais,  -ían

Irreg. verb    Conjugations
--------------------------------------------------------
ser            era,  eras,  era,  éramos,  erais,  eran
ver            veía, veías, veía, veíamos, veíais, veían
ir             iba,  ibas,  iba,  íbamos,  ibais,  iban

Ai fini di questa sfida, utilizzare le lettere maiuscole anziché le lettere accentate (á diventa A, é diventa E e í diventa I). Questo solo perché le lettere accentate sono 2 byte in UTF-8, ma possono essere diverse in altre codifiche, e preferirei non doverne fare a meno e rimanere all'interno di ASCII stampabile.

I verbi infiniti saranno sempre lunghi tre o più caratteri con la sola eccezione del verbo ir , non conterranno mai lettere accentate con l'eccezione dei verbi che terminano in -ír e finiranno sempre in -ar, -er, -ir, oppure -ír. I verbi riflessivi non devono essere gestiti.

L'output può essere nella forma di una stringa separata da spazi bianchi / virgola (quindi la stampa di ogni coniugazione su STDOUT sulla propria riga va bene) o una matrice / lista / ecc.

Dato che si tratta di code-golf , vince il codice più breve in byte.

Casi test:

In       Out
---------------------------------------------------------------
hablar   hablaba hablabas hablaba hablAbamos hablabais hablaban
comer    comIa comIas comIa comIamos comIais comIan
vivir    vivIa vivIas vivIa vivIamos vivIais vivIan
sonreIr  sonreIa sonreIas sonreIa sonreIamos sonreIais sonreIan
ser      era eras era Eramos erais eran
ver      veIa veIas veIa veIamos veIais veIan
ir       iba ibas iba Ibamos ibais iban

Retina , 100 82 byte

\B[^a]r$
I
r$
b
^vI$
veI
^sI$
er
$
a
$
 $_s $_ $_mos $_is $_n
T`l`L`.(?=[^I]amos )

Provalo online. Sfortunatamente, a causa dell'uso di $_non è possibile modificare il codice per eseguire tutti i test contemporaneamente, quindi dovrai copiarli nei singoli verbi. Sto lavorando a una nuova funzionalità che renderà possibile tutto ciò.

Spiegazione

\B[^a]r$
I

Iniziamo trasformando tutti i finali che non sono arin I, a condizione che l'input non sia il verbo irregolare ir. Che si occupa della -er, -ir, -írconiugazioni, scombina i verbi irregolari sere ver(ma li accorcia nel processo), e lascia solo ire -arcon un finale r.

r$
b

Se la parola finisce ancora r, la sostituiamo con a b. Ora abbiamo coperto tutte le coniugazioni standard e il verbo irregolare ir.

^vI$
veI

Questo risolve il verbo irregolare verche è stato trasformato nella vIprima fase.

^sI$
er

Questo risolve il verbo irregolare serche è stato trasformato nella sIprima fase. Ora abbiamo modificato correttamente tutti gli steli possibili. Tutto quello che resta da fare è aggiungere tutti i finali possibili, e quindi correggere l'accento per il plurale in prima persona in alcuni casi.

$
a

Per prima cosa aggiungiamo una aradice, perché fa sempre parte di tutti i finali.

$
 $_s $_ $_mos $_is $_n

Questo utilizza il raramente visto $_che inserisce l'intera stringa nella sostituzione (indipendentemente da ciò che è stato abbinato). Questo è in realtà molto utile quando si duplicano stringhe, come sono $`e $', che sono anche abbastanza sottovalutate.

Prima di questo stadio, abbiamo la prima persona singolare nella stringa. Aggiungiamo ora le altre coniugazioni, abbinando la fine della stringa $e costruendo le altre forme aggiungendo i suffissi appropriati alla prima persona singolare.

T`l`L`.(?=[^I]amos )

Infine, fissiamo l'accento per il plurale in prima persona, se applicabile. Questo deve essere fatto solo per una vocale, due personaggi davanti al -amos meno che non sia il personaggio in mezzo I. Quindi abbiniamo un tale personaggio e quindi usiamo una fase di traslitterazione per convertire maiuscole e minuscole. Questo fa uso delle nuove classi di personaggi le Lche ho aggiunto solo ieri. Si espandono a-ze A-Zrispettivamente, in modo che la nuova funzionalità salvi 4 byte qui.

Python 3, 154 232 byte

M=input()
Q={'ser':'er','ver':'veI','ir':'ib'}.get(M)
H=[(Q if Q else M[:-2]+("ab"if M[-2:]=="ar"else"I"))+j for j in"a as a amos ais an".split(' ')]
if M[-2:]=="ar":H[3]=M[:-2]+"Abamos"
if Q in['er','ib']:H[3]=H[3].title()
print(H)

Risolti i capitoli mancanti nei verbi irregolari.

Ungolfed

M=input()
Q={'ser':'er','ver':'veI','ir':'ib'}.get(M)

H=[]
for j in "a as a amos ais an".split(' '):
    if Q:
        F = Q
    else:
        if M[-2:] == "ar":
            F = M[:-2] + "ab"
        else:
            F = M[:-2] + "I"
    H += [F + j]

if M[-2:] == "ar":
    H[3] = M[:-2] + "Abamos"

if Q in ['er', 'ib']:
    H[3] = H[3].title()

print(H)

Via Lattea 1.6.2 , 281 byte

'?{"ser"b_^"er";_}?{"ver"b_^"veI";_}?{"ir"b_^"ib";_}?{_:y2->CH=<1-&{~>;+<1-}^>;+<;_^""0}?{"ar"b_"ab";>+<0_}?{_"I";>+<_^}^;^"an ais amos a as a"" "\?{<y__<^}=3&{~<:>;>;+!^<1-}^?{'C=^"a"b_'C:y2->=^^<ΩG"Abamos"+!^^_}?{<"er"b_"Eramos"!^^_}?{<"ib"b_"Ibamos"!^^_}J:y1-;=<&{~<:>;>;+!^<1-}

Bene che ha preso un po '! Sembra che debba aggiungere alcuni builtin, hehe ...

uso

./mw <path-to-code> -i <input>

Esempi

$ ./mw test.mwg -i "hablar"
hablaba
hablabas
hablaba
hablAbamos
hablabais
hablaban

$ ./mw test.mwg -i "ver"
veIa
veIas
veIa
veIamos
veIais
veIan

Rubino, 151 149

Normalmente, sceglierò una nuova riga sopra un punto e virgola ove possibile nell'interesse della leggibilità, ma poiché non ci sono punti e virgola, questa è una riga.

->n{%w{a as a amos ais an}.map{|z|['3r','veI','1b',n[0..-3]+(n[-2]==?a?'@b':?I)][("ser ver ir  "+n).index(n)/4].tr('31@',['eia','EIA'][z.size/4])+z}}

Una caratteristica è l'uso di segnaposto 31@per le vocali accentate che dipendono dalle amosterminazioni. In questo modo si forma il gambo corretto e quindi il segnaposto viene sostituito con uno dieia o EIAcome appropriato

Ci sono alcuni usi di indici di array negativi qui. cosìn[-2] riferisce al penultimo carattere dell'input e si n[0..-3]riferisce all'input con gli ultimi 2 caratteri rimossi (il gambo infinito).

Non registrato nel programma di test

f=->n{
%w{a as a amos ais an}.map{|z|            #iterate through each verb ending
    ['3r','veI','1b',                     #array index 0,1,2 formats for irregular stems (note numbers 1 and 3 used as placeholders)
    n[0..-3]+(n[-2]==?a?'@b':?I)][        #array index 3 format for regular stems, AR->@b or ER/IR->I depending if A found at index -2 (@ used as placeholder)
    ("ser ver ir  "+n).index(n)/4]        #find index of input verb n in "ser ver ir  "+n, divide by 4 to obtain 0,1,2,3 above
    .tr('31@',['eia','EIA'][z.size/4])+   #if z is 4 characters long (AMOS) replace 3,1,@ with uppercase E,I,A. Otherwise with lowercase e,i,a
    z                                     #add the verb ending to the stem
  }
}

n=gets.chop
puts f[n]