Introdução

Neste desafio, sua tarefa é listar corretamente os casos de dois substantivos finlandeses. O segredo é que você pode usar uma das listas como guia para produzir a outra.

Os Substantivos

Usamos as duas tabelas de declinação a seguir como dados. Eles listam os casos de dois substantivos, um caso por linha, na mesma ordem que no artigo da Wikipedia vinculado acima, na forma singular: plural, quando aplicável.

Tabela 1: Casos de óvulos ("porta")

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

Tabela 2: Casos de jalka ("pé")

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

A tarefa

Sua tarefa é escrever dois programas fe g(possivelmente com nomes diferentes) que recebem uma string como entrada, fornecem uma string como saída e têm a seguinte propriedade. Se a Tabela 1 é fornecida fcomo entrada, ela gera a Tabela 2, e se a Tabela 2 é fornecida g, ela gera a Tabela 1. Todas as outras entradas resultam em comportamento indefinido. As tabelas devem aparecer exatamente como acima, tanto na entrada quanto na saída. Opcionalmente, você pode assumir que há uma nova linha à direita, mas ela deve ser usada nas duas tabelas e nas entradas e saídas. Não há nova linha anterior.

Regras e Bônus

Você pode escrever fe gcomo funções ou programas completos, mas eles devem ser do mesmo tipo e devem ser completamente separados (se você escrever uma função auxiliar f, deverá reescrevê-la gse quiser usá-la) . A menor contagem total de bytes vence e as brechas padrão não são permitidas.

Há um bônus de -25% por não usar expressões regulares.

Alguns esclarecimentos

É perfeitamente correto escrever uma função / programa fque ignore sua entrada e sempre retorne a Tabela 2, e uma função / programa gque sempre retorne a Tabela 1. É necessário apenas que e ; o comportamento de e em todas as outras entradas é irrelevante.f(Table 1) == Table 2g(Table 2) == Table 1fg

A parte "completamente separada" significa o seguinte. Sua resposta fornece dois pedaços de código, um para fe outro para g, de preferência em caixas de código diferentes. Se eu colocar o código fem um arquivo e executá-lo, ele funcionará e o mesmo para g. Sua pontuação é a soma das contagens de bytes dos dois pedaços de código. Qualquer código duplicado é contado duas vezes.

Perl, 105 + 54 = 159

Programa f(tente me ):

#!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(tente me ):

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

Uma versão alternativa de f, apenas 2 bytes a mais (esse método também pode ser aplicado, gmas seria muito longo):

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

Tecnicamente, isso ainda usa um regexp (para decodificar a sequência de substituição e depois aplicá-la), portanto não posso reivindicar o bônus aqui.

Perl, 131 + 74 = 205

Tabela 1 a Tabela 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

Tabela 2 a Tabela 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

(Obrigado a @nutki por algumas dicas de Perl)

Apesar da penalidade nas regexes, decidi enfrentá-lo de qualquer maneira e aprender Perl enquanto estava nele. Estou assumindo que existem alguns truques do Perl que podem me permitir substituir trocas, mas não encontrei nenhum na minha pesquisa rápida online.

É muito mais difícil ir da tabela ovi para a tabela jalka , o que eu acho que é porque a tabela jalka tem nuances adicionais para facilitar a pronúncia das palavras.

Aqui está a tabela de substituição em que eu estava trabalhando:

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

Python 2, 371 - 25% = 278

Quando a tabela 1 é a entrada para a função f, ela retorna a tabela 2. Se a entrada não for a tabela 1, sua saída será indefinida (por mais provável que seja, mas não garantido, retornar a tabela 2). Por exemplo, a chamada f(9**9**9**9)provavelmente não retornará a tabela 2.

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

A mesma lógica é usada com a função g:

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

As funções são independentes.

Python - 462 - 25% = 346,5

Este programa faz a abordagem direta e óbvia, exceto por alguns truques de golfe de dados. Para o comportamento indefinido, imprime a tabela exatamente como o comportamento definido. Que incrível "coincidência"! :)

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

Agora, se alguém considerar essa trapaça (sim, certo), posso seguir o espírito das regras para mais 20 caracteres = 482 - 25% = 361,5 . Apenas substitua as duas últimas linhas por:

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

Isso faria o comportamento indefinido retornar não a tabela correta, mas a tabela de entrada.

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

A abordagem direta.

Edit: Bug corrigido e usado substituir truque 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

Execute a partir da janela Imediata:

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%)

Começando simples. As funções ignoram o parâmetro de entrada.
Usar divisão / junção em vez de substituição para evitar expressões regulares.

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

Teste no console 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
forno: ovien
forno: OVET
ovea: Ovia
ovessa: ovissa
ovesta: ovista
oveen: oviin
ovella: ovilla
ovelta: ovilta
ovelle: oville
ovena: ovina
oveksi: oviksi
ovin
ovetta: ovitta
ovina