Dada a entrada de um verbo espanhol em sua forma infinitiva, produza o verbo conjugado em todas as 6 formas do indicativo imperfeito.

Para conjugar um infinitivo no imperfeito, remova a desinência infinitiva (-ar, -er, -ir e algumas vezes -ír) e adicione as desinências imperfeitas listadas abaixo. Existem três verbos irregulares no imperfeito, também listados abaixo.

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

Para os propósitos deste desafio, use letras maiúsculas em vez de letras acentuadas (á se torna A, é se torna E e i se torna I). Isso ocorre apenas porque as letras acentuadas têm 2 bytes em UTF-8, mas elas podem ser diferentes em outras codificações, e eu prefiro não ter que lidar com nada disso e permanecer no ASCII imprimível.

Os verbos infinitivos sempre terão três ou mais caracteres, com a única exceção do verbo ir , nunca conterão letras acentuadas, com exceção dos verbos que terminam em -ír e sempre terminam em -ar, -er, -ir, ou -ír. Os verbos reflexivos não precisam ser manuseados.

A saída pode estar na forma de uma cadeia de caracteres separada por espaço em branco / vírgula (portanto, imprimir cada conjugação em STDOUT em sua própria linha é aceitável) ou um array / lista / etc.

Como esse é o código-golfe , o código mais curto em bytes vence.

Casos de teste:

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 bytes

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

Experimente online. Infelizmente, devido ao uso $_, não é possível modificar o código para executar todos os testes de uma só vez; portanto, você precisará copiar os verbos individuais. Estou trabalhando em um novo recurso que tornará isso possível.

Explicação

\B[^a]r$
I

Começamos transformando todas as terminações que não estão ardentro I, desde que a entrada não seja o verbo irregular ir. Que cuida do -er, -ir, -írconjugações, mexe-se os verbos irregulares sere ver(mas encurta-los no processo), e deixa apenas ire -arcom uma fuga r.

r$
b

Se a palavra ainda terminar r, substituí-la por a b. Agora, cobrimos todas as conjugações padrão, bem como o verbo irregular ir.

^vI$
veI

Isso corrige o verbo irregular verque foi transformado vIno primeiro estágio.

^sI$
er

Isso corrige o verbo irregular serque foi transformado sIno primeiro estágio. Agora, modificamos todas as hastes possíveis corretamente. Tudo o que resta a fazer é anexar todos os finais possíveis e, em alguns casos, fixar o sotaque da primeira pessoa do plural.

$
a

Primeiro, anexamos um aao radical, porque isso sempre faz parte de todos os finais.

$
 $_s $_ $_mos $_is $_n

Isso faz uso do raramente visto, $_que insere toda a cadeia na substituição (independentemente do que foi correspondido). Isso é realmente muito útil ao duplicar strings, como são $`e $', que também são bastante subestimadas.

Antes deste estágio, temos a primeira pessoa do singular na string. Agora, anexamos as outras conjugações, combinando o final da string com $e construindo as outras formas, anexando os sufixos apropriados à primeira pessoa do singular.

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

Finalmente, fixamos o sotaque da primeira pessoa do plural, se aplicável. Isso só precisa ser feito para uma vogal, dois caracteres na frente do, a -amos menos que o caractere intermediário seja I. Então, combinamos esse caractere e usamos um estágio de transliteração para converter letras minúsculas em maiúsculas. Isso faz uso das novas classes de personagens le Lque eu adicionei apenas ontem. Eles se expandem para a-ze A-Zrespectivamente, para que o novo recurso salve 4 bytes aqui.

Python 3, 154 232 bytes

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)

Corrigidas as maiúsculas ausentes em verbos irregulares.

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 Láctea 1.6.2 , 281 bytes

'?{"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-}

Bem, isso levou algum tempo! Parece que eu preciso adicionar alguns builtins, hehe ...

Uso

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

Exemplos

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

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

Ruby, 151 149

Normalmente, escolherei uma nova linha em vez de um ponto e vírgula, sempre que possível, no interesse da legibilidade, mas como não há ponto e vírgula, esse é um argumento único.

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

Um recurso é o uso de espaços reservados 31@para as vogais acentuadas que dependem dos amosfinais. Assim, a haste correta é formada e, em seguida, o espaço reservado é substituído por um eiaou EIAconforme apropriado

Existem alguns usos de índices de matriz negativos aqui. Portanto, n[-2]refere-se ao penúltimo e último caractere da entrada e n[0..-3]refere-se à entrada com os 2 últimos caracteres removidos (o tronco infinitivo).

Ungolfed in program program

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]