Introducción

En este desafío, su tarea es enumerar correctamente los casos de dos sustantivos finlandeses. El giro es que puede usar uno de los listados como guía para producir el otro.

Los sustantivos

Utilizamos las siguientes dos tablas de declinación como nuestros datos. Enumeran los casos de dos sustantivos, un caso por línea en el mismo orden que en el artículo de Wikipedia vinculado anteriormente, en la forma singular: plural cuando corresponda.

Tabla 1: Casos de ovi ("puerta")

ovi : ovet
oven : ovien
oven : ovet
ovea : ovia
ovessa : ovissa
ovesta : ovista
oveen : oviin
ovella : ovilla
ovelta : ovilta
ovelle : oville
ovena : ovina
oveksi : oviksi
ovin
ovetta : ovitta
ovine

Tabla 2: Casos de jalka ("pie")

jalka : jalat
jalan : jalkojen
jalan : jalat
jalkaa : jalkoja
jalassa : jaloissa
jalasta : jaloista
jalkaan : jalkoihin
jalalla : jaloilla
jalalta : jaloilta
jalalle : jaloille
jalkana : jalkoina
jalaksi : jaloiksi
jaloin
jalatta : jaloitta
jalkoine

La tarea

Su tarea es escribir dos programas fy g(posiblemente con diferentes nombres) que toman una cadena como entrada, dan una cadena como salida y tienen la siguiente propiedad. Si la Tabla 1 se proporciona fcomo entrada, genera la Tabla 2, y si se proporciona la Tabla 2 g, genera la Tabla 1. Todas las demás entradas dan como resultado un comportamiento indefinido. Las tablas deben aparecer exactamente como se indica arriba tanto en la entrada como en la salida. Opcionalmente, puede suponer que hay una nueva línea final, pero luego debe usarse en ambas tablas, y tanto en la entrada como en la salida. No hay una nueva línea precedente.

Reglas y bonos

Puede escribir fy gcomo funciones o programas completos, pero deben ser del mismo tipo y deben estar completamente separados (si escribe una función auxiliar f, debe volver a escribirla gsi desea usarla allí) . El conteo total de bytes más bajo gana, y las lagunas estándar no se permiten.

Hay una bonificación de -25% por no usar expresiones regulares.

Algunas aclaraciones

Está perfectamente bien escribir una función / programa fque ignore su entrada y siempre devuelva la Tabla 2, y una función / programa gque siempre devuelva la Tabla 1. Solo se requiere eso y ; el comportamiento de y en todas las demás entradas es irrelevante.f(Table 1) == Table 2g(Table 2) == Table 1fg

La parte "completamente separada" significa lo siguiente. Su respuesta proporciona dos piezas de código, una para fy otra para g, preferiblemente en diferentes cuadros de código. Si pongo el código fen un archivo y lo ejecuto, funciona, y lo mismo para g. Su puntaje es la suma de los recuentos de bytes de las dos piezas de código. Cualquier código duplicado se cuenta dos veces.

Perl, 105 + 54 = 159

Programa f(trate de mí ):

#!perl -p
s/vi /vka /;s/ve/va/g;s/en/an/;s/vi/voi/;s/ov/1&34960>>$.?jalk:jal/eg;s/ii/ihi/;s/loia/lkoje/;s/oia/oja/

Programa g(trate de mí ):

#!perl -p
s/jalk?o?/ov/g;s/va /vi /;s/va/ve/g;s/an/en/;y/jh/i/d

Una versión alternativa de f, solo 2 bytes más (este método también se puede aplicar gpero sería demasiado largo):

#!perl -p0
ka1a1a1koj1a1a1ka1koj1a1o0a1o0kaa2koih1a1o0a1o0a1o0ka1ko0a1o0o0a1o0ko=~s!\D+!"s/ov".'.'x$'."/jal$&/"!gree

Técnicamente, esto todavía usa una expresión regular (para decodificar la cadena de sustitución y luego aplicarla), por lo que no puedo reclamar el bono aquí.

Perl, 131 + 74 = 205

Tabla 1 a la Tabla 2

$_=join"",<>;s/ee/kaa/;s/ii/koihi/;s/i(e|a)/koj$1/g;s/i(na|ne)/koi$1/g;s/v[ie](.?a| )/vka$1/g;s/vi/voi/g;s/ve/va/g;s/ov/jal/g;print

Expandido:

$_=join"",<>;
s/ee/kaa/;
s/ii/koihi/;
s/i(e|a)/koj$1/g;
s/i(na|ne)/koi$1/g;
s/v[ie](.?a| )/vka$1/g;
s/vi/voi/g;
s/ve/va/g;
s/ov/jal/g;
print

Tabla 2 a la Tabla 1

$_=join"",<>;s/aan/aen/;s/jal(ka\b|oi|ko[ij]h?)/ovi/g;s/jalk?a/ove/g;print

Expandido:

