Questa sfida si basa e contiene casi di test di un corso di programmazione che ho seguito all'università di Aalto. Il materiale viene utilizzato con il permesso.

Due anni e mezzo fa c'è stata una sfida in inglese . Tuttavia, nei mungerismi finlandesi sono molto più complicati.

Spoonerismi in finlandese

In finlandese sono le vocali aeiouyäöe le consonanti lo sono bcdfghjklmnpqrstvwxz. ( åfa tecnicamente parte del finlandese, ma non è considerato qui.)

I spatolismi di base prendono solo la prima vocale di ogni parola e tutte le consonanti che le precedono e scambiano le parti:

henri kontinen -> konri hentinen
tarja halonen -> harja talonen
frakki kontti -> kokki frantti
ovi kello -> kevi ollo

Vocali lunghe

Alcune parole contengono due della stessa vocale consecutiva. In questi casi, la coppia di vocali deve essere scambiata con la prima vocale dell'altra parola, vocali accorciate o allungate per mantenere la stessa lunghezza.

haamu kontti -> koomu hantti
kisko kaappi -> kasko kiippi

Nel caso di due vocali consecutive diverse ciò non si applica:

hauva kontti -> kouva hantti
puoskari kontti -> kooskari puntti

Tre o più lettere della stessa lettera consecutiva non appariranno nell'input.

Armonia vocale

Il finlandese ha questa cosa adorabile chiamata armonia vocale . Fondamentalmente, significa che le vocali posteriori aou e le vocali anteriori äöy non dovrebbero apparire nella stessa parola.

Quando lo scambio di vocali anteriori o posteriori in una parola, tutte le vocali dell'altro genere nel resto della parola dovrebbero essere modificati in base al nuovo inizio della parola ( a <-> ä, o <-> ö, u <-> y):

köyhä kontti -> kouha köntti
hauva läähättää -> läyvä haahattaa

ee isono neutrali e possono apparire con tutte le altre lettere; scambiarli in una parola non deve causare modifiche al resto della parola.

Casi speciali

L'armonia vocale non si applica ad alcune parole, incluse molte parole di prestito e parole composte. Non è necessario che questi casi vengano gestiti "correttamente".

Sfida

Dato due parole, emette le parole spatolate.

Le parole di input conterranno solo i caratteri a-ze äö. Puoi scegliere di usare maiuscole o minuscole, ma la tua scelta deve essere coerente tra parole e input / output.

L'I / O può essere eseguito in qualsiasi formato conveniente . (Le parole dovrebbero essere considerate stringhe o matrici di caratteri.)

Questo è code-golf , quindi vince la soluzione più breve in byte.

Casi test

henri kontinen -> konri hentinen
tarja halonen -> harja talonen
frakki kontti -> kokki frantti
ovi kello -> kevi ollo
haamu kontti -> koomu hantti
hauva kontti -> kouva hantti
puoskari kontti -> kooskari puntti
köyhä kontti -> kouha köntti
hauva läähättää -> läyvä haahattaa
frakki stressi -> strekki frassi
äyskäri kontti -> kouskari äntti
hattu sfääri -> sfätty haari
ovi silmä -> sivi olma
haamu prätkä -> präämy hatka
puoskari sfääri -> sfäöskäri puuri
puoskari äyskäri -> äöskäri puuskari
uimapuku hajoa -> haimapuku ujoa
ihme baletti -> bahme iletti
uhka lima -> lihka uma
osuma makkara -> masuma okkara
makkara fakta -> fakkara makta
lapsi laiva -> lapsi laiva
firma hajoa -> harma fijoa
dimensio bitti -> bimensio ditti
flamingo joustava -> jomingo flaustava
globaali latomo -> labaali glotomo
trilogia fakta -> falogia trikta
printti maksa -> mantti priksa
riisi bitti -> biisi ritti
sini riisi -> rini siisi
aarre nyrkki -> nyyrre arkki
laavu laki -> laavu laki
kliininen parveke -> paaninen klirveke
priimus kahvi -> kaamus prihvi
spriinen lasta -> laanen sprista
kliimaksi mammona -> maamaksi klimmona
hylky hupsu -> hulku hypsy
kehys fiksu -> fihys keksu
levy huhu -> huvu lehu
tiheys guru -> guheus tiru
nyrkki heiluri -> herkki nyilyri
latomo hajoa -> hatomo lajoa
prisma lehti -> lesma prihti
viina baletti -> baana viletti

JavaScript (ES6), 196 175 byte

Prende le parole come due stringhe nella sintassi del curry (a)(b). Restituisce una matrice di due matrici di caratteri.

