Einführung

Bei dieser Herausforderung besteht Ihre Aufgabe darin, die Fälle von zwei finnischen Substantiven korrekt aufzulisten. Der Clou ist, dass Sie eine der Auflistungen als Leitfaden verwenden können, um die andere zu erstellen.

Die Nomen

Wir verwenden die folgenden zwei Deklinationstabellen als unsere Daten. Sie listen die Fälle von zwei Substantiven, einen Fall pro Zeile, in derselben Reihenfolge wie im oben verlinkten Wikipedia-Artikel in der Form Singular: Plural auf , sofern zutreffend.

Tabelle 1: Fälle von Ovi ("Tür")

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

Tabelle 2: Fälle von Jalka ("Fuß")

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

Die Aufgabe

Ihre Aufgabe ist es, zwei Programme zu schreiben fund g(möglicherweise mit unterschiedlichen Namen) eine Zeichenfolge als Eingabe zu verwenden, eine Zeichenfolge als Ausgabe anzugeben und die folgende Eigenschaft zu haben. Wenn Tabelle 1 fals Eingabe angegeben wird, wird Tabelle 2 ausgegeben, und wenn Tabelle 2 angegeben wird g, wird Tabelle 1 ausgegeben . Alle anderen Eingaben führen zu undefiniertem Verhalten. Die Tabellen müssen sowohl in der Eingabe als auch in der Ausgabe genau wie oben angezeigt werden. Sie können optional davon ausgehen, dass es einen nachgestellten Zeilenumbruch gibt, der dann jedoch in beiden Tabellen sowie in der Eingabe und Ausgabe verwendet werden muss. Es gibt keinen vorhergehenden Zeilenumbruch.

Regeln und Boni

Sie können schreiben , fund gentweder als Funktionen oder vollständige Programme, aber sie müssen vom gleichen Typ sein, und sie müssen vollständig getrennt sein (wenn Sie eine Hilfsfunktion für schreiben f, müssen Sie neu zu schreiben es in , gwenn Sie wollen , dass es dort verwenden) . Die niedrigste Gesamtbytezahl gewinnt und Standardschlupflöcher sind nicht zulässig.

Es gibt einen Bonus von -25%, wenn keine regulären Ausdrücke verwendet werden.

Einige Erläuterungen

Es ist vollkommen in Ordnung, eine Funktion / ein Programm zu schreiben, das / fdas seine Eingabe ignoriert und immer Tabelle 2 zurückgibt, und eine Funktion / ein Programm g, die / das immer Tabelle 1 zurückgibt. Es ist nur erforderlich, dass und ; Das Verhalten von und bei allen anderen Eingaben ist irrelevant.f(Table 1) == Table 2g(Table 2) == Table 1fg

Der "vollständig getrennte" Teil bedeutet Folgendes. Ihre Antwort enthält zwei Codeteile, einen für fund einen für g, vorzugsweise in verschiedenen Codefeldern. Wenn ich den Code für fin eine Datei lege und ihn ausführe, funktioniert er und das Gleiche für g. Ihre Punktzahl ist die Summe der Byteanzahlen der beiden Codeteile. Jeder duplizierte Code wird zweimal gezählt.

Perl, 105 + 54 = 159

Programm f(probier mich aus ):

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

Programm g(probier mich aus ):

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

Eine alternative Version von f, nur 2 Bytes länger (diese Methode kann auch angewendet werden, gwäre aber zu lang):

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

Technisch gesehen wird hierfür immer noch ein regulärer Ausdruck verwendet (um die Ersetzungszeichenfolge zu dekodieren und dann anzuwenden), sodass ich den Bonus hier nicht beanspruchen kann.

Perl, 131 + 74 = 205

Tabelle 1 bis Tabelle 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

Erweitert:

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

Tabelle 2 bis Tabelle 1

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

Erweitert:

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

(Danke an @nutki für einige Perl-Tipps)

Trotz der Strafe für Regexes habe ich mich entschlossen, es trotzdem anzugehen und Perl zu lernen, während ich dabei war. Ich gehe davon aus, dass es einige Perl-Tricks gibt, mit denen ich Ketten ersetzen kann, aber ich konnte bei meiner Online-Schnellsuche keine finden.

Es ist viel schwieriger, vom Ovi- Tisch zum Jalka- Tisch zu wechseln , was meiner Meinung nach daran liegt, dass der Jalka- Tisch zusätzliche Nuancen aufweist, um die Aussprache von Wörtern zu erleichtern.

Hier ist der Ersatztisch, an dem ich gearbeitet habe:

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

Wenn Tabelle 1 die Eingabe für die Funktion f ist, gibt sie Tabelle 2 zurück. Wenn die Eingabe nicht Tabelle 1 ist, ist ihre Ausgabe undefiniert (jedoch wahrscheinlich, aber nicht garantiert, dass sie Tabelle 2 zurückgibt). Zum Beispiel wird ein Aufruf f(9**9**9**9)wahrscheinlich nicht Tabelle 2 zurückgeben.

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

Die gleiche Logik wird mit der Funktion g verwendet:

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

Die Funktionen sind unabhängig.

Python - 462 - 25% = 346,5

Dieses Programm macht den offensichtlichen, direkten Ansatz mit Ausnahme einiger Datengolf-Tricks. Für das undefinierte Verhalten wird die Tabelle genauso gedruckt wie das definierte Verhalten. Was für ein erstaunlicher "Zufall"! :) :)

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

Wenn man dieses Betrügen in Betracht ziehen würde (ja, richtig), kann ich dem Geist der Regeln für 20 weitere Zeichen folgen = 482 - 25% = 361,5 . Ersetzen Sie einfach die letzten beiden Zeilen durch:

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

Dies würde dazu führen, dass das undefinierte Verhalten nicht die richtige Tabelle, sondern die Eingabetabelle zurückgibt.

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

Der direkte Ansatz.

Bearbeiten: Fehler behoben und Trick zum Ersetzen von @Maltysen verwendet

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

Aus dem Sofortfenster ausführen:

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

Einfach anfangen. Die Funktionen ignorieren Eingabeparameter überhaupt.
Verwenden von split / join anstelle von replace, um reguläre Ausdrücke zu vermeiden.

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

Test in der Firefox / FireBug-Konsole

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
Ofen: ovien
Ofen: ovet
ovea: Ovia
ovessa: ovissa
ovesta: ovista
oveen: oviin
ovella: ovilla
ovelta: ovilta
Ovelle: Oville
Ovena: ovina
oveksi: oviksi
ovin
Ovetta: ovitta
Schafen