Вступ

У цьому виклику ваше завдання - правильно перелічити відмінки двох фінських іменників. Поворот полягає в тому, що ви можете використовувати один із списків як керівництво для створення іншого.

Іменники

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

Таблиця 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 : 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, які можуть дозволити мені замінити ланцюжок, але я не міг знайти жодного в своєму швидкому пошуку в Інтернеті.

Набагато складніше переходити від таблиці 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

Пітон 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%)

Почати просто. Функції взагалі ігнорують вхідний параметр.
Використовуйте розділення / приєднання замість заміни, щоб уникнути регулярних виразів.

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
jalan
: jalkojen
jalan: jalat
jalkaa: jalkoja
jalassa: jaloissa
jalasta: jaloista
jalkaan: jalkoihin
jalalla: jaloilla
jalalta: jaloilta
jalalle: jaloille
jalkana:
jalkoina
jalaksi: jaloiksi
jalointa jalointa

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
овечий