Explicação

Hola! Para aqueles que não praticam espanhol, um verbo é conjugado com base na pessoa que executa a ação. Aqui está um gráfico:

English                   Spanish
I                         Yo
You                       Tú
He                        Él
She                       Ella
You (formal)              Usted
We all                    Nosotros
You all                   Vosotros
They (masculine, plural)  Ellos
They (feminine, plural)   Ellas
You (plural)              Ustedes

Em espanhol, todos os verbos terminam com ar, erou ir. Aqui está outro gráfico útil:

          Ar    Er    Ir
Yo        o     o     o
Tú        as    es    es
Él        a     e     e
Ella      a     e     e
Usted     a     e     e
Nosotros  amos emos imos
Vosotros  áis  éis  ís
Ellos     an   en   en
Ellas     an   en   en
Ustedes   an   en   en

Dado um pronome e um verbo, imprima o verbo conjugado usando o pronome no tempo presente. Não se preocupe com a troca de hastes e verbos ímpares.

Exemplos

Input        Output
Yo escribir  Escribo
Tu enseñar   Enseñas
Ella querer  Quere (It should be quiere but ignore stem changes)

Se o seu idioma não suportar impressão com acentos, você poderá omiti-los. Caso contrário, não será necessário mais caracteres para usar á em vez de a em seu código.

Você pode encontrar mais palavras com as quais testar aqui: http://spanish.speak7.com/spanish_vocabulary_verbs.htm . Observe que o competidor deve ser contestar.

Desafio: Mudanças no Tronco

Em espanhol, alguns verbos têm alterações no radical. Vamos pegar o verbo, quererpor exemplo. Em todas as formas, exceto nosotros e vosotros , a primeira emuda para ie. Então yo quiero, mas nosotros queremos. Se o seu programa puder explicar alterações no tronco, você poderá subtrair o dobro da duração de cada palavra da sua pontuação final. Por exemplo, se você apoia somente a alteração i-> , pode subtrair o dobro da duração ou 12 da sua pontuação.iequererquererquerer

Para alguns verbos que mudam o radical, tente o seguinte: https://conjuguemos.com/chart.php?language=spanish&id=2&etre=no&commands=no&all=no&source=public

Bônus pequenos

Apenas por diversão, se você explicar o que seu código faz em espanhol, tire 30 da sua pontuação. Não use apenas o Google Tradutor ou poderei dizer que você trapaceou.

(Como eu não sou um falante nativo de espanhol, corrija-me se houver algum erro)

Python, 172 168 743 caracteres - 1796 bônus = -1053

Atualizado para enfrentar o desafio de mudar de tronco.

p,v=raw_input().split()
y="aee";z=y+'n'
x=["ooo",y+'s',y,y,y,"aeimos","ae\x00is",z,z]["YoTuElEaUdNsVsEsUs".index(p[0]+p[-1])/2]
s=v[:-2]
X=v='eJw1UuHS5CAIe1aqrNsZhR6w/tj5Hv4Sv7uODRYDxEzlylKTplHS3xrS/3yIm4kntCTVSipkazaZ\n+AA32h3tY1ut+VL7NreXxsEEsgSheGynlJv/GNVvsPs9CIl2hoCSV+gYfuH7rdAyIQdr3+x92yCg\n2g7WEp4vMfTKgogyHabbL4z1l1p/1PLBCF4o9AjtmJBc6wpOTJykM+O0Ib2Y+FyCAuv5wcwCd+Ks\n4+XCdSwhqMIf/eJOFPMjV/rc0jw6IEvm8vjKdBuy/JryMPmEXwIiDInhtK01n1iDPrGu6/A5uy4/\nkBVd89R1OjvHCXbSnoDyaB23nhseElHosf45rzYC1zOevyDojQ548fjGCGg8M5aD8EAmB9GqgFHk\nBzRwDwJ6EcgK5aSDZ2/4TSAjKOMXd3gPh6sTq/+GApG0wkSYdzSBz/AXclUQ+g=='.decode('base64').decode('zip')
if s in X:
 j=X.index(s)<326
 s=(s.replace('oe'[j],'ui'[j]+'e'),s)[p[0]in'NV']
print s+x["aei".index(v[-2])]+x[3:]

Uso :

$ echo "Ellas querer" | python conj_golf2.py
quieren

