introduction

Dans ce défi, votre tâche consiste à répertorier correctement les cas de deux noms finlandais. La torsion est que vous pouvez utiliser l'une des listes comme guide pour produire l'autre.

Les noms

Nous utilisons les deux tableaux de déclinaison suivants comme données. Ils répertorient les cas de deux noms, un cas par ligne dans le même ordre que dans l'article Wikipedia lié ci-dessus, sous la forme singulière: pluriel le cas échéant.

Tableau 1: Cas d' ovi ("porte")

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

Tableau 2: Cas de jalka ("pied")

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 tâche

Votre tâche consiste à écrire deux programmes fet g(éventuellement avec des noms différents) qui prennent une chaîne en entrée, donnent une chaîne en sortie et ont la propriété suivante. Si le tableau 1 est donné fen entrée, il sort le tableau 2 et si le tableau 2 est donné g, il sort le tableau 1. Toutes les autres entrées entraînent un comportement indéfini. Les tableaux doivent apparaître exactement comme ci-dessus en entrée et en sortie. Vous pouvez éventuellement supposer qu'il existe un retour à la ligne de fin, mais il doit ensuite être utilisé dans les deux tables, ainsi qu'en entrée et en sortie. Il n'y a pas de nouvelle ligne précédente.

Règles et bonus

Vous pouvez écrire fet en gtant que fonctions ou programmes complets, mais ils doivent être du même type et ils doivent être complètement séparés (si vous écrivez une fonction d'assistance pour f, vous devez la réécrire gsi vous voulez l'utiliser là-bas) . Le nombre d'octets total le plus faible gagne et les failles standard sont interdites.

Il y a un bonus de -25% pour ne pas utiliser d'expressions régulières.

Quelques clarifications

Il est parfaitement correct d'écrire une fonction / un programme fqui ignore son entrée et renvoie toujours le tableau 2, et une fonction / un programme gqui renvoie toujours le tableau 1. Il suffit de cela et ; le comportement de et sur toutes les autres entrées n'est pas pertinent.f(Table 1) == Table 2g(Table 2) == Table 1fg

La partie "complètement séparée" signifie ce qui suit. Votre réponse fournit deux morceaux de code, un pour fet un pour g, de préférence dans des zones de code différentes. Si je mets le code pour fdans un fichier et l'exécute, cela fonctionne, et la même chose pour g. Votre score est la somme du nombre d'octets des deux morceaux de code. Tout code dupliqué est compté deux fois.

Perl, 105 + 54 = 159

Programme f(essayez- moi ):

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

Programme g(essayez- moi ):

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

Une version alternative de f, seulement 2 octets de plus (cette méthode peut également être appliquée gmais elle serait trop longue):

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

Techniquement, cela utilise toujours une expression rationnelle (pour décoder la chaîne de substitution puis pour les appliquer), je ne peux donc pas réclamer le bonus ici.

Perl, 131 + 74 = 205

Tableau 1 à tableau 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

Étendu:

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

Tableau 2 à tableau 1

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

Étendu:

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

(Merci à @nutki pour quelques conseils Perl)

Malgré la pénalité sur les regex, j'ai quand même décidé de m'y attaquer et d'apprendre Perl pendant que j'y étais. Je suppose qu'il y a des astuces Perl qui pourraient me permettre de chaîner des remplacements, mais je n'en ai trouvé aucun dans ma recherche rapide en ligne.

Il est beaucoup plus difficile de passer de la table ovi à la table jalka , ce qui, je suppose, est parce que la table jalka a des nuances supplémentaires pour rendre les mots plus faciles à prononcer.

Voici la table de remplacement sur laquelle je travaillais:

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

Lorsque le tableau 1 est l'entrée de la fonction f, il renvoie le tableau 2. Si l'entrée n'est pas le tableau 1, sa sortie n'est pas définie (mais probable mais non garantie de renvoyer le tableau 2). Par exemple, l'appel f(9**9**9**9)ne retournera probablement pas la table 2.

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

La même logique est utilisée avec la fonction g:

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

Les fonctions sont indépendantes.

Python - 462 - 25% = 346,5

Ce programme fait l'approche directe et évidente, sauf pour quelques trucs de golf de données. Pour le comportement non défini, il imprime le tableau exactement comme le comportement défini. Quelle étonnante "coïncidence"! :)

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

Maintenant, si l'on considère cette tricherie (ouais à droite), je peux suivre l'esprit des règles pour 20 caractères supplémentaires = 482 - 25% = 361,5 . Remplacez simplement les deux dernières lignes par:

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

Cela rendrait le comportement indéfini renvoyer non pas la table correcte mais la table d'entrée.

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

L'approche directe.

Edit: bug corrigé et astuce de remplacement utilisé 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

Exécutez à partir de la fenêtre Exécution:

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

Commencer simple. Les fonctions ignorent tout paramètre d'entrée.
Utiliser split / join au lieu de replace pour éviter les expressions régulières.

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

Test dans la 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:
jaloikal

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
four: ovien
four: ovet
ovea: ovia
ovessa: ovissa
ovesta: ovista
oveen: oviin
ovella: ovilla
ovelta: ovilta
ovelle: oville
ovena: ovina
oveksi: oviksi
ovin
ovetta: ovitta
ovine