介绍

在这种挑战，你的任务就是要正确列出案件 2个芬兰名词。不同之处在于您可以使用其中一个清单作为指导来制作另一个清单。

名词

我们使用以下两个磁偏角表作为数据。他们以单数形式：复数形式列出了两个名词的情况，每行一个情况，与上面链接的Wikipedia文章中的顺序相同。

表1：ovi（“门”）的案例

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

表2：jalka（“脚”）的病例

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

任务

您的任务是编写两个程序，f并g（可能使用不同的名称）将一个字符串作为输入，将一个字符串作为输出，并具有以下属性。如果将表1给出f作为输入，则输出表2，如果将表2给出g，则输出表1。所有其他输入导致不确定的行为。这些表在输入和输出中必须完全如上。您可以选择假设有尾随换行符，但是必须在两个表以及输入和输出中都使用它。没有前面的换行符。

规则和奖金

您可以将f和编写g为函数或完整程序，但它们必须具有相同的类型，并且必须完全独立（如果您为编写了一个辅助函数f，则要在其中g使用它必须将其重新写入） 。最低的总字节数获胜，并且不允许出现标准漏洞。

不使用正则表达式有-25％的奖金。

一些澄清

它是完全没有编写一个函数/程序f，忽略它的输入，并始终返回表2中，和一个功能/程序g总是返回表1仅要求和; 的行为，并在所有其他投入是无关紧要的。f(Table 1) == Table 2g(Table 2) == Table 1fg

“完全分开”部分的含义如下。您的答案提供了两段代码，一个用于f，一个用于g，最好在不同的代码框中。如果我将的代码放入f文件中并运行它，则它的工作原理与相同g。您的分数是这两段代码的字节计数之和。任何重复的代码都会被计数两次。

Perl，105 + 54 = 159

程序f（尝试我）：

#!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/

程序g（尝试我）：

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

的替代版本f，仅长2个字节（也可以应用此方法，g但可能太长）：

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

从技术上讲，它仍然使用正则表达式（解码替换字符串然后应用它们），因此我不能在这里要求红利。

Perl，131 + 74 = 205

表1至表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

展开：

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

表2至表1

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

展开：

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

（感谢@nutki提供了一些Perl技巧）

尽管对正则表达式有惩罚，但我还是决定解决它，并在学习Perl的同时学习Perl。我假设有一些Perl技巧可以使我替换链，但是在网上快速搜索中找不到任何技巧。

从ovi表转到jalka表要困难得多，我猜这是因为jalka表还有其他细微差别，可以使单词更容易发音。

这是我正在处理的替换表：

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

当表1是函数f的输入时，它将返回表2。如果输入不是表1，则其输出是不确定的（但是有可能但不能保证返回表2）。例如，调用f(9**9**9**9)可能不会返回表2。

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

函数g使用相同的逻辑：

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

功能是独立的。

Python-462-25％= 346.5

该程序除了一些数据高尔夫技巧外，还采用了显而易见的直接方法。对于未定义的行为，它像定义的行为一样打印表。多么惊人的“巧合”！:)

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

现在，如果有人考虑作弊（是的），我可以遵循规则的精神，再添加20个字符= 482-25％= 361.5。只需将最后两行替换为：

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

这将使未定义的行为返回的不是正确的表，而是输入表。

VBA 1204（1605-25％） 1191（1587-25％）

直接方法。

编辑：更正了错误，并从@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

从立即窗口运行：

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％）

从简单开始。这些功能完全忽略输入参数。
使用split / join而不是replace以避免正则表达式。

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

在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
惹：jalkojen
惹：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烤箱：ovien
烤箱：
ovet ovea：ovia
ovessa：ovissa
ovesta：ovista
oveen：oviin
ovella：ovilla
ovelta：ovilta
ovelle：oville
tanka：ovina
oveksi：oviksi
ovin
ovetta：ovitta
ovine