$_=join"",<>;
s/aan/aen/;
s/jal(ka\b|oi|ko[ij]h?)/ovi/g;
s/jalk?a/ove/g;
print

(Gracias a @nutki por algunos consejos de Perl)

A pesar de la penalización en expresiones regulares, decidí abordarlo de todos modos y aprender Perl mientras estaba en eso. Supongo que hay algunos trucos de Perl que podrían permitirme reemplazar las cadenas, pero no pude encontrar ninguno en mi búsqueda rápida en línea.

Es mucho más difícil pasar de la tabla ovi a la tabla jalka , lo que supongo es que la tabla jalka tiene matices adicionales para que las palabras sean más fáciles de pronunciar.

Aquí está la tabla de reemplazo con la que estaba trabajando:

i <-> ka
--------
ov i               jal ka

e <-> ka
--------
ov e a             jal ka a
ov e na            jal ka na

e <-> a
-------
ov e t             jal a t
ov e n             jal a n
ov e ssa           jal a ssa
ov e sta           jal a sta
ov e lla           jal a lla
ov e lta           jal a lta
ov e lle           jal a lle
ov e ksi           jal a ksi
ov e tta           jal a tta

i <-> oi
--------
ov i ssa           jal oi ssa
ov i sta           jal oi sta
ov i lla           jal oi lla
ov i lta           jal oi lta
ov i lle           jal oi lle
ov i ksi           jal oi ksi
ov i n             jal oi n
ov i tta           jal oi tta

i <-> koi
---------
ov i na            jal koi na
ov i ne            jal koi ne

i <-> koj
---------
ov i en            jal koj en
ov i a             jal koj a

i <-> koih
------------
ov i in            jal koih in

ee <-> kaa
----------
ov ee n            jal kaa n

Pitón 2, 371 - 25% = 278

Cuando la tabla 1 es la entrada para la función f, devuelve la tabla 2. Si la entrada no es la tabla 1, su salida no está definida (aunque es probable pero no está garantizado que devuelva la tabla 2). Por ejemplo, llamar f(9**9**9**9)probablemente no devolverá la tabla 2.

f=lambda a:'jalkaBatAanBkojenAanBatAkaaBkojaAassaBoissaAastaBoistaAkaanBkoihinAallaBoillaAaltaBoiltaAalleBoilleAkanaBkoinaAaksiBoiksiAoinAattaBoittaAkoine'.replace('A','\njal').replace('B',' : jal')

La misma lógica se usa con la función g:

g=lambda a:'oviBetAenBienAenBetAeaBiaAessaBissaAestaBistaAeenBiinAellaBillaAeltaBiltaAelleBilleAenaBinaAeksiBiksiAinAettaBittaAine'.replace('A','\nov').replace('B',' : ov')

Las funciones son independientes.

Python - 462 - 25% = 346.5

Este programa realiza el enfoque obvio y directo, excepto por algunos trucos de golf de datos. Para el comportamiento indefinido, imprime la tabla al igual que el comportamiento definido. ¡Qué sorprendente "coincidencia"! :)

x,y="""ovi:ovet
oven:ovien
oven:ovet
ovea:ovia
ovessa:ovissa
ovesta:ovista
oveen:oviin
ovella:ovilla
ovelta:ovilta
ovelle:oville
ovena:ovina
oveksi:oviksi
ovin
ovetta:ovitta
ovineXjalka:jalat
jalan:jalkojen
jalan:jalat
jalkaa:jalkoja
jalassa:jaloissa
jalasta:jaloista
jalkaan:jalkoihin
jalalla:jaloilla
jalalta:jaloilta
jalalle:jaloille
jalkana:jalkoina
jalaksi:jaloiksi
jaloin
jalatta:jaloitta
jalkoine""".replace(':',' : ').split('X')
f=lambda n:y
g=lambda n:x

Ahora, si uno considerara esta trampa (sí, claro), puedo seguir el espíritu de las reglas para 20 personajes más = 482 - 25% = 361.5 . Simplemente reemplace las dos últimas líneas con:

f=lambda n:[x,y][n==x]
g=lambda n:[y,x][n==y]

Esto haría que el comportamiento indefinido no devuelva la tabla correcta sino la tabla de entrada.

VBA 1204 (1605 - 25%) 1191 (1587 - 25%)

El enfoque directo.

Editar: error corregido y truco de reemplazo utilizado de @Maltysen

