Wprowadzenie

W tym wyzwaniu Twoim zadaniem jest prawidłowe wylistowanie przypadków dwóch rzeczowników fińskich. Rzecz w tym, że możesz użyć jednej z list jako przewodnika przy tworzeniu drugiej.

Rzeczowniki

Jako naszych danych używamy następujących dwóch tabel deklinacji. Wymieniają przypadki dwóch rzeczowników, po jednym przypadku w wierszu, w takiej samej kolejności, jak w powyższym artykule w Wikipedii, w formie liczby pojedynczej: w stosownych przypadkach liczba mnoga .

Tabela 1: Przypadki jaj („drzwi”)

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: Przypadki jalki („stopy”)

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

Zadanie

Twoim zadaniem jest napisanie dwóch programów fi g(prawdopodobnie o różnych nazwach), które pobierają jeden ciąg jako dane wejściowe, dają jeden ciąg jako dane wyjściowe i mają następującą właściwość. Jeśli fjako dane wejściowe podano tabelę 1, dane wyjściowe są podane w tabeli 2, a jeśli podano tabelę 2, dane gwyjściowe są przedstawione w tabeli 1. Wszystkie pozostałe dane wejściowe powodują niezdefiniowane zachowanie. Tabele muszą pojawiać się dokładnie tak jak powyżej, zarówno na wejściu, jak i wyjściu. Opcjonalnie możesz założyć, że istnieje końcowy znak nowej linii, ale wtedy należy go użyć w obu tabelach, zarówno na wejściu, jak i na wyjściu. Nie ma poprzedniej nowej linii.

Zasady i bonusy

Można pisać fi galbo jako funkcji lub pełnych programów, ale muszą być tego samego typu, a ponadto muszą być całkowicie oddzielne (jeśli napisać funkcję pomocniczą dla f, należy ponownie zapisać go w gjeśli chcesz go używać tam) . Wygrywa najmniejsza łączna liczba bajtów, a standardowe luki są niedozwolone.

Istnieje premia w wysokości -25% za nieużywanie wyrażeń regularnych.

Kilka wyjaśnień

Jest perfekcyjnie napisać funkcję / program f, który ignoruje swoje wejście i zawsze zwraca Tabela 2, a funkcja / Program g, który zawsze powraca Tabela 1. Wymagane jest tylko, że i ; zachowanie i na wszystkich innych danych wejściowych jest nieistotne.f(Table 1) == Table 2g(Table 2) == Table 1fg

„Całkowicie oddzielna” część oznacza, co następuje. Twoja odpowiedź zawiera dwa fragmenty kodu, jeden dla fi jeden dla g, najlepiej w różnych polach kodu. Jeśli wstawię kod do fpliku i uruchomię go, zadziała i tak samo g. Twój wynik jest sumą liczby bajtów dwóch fragmentów kodu. Każdy zduplikowany kod jest liczony dwukrotnie.

Perl, 105 + 54 = 159

Program f(wypróbuj mnie ):

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

Program g(wypróbuj mnie ):

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

Alternatywna wersja f, tylko 2 bajty dłuższa (ta metoda może być również zastosowana, gale byłaby za długa):

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

Technicznie nadal używa to wyrażenia regularnego (do odkodowania ciągu podstawiania, a następnie zastosowania go), więc nie mogę ubiegać się o bonus tutaj.

Perl, 131 + 74 = 205

Tabela 1 do tabeli 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

Rozszerzony:

$_=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 do tabeli 1

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

Rozszerzony:

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

(Dzięki @nutki za kilka wskazówek Perla)

Pomimo kary za wyrażenia regularne, i tak postanowiłem sobie z tym poradzić i nauczyć się Perla. Zakładam, że istnieją pewne sztuczki Perla, które mogą pozwolić mi na wymianę łańcuchów, ale nie mogłem znaleźć żadnej w moim szybkim wyszukiwaniu online.

Jest o wiele trudniej jechać z Ovi tabeli Jalka stole, który zgaduję dlatego, że Jalka tabela zawiera dodatkowe niuanse, aby słowa łatwiejsze do wymówienia.

Oto tabela zastępcza, nad którą pracowałem:

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

Gdy tabela 1 jest wejściem do funkcji f, zwraca tabelę 2. Jeśli dane wejściowe nie są tabelą 1, dane wyjściowe są niezdefiniowane (jakkolwiek prawdopodobne, ale nie jest gwarantowane, że zwróci tabelę 2). Na przykład wywołanie f(9**9**9**9)prawdopodobnie nie zwróci tabeli 2.

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

Ta sama logika jest używana z funkcją g:

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

Funkcje są niezależne.

Python - 462 - 25% = 346,5

Ten program wykonuje oczywiste, bezpośrednie podejście, z wyjątkiem kilku sztuczek golfowych. W przypadku niezdefiniowanego zachowania drukuje tabelę tak jak zdefiniowane zachowanie. Cóż za niesamowity „zbieg okoliczności”! :)

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

Teraz, jeśli weźmie się pod uwagę to oszustwo (tak, słusznie), mogę postępować zgodnie z duchem zasad dla kolejnych 20 znaków = 482 - 25% = 361,5 . Po prostu zamień dwa ostatnie wiersze na:

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

Spowodowałoby to, że niezdefiniowane zachowanie nie zwróciłoby właściwej tabeli, ale tabeli wejściowej.

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

Bezpośrednie podejście.

Edycja: poprawiony błąd i używana sztuczka zastępująca z @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

Uruchom z okna Natychmiastowe:

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

Zaczynam prosto. Funkcje w ogóle ignorują parametr wejściowy.
Używanie podziału / łączenia zamiast zamiany, aby uniknąć wyrażeń regularnych.

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

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