a=>b=>[(e=/(.*?)([eiäaöoyu])(\2?)(.*)/,g=(a,[,c,v])=>[...c+v+(a[3]&&v)+a[4]].map(c=>(j=e.search(v),i=e.search(c))>9&j>9?e[i&~1|j&1]:c))(a=e.exec(a),b=e.exec(b),e+=e),g(b,a)]

Provalo online!

Come?

Ogni parola di input viene passata attraverso l'espressione regolare e , che ha 4 gruppi di acquisizione:

e = /(.*?)([eiäaöoyu])(\2?)(.*)/    1: leading consonants (or empty)
     [ 1 ][     2    ][ 3 ][ 4]     2: first vowel
                                    3: doubled first vowel (or empty)
                                    4: all remaining characters

La funzione helper g () prende tutti i gruppi di acquisizione della parola da aggiornare come [] e il primo e il secondo gruppo di acquisizione dell'altra parola come c e v .

Applichiamo lo spatolismo di base e prendiamo cura delle vocali lunghe con:

c + v + (a[3] && v) + a[4]

Per applicare l'armonia vocale, prima forziamo l'espressione regolare e in una stringa aggiungendola a se stessa, che fornisce:

e = "/(.*?)([eiäaöoyu])(\2?)(.*)//(.*?)([eiäaöoyu])(\2?)(.*)/"
     ^^^^^^^^^^^^^^^^
     0123456789ABCDEF (position as hexa)

Le vocali che devono essere armonizzate hanno una posizione maggiore di 9 nella stringa risultante. Inoltre, l'espressione era disposto in modo tale che una vocali anteriori Aoy si trovano in posizione pari, mentre vocali posteriori AOU sono situati in posizioni dispari, accanto alle loro controparti.

Da qui la seguente formula di traduzione che viene applicata a ciascun carattere c della parola di output:

(j = e.search(v), i = e.search(c)) > 9 & j > 9 ? e[i & ~1 | j & 1] : c

Python 3 , 235 231 225 221 217 215 byte

import re
S=F,B='äöy','aou'
def f(a,b,C=1):
 e,r,Q,W=re.findall(fr' ?(.*?([ei{B+F}]))(\2)?(\w*)'*2,a+' '+b)[0][2:6]
 for c in zip(*S*(W in B)+(B,F)*(W in F)):r=r.replace(*c)
 return[Q+W*len(e)+r]+(C and f(b,a,[]))

Provalo online!

Salvato

• -2 byte, grazie a Lynn
• -4 byte, grazie a Zacharý

Pyth, 84 byte

.b++hY*W@N2JhtY2XW}JeA@DJc2"aouäöy"eNGH_Bmth:d:"^([^A*)([A)(\\2)*(.+)"\A"aeiouyäö]"4

Provalo online. Suite di test.

Dimostrando che non è così difficile nelle lingue del golf. Un linguaggio basato su stack potrebbe fare ancora meglio.

Pyth utilizza ISO-8859-1 per impostazione predefinita, quindi äösono un byte ciascuno.

Spiegazione

• Q, contenente la coppia di parole di input, viene aggiunto implicitamente.
• m: mappa ogni parola dnell'input a:
  • :"^([^A*)([A)(\\2)*(.+)"\A"aeiouyäö]": sostituisci Acon aeiouyäö]nella stringa per ottenere il regex ^([^aeiouyäö]*)([aeiouyäö])(\2)*(.+).
  • :d: trova tutte le partite e restituisce i loro gruppi di cattura.
  • h: accetta la prima (e unica) partita.
  • t: elimina il primo gruppo contenente l'intera corrispondenza.
• _B: accoppiare con il retro per ottenere [[first, second], [second, first]].
• .b: mappa ogni coppia di parole N, Yin quella a:
  • hY: prende le consonanti iniziali della seconda parola.
  • @N2: prendi la prima vocale lunga della prima parola, oppure None.
  • htY: prendi la prima vocale della seconda parola.
  • J: salvalo in J.
  • *W... 2: se c'era una vocale lunga, duplica la vocale della seconda parola.
  • +: aggiungilo alle consonanti.
  • c2"aouäöy": diviso aouäöyin due per ottenere ["aou", "äöy"].
  • @DJ: ordina la coppia per intersezione con la prima vocale della seconda parola. Questo ottiene la metà con la prima vocale della seconda parola alla fine della coppia.
  • A: salva la coppia in G, H.
  • e: prendere la seconda metà.
  • }J: vedi se la prima vocale della seconda parola è nella seconda metà.
  • XW... eNGH: se fosse, la mappa Gper Hil suffisso della prima parola, altrimenti mantenere il suffisso così com'è.
  • +: aggiungi il suffisso.