Teste em entradas que não mudam de tronco :

Yo ensenar -> enseno
Yo escribir -> escribo
Tu ensenar -> ensenas
Tu escribir -> escribes
El ensenar -> ensena
El escribir -> escribe
Ella ensenar -> ensena
Ella escribir -> escribe
Usted ensenar -> ensena
Usted escribir -> escribe
Nosotros ensenar -> ensenamos
Nosotros escribir -> escribimos
Vosotros ensenar -> ensenais
Vosotros escribir -> escribis
Ellos ensenar -> ensenan
Ellos escribir -> escriben
Ellas ensenar -> ensenan
Ellas escribir -> escriben
Ustedes ensenar -> ensenan
Ustedes escribir -> escriben

Exemplos de entrada com alteração de haste :

Faz tanto e-> ou seja, mudanças e / ou mudanças, evitando adequadamente os casos nostros + vostros:

$ echo "Yo abstenir"|python conj_golf2.py
abstieno
$ echo "Nostros abstenir"|python conj_golf2.py
abstenimos
$ echo "Tu almorzar"|python conj_golf2.py
almuerzas
$ echo "Vostros almorzar"|python conj_golf2.py
almorzais

Aqui está como o bônus foi determinado e a sequência de dados gerada, a partir da qual você pode deduzir os verbos nos quais trabalha:

e="absten.acert.adher.adquer.advert.apret.asent.atraves.calent.cerr."+\
  "circunven.comenz.confer.confes.consent.conten.contraven.conven.convert."+\
  "difer.diger.discern.disent.freg.gobern.hed.hel.her.herv.infer.inger."+\
  "invern.invert.malher.manifest.ment.neg.nev.obten.ofend.pens.perd."+\
  "quer.recomend.reg.seg.sembr.sent.serr.sosegsosten.soterr.subarrend."+\
  "suger.tembl.tend.ten.tent.transfer.tropez.ven.vert"

u="absolv.acord.acost.almorz.along.amobl.apost.aprob.asol.avergonz."+\
  "coc.col.colg.cont.cost.degoll.demol.demostr.desaprob.descolg.descontr."+\
  "desos.destorc.devolv.disolv.dol.dorm.encontr.engros.envolv.forz.holg."+\
  "holl.llov.mol.mor.mostr.mov.ol.pobl.prob.record.reforz.remord.remov.renov."+\
  "repobl.resolv.resoll.reson.retorc.revolc.revolv."+\
  "rod.rog.sol.sold.sol.solt.son.torc.tost.tron.vol.volc.volv"

words = e.split(".") + u.split(".")
bonus = 0
for word in words:
    bonus += (len(word)+2)*2
print "Bonus: %d from %d stem-changing verbs" % (bonus, len(words))

s=(e+"|"+u).replace(".","")
zipped = s.encode('zip')
b64 = zipped.encode('base64')
print "The separator is at index %d" % s.index("|")
print "Uncompressed: %d chars, %d repr" % (len(s), len(`s`))
print "Compressed: %d chars, %d repr" % (len(zipped), len(`zipped`))
print "Comp+B64: %d chars, %d repr" % (len(b64), len(`b64`))

print "v="+`b64`

Que dá:

$ python conj_help.py
Bonus: 1796 from 127 stem-changing verbs
The separator is at index 326
Uncompressed: 645 chars, 647 repr
Compressed: 331 chars, 1015 repr
Comp+B64: 450 chars, 458 repr
v='eJw1UuHS5CAIe1aqrNsZhR6w/tj5Hv4Sv7uODRYDxEzlylKTplHS3xrS/3yIm4kntCTVSipkazaZ\n+AA32h3tY1ut+VL7NreXxsEEsgSheGynlJv/GNVvsPs9CIl2hoCSV+gYfuH7rdAyIQdr3+x92yCg\n2g7WEp4vMfTKgogyHabbL4z1l1p/1PLBCF4o9AjtmJBc6wpOTJykM+O0Ib2Y+FyCAuv5wcwCd+Ks\n4+XCdSwhqMIf/eJOFPMjV/rc0jw6IEvm8vjKdBuy/JryMPmEXwIiDInhtK01n1iDPrGu6/A5uy4/\nkBVd89R1OjvHCXbSnoDyaB23nhseElHosf45rzYC1zOevyDojQ548fjGCGg8M5aD8EAmB9GqgFHk\nBzRwDwJ6EcgK5aSDZ2/4TSAjKOMXd3gPh6sTq/+GApG0wkSYdzSBz/AXclUQ+g==\n'

