Explicación

¡Hola! Para aquellos de ustedes que no toman español, se conjuga un verbo basado en la persona que realiza la acción. Aquí hay un cuadro:

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

En español, todos los verbos terminan con ar, ero ir. Aquí hay otra tabla ú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 un pronombre y un verbo, imprime el verbo conjugado usando el pronombre en tiempo presente. No te preocupes por el cambio de tallo y los verbos impares.

Ejemplos

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

Si su idioma no admite la impresión con acentos, puede omitirlos. De lo contrario, no debería tomar más caracteres para usar á en lugar de a en su código.

Puede encontrar más palabras para probar aquí: http://spanish.speak7.com/spanish_vocabulary_verbs.htm . Tenga en cuenta que el concursante debe ser contestar.

Desafío: cambios en el tallo

En español, algunos verbos tienen cambios en el tallo. Tomemos el verbo quererpor ejemplo. En todas las formas, excepto nosotros y vosotros , los primeros ecambios a ie. Entonces yo quiero, pero nosotros queremos. Si su programa puede dar cuenta de los cambios en la raíz, puede restar el doble de la longitud de cada palabra que apoya de su puntaje final. Por ejemplo, si admite el cambio i-> y solo , puede restar el doble de la longitud , o 12, de su puntaje.iequererquererquerer

Para algunos verbos que cambian las raíces, intente esto: https://conjuguemos.com/chart.php?language=spanish&id=2&etre=no&commands=no&all=no&source=public

Pequeñas bonificaciones

Solo por diversión, si explicas qué hace tu código en español, quita 30 de tu puntaje. No solo use Google Translate o podré decirle que hizo trampa.

(Como no soy hispanohablante, corrígeme si hay algún error)

Python, 172 168 743 caracteres - 1796 bonus = -1053

Actualizado para asumir el desafío de cambio de tallo.

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

Prueba en entradas que no cambian el tallo :

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

Ejemplos de entrada de cambio de tallo :

Hace ambos cambios e-> ie y cambios o-> ue, evitando adecuadamente los 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

Así es como se determinó la bonificación y se generó la cadena de datos, a partir de la cual puede deducir los verbos en los que funciona:

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`

Lo que da:

$ 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 - bonificación (extremadamente 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

Salida de muestra:

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

Explicación:

Este código utiliza un sitio web de conjugación gratuita existente ( http://www.conjugation.org/ ) que devuelve varias conjugaciones de una gran base de datos de verbos. Reduje ligeramente la URL mediante el uso de un acortador de URL en línea gratuito que permite pasar parámetros a través de la redirección ( http://smarturl.it/ ). Simplemente hago una solicitud HTTP basada en el verbo especificado, elimino los acentos de uy een la fuente, encuentro el pronombre en el HTML usando expresiones regulares y luego devuelvo la conjugación asociada.

Es imposible saber cuántos verbos tienen cambios de tallo sin sondear toda la base de datos contra un diccionario. Probablemente sea seguro asumir que la bonificación negativa de esta base de datos es mucho mayor que cualquier bonificación de las listas codificadas que se pasan (lo que aumenta la longitud del código).

Obviamente, podría haber manejado mejor los caracteres acentuados, pero habría requerido codificación / decodificación y manejo adicional dentro de las expresiones regulares.

Freepascal, 218 caracteres -30 = 189

Es una decisión difícil superar la respuesta de Python (original), especialmente con Pascal. Puedo intentar mejorar mañana, posiblemente con un concepto similar en un idioma diferente. No enviaré una respuesta que cambie el tronco, ya que veo esto como un desafío lingüístico más que de programación.

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.

Versión sin golf:

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.

Explicación (en español para el bono de -30 desde que lo solicitó)

el primer copyextrae la raíz del verbo, teniendo como parámetros el string , el índice para empezar (en este caso 1) y la cantidad de letras (en este caso length-2. ) el segundo extrae su desinencia.

6*(7-pos(p[1],' yt v n')se evalúa según la primera letra del pronombre. Si el pronombre es él / ella (o / s) o usted (es), posse evalúa a cero, así que el valor dentro de los paréntesis es 7. pos(v[length(v)-1],ybusca la penúltima letra del infinitivo en amosemosimosasí que avanza 4 por cada tipo de verbo , formando un ciclo de 12. El resto de yconsistencia en todas las desinencias. Se ha logrado intercalar las desinencias para "tu" y "yo". Sin embargo queda cierta cantidad de espacio en blanco que me gustaría eliminar. Así se define el índice para buscar la desinencia en y.

pos(p[length(p)],'u s')+1)determina el número de caracteres para imprimir. si el pronombre no termina en so usolo se imprime un personaje. De esta manera suprimimos la segunda letra de an en enen el caso de un pronombre de tercera persona singular: él, ella, usted.

Salida

perl, 243 caracteres

Esta vez centrándose en la búsqueda de hash. Estoy bastante sorprendido de no poder hacer esto más pequeño.

$_=<>;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

Y si la validación de entrada no es 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

Solo un montón de expresiones regulares esta vez. Puede obtener un código más corto reorganizando las cosas ligeramente para que el pronombre venga después del verbo, ya que solo nos importa realmente el final del 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 lo anterior es actualmente el ganador del código que ignora el bono.

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 (corrección de errores) 307 299 incluyendo nuevas líneas

No es genial en comparación con los otros por ahí. Podría ser mejorado.

Explota algunas convenientes coincidencias.

La corrección de errores no se basa en que ningún verbo en español tenga "ii" en ninguna parte, debido a la forma en que guarda los caracteres cuando se maneja con verbos -ir. Por favor corrígeme si eso está mal.

Asume una entrada válida: el primer argumento es el pronombre en minúscula, con los acentos necesarios; El segundo argumento es el infinitivo del verbo. No se implementaron cambios en el tronco. Emite el verbo conjugado, en minúsculas, sin 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. `` es una notación oscura para $( ), guardar un personaje.

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

obtener el final del verbo

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

obtener el primer carácter del final del verbo

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

obtener la raíz del verbo

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

Verbo stem + o. $ o es nuestra salida

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

tomar tallo + primera letra de finalización + mos

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

madre + primera letra de finalización + es (sin acentos)

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

En todos los escenarios, excepto los dos anteriores, los verbos -ir se comportan como verbos -er. cambie $ f a e si es i.

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

tallo + $ f + s

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

si la última letra del final es s. esto incluye a ellos, ellas, ustedes que tienen las mismas terminaciones. que conveniente.

o="$s$f"n;

tallo + $ f + n

else o=$s$f;fi

estamos asumiendo una entrada válida, por lo que las únicas otras posibilidades son Él, Ella y Usted, todas con las mismas terminaciones

fi
tr -s i <<< $0

salida de impresión, eliminando dobles i (que aparecen cuando usas vosotros con un 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

o si podemos arrojar precaución al viento y asumir una 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

salida de prueba:

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: demasiado largo

Ni siquiera me voy a molestar en contar. Si a alguien le gustaría jugar mejor al golf, por favor hágalo. Eventualmente implementaré el desafío de cambio de tallo.

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");
    }
}