Elenca i casi di due nomi finlandesi


10

introduzione

In questa sfida, il tuo compito è elencare correttamente i casi di due nomi finlandesi. Il colpo di scena è che puoi utilizzare uno degli elenchi come guida per produrre l'altro.

I nomi

Usiamo le seguenti due tabelle di declinazione come nostri dati. Elencano i casi di due sostantivi, un caso per riga nello stesso ordine dell'articolo di Wikipedia collegato sopra, nella forma singolare: plurale ove applicabile.

Tabella 1: Casi di ovi ("porta")

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

Tabella 2: Casi di jalka ("piede")

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

L'obiettivo

Il tuo compito è scrivere due programmi fe g(possibilmente con nomi diversi) che accettano una stringa come input, forniscano una stringa come output e abbiano la seguente proprietà. Se la tabella 1 viene assegnata fcome input, genera la tabella 2 e se viene fornita la tabella 2 g, genera la tabella 1. Tutti gli altri input determinano un comportamento indefinito. Le tabelle devono apparire esattamente come sopra sia in input che in output. Si può facoltativamente supporre che esista una newline finale, ma deve essere utilizzata in entrambe le tabelle, sia in input che in output. Non esiste una nuova riga precedente.

Regole e bonus

Puoi scrivere fe gcome funzioni o programmi completi, ma devono essere dello stesso tipo e devono essere completamente separati (se scrivi una funzione di supporto per f, devi riscriverla gse vuoi usarla lì) . Il conteggio dei byte totali più basso vince e le scappatoie standard non sono ammesse.

C'è un bonus del -25% per non usare espressioni regolari.

Alcuni chiarimenti

È perfettamente corretto scrivere una funzione / programma fche ignori il suo input e restituisca sempre la Tabella 2, e una funzione / programma gche restituisca sempre la Tabella 1. È necessario solo che e ; il comportamento di e su tutti gli altri input è irrilevante.f(Table 1) == Table 2g(Table 2) == Table 1fg

La parte "completamente separata" indica quanto segue. La tua risposta fornisce due parti di codice, una per fe una per g, preferibilmente in diverse caselle di codice. Se inserisco il codice fin un file e lo eseguo, funziona e lo stesso per g. Il tuo punteggio è la somma dei conteggi dei byte dei due pezzi di codice. Qualsiasi codice duplicato viene conteggiato due volte.


if Table 1 is given `f` as inputCome si inserisce una funzione in una tabella? Non capisco questa parte

@Reticality "Se Tabella 1 è dato a f come input"
Zgarb

Risposte:


5

Perl, 105 + 54 = 159

Programma f(provate me ):

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

Programma g(provate me ):

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

Una versione alternativa di fsolo 2 byte in più (questo metodo può essere applicato anche a gma sarebbe troppo lungo):

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

Tecnicamente questo utilizza ancora un regexp (per decodificare la stringa di sostituzione e quindi applicarle), quindi non posso richiedere il bonus qui.


Wow, buon lavoro con s/jalk?o?/ov/g! Quello è potente.
Sp3000,

4

Perl, 131 + 74 = 205

Tabella 1 a tabella 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

Allargato:

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

Tabella 2 a tabella 1

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

Allargato:

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

(Grazie a @nutki per alcuni suggerimenti Perl)

Nonostante la penalità sulle regex, ho deciso di affrontarlo comunque e di imparare il Perl mentre ero lì. Suppongo che ci siano alcuni trucchi Perl che potrebbero permettermi di sostituire le catene, ma non sono riuscito a trovarne nessuno nella mia rapida ricerca online.

È molto più difficile passare dalla tabella ovi alla tabella jalka , il che immagino sia perché la tabella jalka ha sfumature aggiuntive per rendere le parole più facili da pronunciare.


Ecco la tabella di sostituzione a cui stavo lavorando:

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

Python 2, 371-25% = 278

Quando la tabella 1 è l'input per la funzione f, restituisce la tabella 2. Se l'input non è la tabella 1, l'output non è definito (comunque probabile ma non è garantito che restituisca la tabella 2). Ad esempio, la chiamata f(9**9**9**9)probabilmente non restituirà la tabella 2.

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

La stessa logica viene utilizzata con la funzione g:

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

Le funzioni sono indipendenti.


0

Python - 462 - 25% = 346.5

Questo programma utilizza l'approccio diretto e ovvio, ad eccezione di alcuni trucchi per il golf dei dati. Per il comportamento indefinito stampa la tabella proprio come il comportamento definito. Che sorprendente "coincidenza"! :)

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

Ora, se uno considerasse questo imbroglione (sì, giusto), posso seguire lo spirito delle regole per altri 20 personaggi = 482 - 25% = 361,5 . Sostituisci le ultime due righe con:

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

Ciò renderebbe il comportamento indefinito restituire non la tabella corretta ma la tabella di input.


Va benissimo restituire sempre lo stesso tavolo. Tuttavia, la sfida afferma che tutto il codice utilizzato per definire le funzioni deve essere separato (questo potrebbe essere stato un po 'ambiguo, cercherò di chiarirlo). In particolare, non è possibile definire xe yin un'espressione e utilizzare uno in fe l'altro in y.
Zgarb,

"in y" -> "in g"
Zgarb

0

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

L'approccio diretto.

Modifica: corretto bug e usato per sostituire il trucco di @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

Esegui dalla finestra immediata:

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

Non dovresti solo verificare se il primo carattere è 'o' o 'j'?
Claudiu,

@Claudiu In realtà, non è necessario controllare nulla; le funzioni che ignorano il loro input e restituiscono sempre la stessa tabella sono risposte valide. Lo chiarirò nella sfida.
Zgarb,

@Claudiu Ci ho pensato, ma cosa succede se qualcuno lo gestisce passando "o"?
phrebh,

@Zgarb Sembra che tu pensi che le mie funzioni stiano ignorando il loro input, cosa che non sono (tecnicamente). Non c'è traduzione di personaggi, però.
phrebh,

No, sto solo dicendo che potrebbero semplicemente ignorare i loro input ed essere comunque validi.
Zgarb,

0

JavaScript (ES6) 271 (165 + 196 -25%)

Iniziare semplice. Le funzioni ignorano del tutto il parametro di input.
Utilizzare dividere / unire anziché sostituire per evitare espressioni regolari.

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

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.