Python, 240 bytes - bônus (extremamente grande)

from re import*;import urllib2 as u,sys;x=sys.argv
try:
 print search('>.*?'+sub('a','o',sub('ella','el',x[1]))+'.*? ([^<]*)',sub(u'\u00e9','e',sub(u'\u00fa','u',u.urlopen("http://smarturl.it/xz?word="+x[2]).read()))).group(1)
except:
 pass

Saída de amostra:

Input         | Output
yo escribir   | escribo
tu escribir   | escribes
tu ensenar    | ensenas
ella querer   | quiere
ellas querer  | quieren
nosotros vive | vi
tu acordar    | acuerdas

Explicação:

Este código usa um site de conjugação gratuito existente ( http://www.conjugation.org/ ) que retorna várias conjugações de um grande banco de dados de verbos. Reduzi um pouco a URL usando um encurtador de URL on-line gratuito que permite que os parâmetros sejam transmitidos pelo redirecionamento ( http://smarturl.it/ ). Simplesmente faço uma solicitação HTTP com base no verbo especificado, retiro os acentos do ue ena fonte, localizo o pronome no HTML usando expressões regulares e retorno a conjugação associada.

É impossível dizer quantos verbos têm alterações no radical sem consultar o banco de dados inteiro em um dicionário. Provavelmente, é seguro assumir que o bônus negativo desse banco de dados é muito maior do que qualquer bônus das listas codificadas passadas (que aumentam o comprimento do código).

Obviamente, eu poderia ter lidado melhor com os caracteres acentuados, mas isso exigiria codificação / decodificação e manipulação extra nas expressões regulares.

Freepascal, 218 caracteres -30 = 189

É uma decisão difícil de vencer a resposta python (original), especialmente com Pascal. Eu posso tentar melhorar amanhã, possivelmente com um conceito semelhante em um idioma diferente. Não enviarei uma resposta de mudança de radical, pois vejo isso como um desafio linguístico e não de programação.

var y,p,v:string;BEGIN y:='amosemosimosais eis is  as  eso eso   o   an  en  en';readln(p);readln(v);writeln(copy(v,1,length(v)-2),copy(y,6*(7-pos(p[1],' yt v n'))+pos(v[length(v)-1],y),pos(p[length(p)],'u s')+1));END.

Versão não destruída:

var y,p,v:string;
BEGIN 
  y:='amosemosimosais eis is  as  eso eso   o   an  en  en';
  readln(p);readln(v);
  writeln(copy(v,1,length(v)-2),
  copy(y,6*(7-pos(p[1],' yt v n'))+pos(v[length(v)-1],y),pos(p[length(p)],'u s')+1));
END.

Explicação (em espanhol para o bônus -30 desde que você pediu)

o primer copyextra da raíz do verbo, definindo como parâmetros a string , o índice para empezar (no caso 1) e a letra das letras (no caso comprimento-2. ) O segundo extra na descrição.

6*(7-pos(p[1],' yt v n')avalie a segunda letra do pronome. Se pronome es él / ella (s / s) usado (s), posavalie um cero, como o valor dentro da parêntesis es 7. pos(v[length(v)-1],ypesquise a última letra do infinitivo en amosemosimosavanza 4 por cada tipo de verbo , formando um ciclo de 12. O yrestante consiste em todas as desinencias. Se o logradouro intercalar separa as descrições para "você" e "você". Se houver embargo, haverá uma cantoria de espaço em branco que me deve eliminar. Como definir o índice para buscar a desinência em y.

pos(p[length(p)],'u s')+1)determinar o número de caracteres para imprimir. Si el pronombre não Terminais en so usolo se Imprime un carácter. Esta regra suprime a segunda letra do an en encaso de uma pessoa singular singular: él, ella, usted.

Resultado

perl, 243 caracteres

Desta vez, com foco na pesquisa de hash. Estou bastante surpreso por não conseguir ficar menor.

$_=<>;s/^(ustede|ell[oa])s\b/x/;s/^(él|ella|usted)\b/w/;%t=(yo,[o,o,o],"tú",[es,as,es],w,[e,a,e],x,[en,an,en],nosotros,[imos,amos,emos],vosotros,[qw(ís áis éis)]);@t=keys%t;$"="|";s/^(@t)\s+(\S*)([aei])r$/$2.$t{$1}[ord($3)%3]/e||die;print

E se a validação de entrada não for importante, 186 caracteres:

$_=<>;s/^[ue].*s /x /;s/^[éeu].* /w /;%_=(y=>[o,o,o],t,[es,as,es],w,[e,a,e],x,[en,an,en],n,[imos,amos,emos],v,[qw(ís áis éis)]);s/^(.)\S*\s+(.*)([aei])r$/$2.$_{$1}[ord($3)%3]/e;print

perl, 155 caracteres

Apenas um monte de expressões regulares desta vez. Você pode obter um código mais curto, reorganizando as coisas um pouco, para que o pronome venha após o verbo, já que nós realmente nos importamos com o final do verbo:

$_=<>;s/(.+) (.*)(.)r/$2$3 $1/;s/. yo/o/||s/ tú/s/||s/ n.*/mos/||s/ v.*/is/||s/ .*s$/n/||s/ .*//;s/i(n?)$/e$1/;s/ais$/áis/;s/eis$/éis/;s/iis$/ís/;print

Parece que o acima é atualmente o vencedor do código que ignora o bônus.

ski@anito:~$ c='$_=<>;s/(.+) (.*)(.)r/$2$3 $1/;s/. yo/o/||s/ tú/s/||s/ n.*/mos/||s/ v.*/is/||s/ .*s$/n/||s/ .*$//;s/i(n?)$/e$1/;s/ais$/áis/;s/eis$/éis/;s/iis$/ís/;print'; for p in yo tú él ella usted ellos ellas ustedes vosotros nosotros ; do for v in mar mer mir ; do echo "$p $v" | perl -e "$c" ; done ; done ; echo -n "$c" | wc -c
mo
mo
mo
mas
mes
mis
ma
me
me
ma
me
me
ma
me
me
man
men
men
man
men
men
man
men
men
máis
méis
mís
mamos
memos
mimos
155

Bash, 301 309 (correção de bug) 307 299 incluindo novas linhas

Não é ótimo em comparação com os outros por aí. Poderia ser melhorado.

Explora algumas coincidências convenientes.

A correção de bug não se baseia em nenhum verbo espanhol que tenha "ii" em nenhum lugar, devido à maneira como salva caracteres ao manipular vosotros com verbos -ir. Por favor, corrija-me se estiver errado.

Pressupõe entrada válida: o primeiro argumento é o pronome minúsculo, com os acentos necessários; o segundo argumento é o infinitivo do verbo. Nenhuma mudança de haste implementada. Produz o verbo conjugado, em minúsculas, sem acentos.

e=`tail -c3<<<$2`
f=`echo ${e:0:-1}`
s=`echo ${2:0:-2}`
if [ $1 = yo ];then o="$s"o;elif [ $1 = nosotros ];then o="$s$f"mos;elif [ $1 = vosotros ];then o="$s$f"is;else
if [ $f = i ];then f=e;fi
if [ $1 = tú ];then
o="$s$f"s;elif [ `tail -c2<<<$1` = s ];then
o="$s$f"n;else o=$s$f;fi
fi
tr -s i<<<$o

Explicado. `` é uma notação obscura para $( ), economizando um caractere.

e=`tail -c3<<<$2`

obter o verbo terminar

f=`echo ${e:0:-1}`

obter o primeiro caractere do verbo terminar

s=`echo ${2:0:-2}`

obter o verbo stem

if [ $1 = yo ]; then
o="$s"o;

Haste de verbos + o. $ o é a nossa produção

elif [ $1 = nosotros ]; then
o="$s$f"mos;

pegue o radical + primeira letra do final + mos

elif [ $1 = vosotros ]; then
o="$s$f"is;

stem + primeira letra do final + é (sem acentos)

else
if [ $f = i ];then f=e;fi

em todos os cenários, exceto nos dois acima, os verbos -ir se comportam como verbos -er. mude $ f para e se for i.

if [ $1 = tú ]; then
o="$s$f"s;

caule + $ f + s

elif [ `tail -c2<<<$1` = s ]; then 

se a última letra do final é s. isso inclui ellos, ellas, ustedes que têm todos os mesmos finais. quão conveniente.

o="$s$f"n;

caule + $ f + n

else o=$s$f;fi

estamos assumindo entrada válida, então as únicas outras possibilidades são Él, Ella e Usted, todas com os mesmos finais

fi
tr -s i <<< $0

imprimir saída, removendo o dobro do i (que aparece quando você usa vosotros com um verbo ir)

perl, 298 caracteres

$_=<>;($p,$b,$x)=/^\s*(yo|tú|él|ellas?|ellos|usted|ustedes|[nv]osotros)\s+(\S*)([aei])r\s*$/;sub r{($z,$y)=@_;return if$p!~/^($z)/;if($p!~/ros$/){$x="e" if$x eq"i"}$x=""if$z eq yo;$x={qw(a áis e éis i ís)}->{$x}if$p=~/^v/;print"$b$x$y";exit}r yo,o;r t,"s";r"[eu].+s",n;r"[éeu]","";r n,mos;r v

ou se pudermos tomar cuidado com o vento e assumir uma entrada válida, 246 caracteres:

$_=<>;($p,$b,$x)=/^(\S+)\s+(\S*)([aei])r$/;sub r{($z,$y)=@_;return if$p!~/^($z)/;if($p!~/ros$/){$x="e" if$x eq"i"}$x=""if$z eq yo;$x={qw(a áis e éis i ís)}->{$x}if$p=~/^v/;print"$b$x$y";exit}r yo,o;r t,"s";r"[eu].+s",n;r"[éeu]","";r n,mos;r v

saída de teste:

ski@anito:~$ c='$_=<>;($p,$b,$x)=/^(\S+)\s+(\S*)([aei])r$/;sub r{($z,$y)=@_;return if$p!~/^($z)/;if($p!~/ros$/){$x="e" if$x eq"i"}$x=""if$z eq yo;$x={qw(a áis e éis i ís)}->{$x}if$p=~/^v/;print"$b$x$y";exit}r yo,o;r t,"s";r"[eu].+s",n;r"[éeu]","";r n,mos;r v'; for p in yo tú él ella usted ellos ellas ustedes vosotros nosotros ; do for v in mar mer mir ; do echo "$p $v" | perl -le "$c" ; done ; done ; echo -n "$c" | wc -c
mo
mo
mo
mas
mes
mes
ma
me
me
ma
me
me
ma
me
me
man
men
men
man
men
men
man
men
men
máis
méis
mís
mamos
memos
mimos
246

Java - muito longo

Eu nem vou me preocupar em contar. Se alguém quiser jogar melhor isso, faça-o. Acabarei por implementar o desafio de mudar de tronco.

public class Conjugator {

    public static void main(String[] args) {
        setup();
        String p = args[0].toLowerCase(), v = args[1]; 
        String e = v.substring(v.length() - 2);
        v = v.substring(0, v.length() - 2);
        String f = data.get(e).get(p);
        System.out.println(v + f);
    }

    static HashMap<String, HashMap<String, String>> data = new HashMap<String, HashMap<String, String>>();

    public static void add(String ending, String pronoun, String fin) {
        HashMap<String, String> hm = data.get(ending);
        if (hm == null) {
            hm = new HashMap<String, String>();
            hm.put(pronoun, fin);
            data.put(ending, hm);
            return;
        }
        hm = data.get(ending);
        hm.put(pronoun, fin);
    }

    public static void setup() {
        add("ar", "yo", "o");
        add("ar", "tu", "as");
        add("ar", "el/ella/usted", "a");
        add("ar", "nosotros", "amos");
        add("ar", "vosotros", "ais");
        add("ar", "ellos/ellas/ustedes", "an");

        add("er", "yo", "o");
        add("er", "tu", "es");
        add("er", "el/ella/usted", "e");
        add("er", "nosotros", "emos");
        add("er", "vosotros", "eis");
        add("er", "ellos/ellas/ustedes", "en");

        add("ir", "yo", "o");
        add("ir", "tu", "es");
        add("ir", "el/ella/usted", "e");
        add("ir", "nosotros", "imos");
        add("ir", "vosotros", "is");
        add("ir", "ellos/ellas/ustedes", "en");
    }
}