Function f(s)
    If Replace(s, " : ", ":") = "ovi:ovet" & vbLf & "oven:ovien" & vbLf & "oven:ovet" & vbLf & "ovea:ovia" & vbLf & "ovessa:ovissa" & vbLf & "ovesta:ovista" & vbLf & "oveen:oviin" & vbLf & "ovella:ovilla" & vbLf & "ovelta:ovilta" & vbLf & "ovelle:oville" & vbLf & "ovena:ovina" & vbLf & "oveksi:oviksi" & vbLf & "ovin" & vbLf & "ovetta:ovitta" & vbLf & "ovine" Then f = Replace("jalka:jalat" & vbLf & "jalan:jalkojen" & vbLf & "jalan:jalat" & vbLf & "jalkaa:jalkoja" & vbLf & "jalassa:jaloissa" & vbLf & "jalasta:jaloista" & vbLf & "jalkaan:jalkoihin" & vbLf & "jalalla:jaloilla" & vbLf & "jalalta:jaloilta" & vbLf & "jalalle:jaloille" & vbLf & "jalkana:jalkoina" & vbLf & "jalaksi:jaloiksi" & vbLf & "jaloin" & vbLf & "jalatta:jaloitta" & vbLf & "jalkoine", ":", " : ")
End Function

Function g(s)
    If Replace(s, " : ", ":") = "jalka:jalat" & vbLf & "jalan:jalkojen" & vbLf & "jalan:jalat" & vbLf & "jalkaa:jalkoja" & vbLf & "jalassa:jaloissa" & vbLf & "jalasta:jaloista" & vbLf & "jalkaan:jalkoihin" & vbLf & "jalalla:jaloilla" & vbLf & "jalalta:jaloilta" & vbLf & "jalalle:jaloille" & vbLf & "jalkana:jalkoina" & vbLf & "jalaksi:jaloiksi" & vbLf & "jaloin" & vbLf & "jalatta:jaloitta" & vbLf & "jalkoine" Then f = Replace("ovi:ovet" & vbLf & "oven:ovien" & vbLf & "oven:ovet" & vbLf & "ovea:ovia" & vbLf & "ovessa:ovissa" & vbLf & "ovesta:ovista" & vbLf & "oveen:oviin" & vbLf & "ovella:ovilla" & vbLf & "ovelta:ovilta" & vbLf & "ovelle:oville" & vbLf & "ovena:ovina" & vbLf & "oveksi:oviksi" & vbLf & "ovin" & vbLf & "ovetta:ovitta" & vbLf & "ovine", ":", " : ")
End Function

Ejecutar desde la ventana Inmediato:

msgbox f("ovi : ovet" & vbLf & "oven : ovien" & vbLf & "oven : ovet" & vbLf & "ovea : ovia" & vbLf & "ovessa : ovissa" & vbLf & "ovesta : ovista" & vbLf & "oveen : oviin" & vbLf & "ovella : ovilla" & vbLf & "ovelta : ovilta" & vbLf & "ovelle : oville" & vbLf & "ovena : ovina" & vbLf & "oveksi : oviksi" & vbLf & "ovin" & vbLf & "ovetta : ovitta" & vbLf & "ovine")

JavaScript (ES6) 271 (165 + 196-25%)

Comenzando simple. Las funciones ignoran el parámetro de entrada en absoluto.
Usar dividir / unir en lugar de reemplazar para evitar expresiones regulares.

g=_=>'ovi1et0n1ien0n1et0a1ia0ssa1issa0sta1ista0en1iin0lla1illa0lta1ilta0lle1ille0na1ina0ksi1iksi\novin0tta1itta\novine'
.split(0).join('\nove').split(1).join(' : ov')
f=_=>'jalka1at0an1kojen0an1at0kaa1koja0assa1oissa0asta1oista0kaan1koihin0alla1oilla0alta1oilta0alle1oille0kana1koina0aksi1oiksi0oin0atta1oitta0koine'
.split(0).join('\njal').split(1).join(' : jal')

Prueba en la consola Firefox / FireBug

console.log(f('ovi : ovet\noven : ovien\noven : ovet\novea : ovia\novessa : ovissa\novesta : ovista\noveen : oviin\novella : ovilla\novelta : ovilta\novelle : oville\novena : ovina\noveksi : oviksi\novin\novetta : ovitta\novine'))

jalka: Jalat
Jalan: jalkojen
Jalan: Jalat
jalkaa: jalkoja
jalassa: jaloissa
jalasta: jaloista
jalkaan: jalkoihin
jalalla: jaloilla
jalalta: jaloilta
jalalle: jaloille
jalkana: jalkoina
jalaksi: jaloiksi
jaloin
jalatta: jaloitta
jalkoine

console.log(g("jalka : jalat\njalan : jalkojen\njalan : jalat\njalkaa : jalkoja\njalassa : jaloissa\njalasta : jaloista\njalkaan : jalkoihin\njalalla : jaloilla\njalalta : jaloilta\njalalle : jaloille\njalkana : jalkoina\njalaksi : jaloiksi\njaloin\njalatta : jaloitta\njalkoine"))

ovi: ovet
horno: ovien
horno: ovet
Ovea: Ovia
ovessa: ovissa
ovesta: ovista
oveen: oviin
ovella: Ovilla
ovelta: ovilta
ovelle: Oville
Oveña: ovina
oveksi: oviksi
ovin
Ovetta: ovitta
ovina