Введение

В этом задании ваша задача - правильно составить список падежей двух финских существительных. Суть в том, что вы можете использовать один из списков в качестве руководства для создания другого.

Существительные

Мы используем следующие две таблицы склонений в качестве наших данных. Они перечисляют падежи двух существительных, по одному падежу на строку в том же порядке, что и в статье Википедии, связанной выше, в форме единственного числа: множественное число, где это применимо.

Таблица 1: Случаи яйцеклетки («дверь»)

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(возможно, с разными именами), которые принимают одну строку в качестве входных данных, дают одну строку в качестве выходных данных и имеют следующее свойство. Если в fкачестве входных данных приведена таблица 1 , она выводит таблицу 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

Expanded:

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

Expanded:

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

(Спасибо @nutki за некоторые советы по 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')

Функции независимы.

Питон - 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 вместо замены, чтобы избежать регулярных выражений.

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

Джалка: Джалат
Джалан: Джалкоджен
Джалан: Джалат
Джалкаа: Джалкоджа
Джаласса: Джалойса
Джаласта: Джалоиста
Джалкан: Джалкойин
Джалалла: Джалойла
Джалалта: Джалойлта
Джалалла: Джалло
Джалкьяло Джалкано Джалкьяло: Джалло Джалкьяло: Джалло
Джалкьяло:
Джалло
Джалкьяло: Джалло
Джалкьяло

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

Ови: ovet
печь: ovien
печь: ovet
ovea: Овия
ovessa: ovissa
ovesta: ovista
oveen: oviin
ovella: ovilla
ovelta: ovilta
ovelle: oville
ovena: ovina
oveksi: oviksi
Овин
ovetta: ovitta
овечий