दो फिनिश संज्ञा के मामलों की सूची

Question

परिचय

इस चुनौती में, आपका कार्य दो फिनिश संज्ञा के मामलों को सही ढंग से सूचीबद्ध करना है । मोड़ यह है कि आप लिस्टिंग में से एक का उपयोग दूसरे के उत्पादन के लिए एक गाइड के रूप में कर सकते हैं।

संज्ञा

हम अपने डेटा के रूप में निम्नलिखित दो घोषणा तालिकाओं का उपयोग करते हैं। वे दो संज्ञा के मामलों को सूचीबद्ध करते हैं, प्रति पंक्ति एक मामला उसी क्रम में जैसा कि विकिपीडिया लेख में जुड़ा हुआ है, एकवचन में: बहुवचन जहां लागू हो।

तालिका 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। आपका स्कोर कोड के दो टुकड़ों की बाइट मायने रखता है। कोई भी डुप्लिकेट कोड दो बार गिना जाता है।

Comments

if Table 1 is given `f` as inputएक टेबल में एक इनपुट कैसे कार्य करता है? मैं इस भाग को नहीं समझता

@Reticality "यदि तालिका 1 को इनपुट के रूप में दिया गया है f "

— ज़र्ब

Answer 1

पर्ल, 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

तकनीकी रूप से यह अभी भी एक regexp (प्रतिस्थापन स्ट्रिंग को डिकोड करने और फिर उन्हें लागू करने के लिए) का उपयोग करता है, इसलिए मैं यहां बोनस का दावा नहीं कर सकता।

Comments

वाह, के साथ अच्छा काम s/jalk?o?/ov/g! वह शक्तिशाली है।

— Sp3000

Answer 2

पर्ल, 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

(कुछ पर्ल टिप्स के लिए @ कुटकी से साभार)

रेगेक्स पर जुर्माने के बावजूद, मैंने वैसे भी इससे निपटने और पर्ल को सीखने का फैसला किया, जबकि मैं इस पर था। मैं मान रहा हूँ कि कुछ पर्ल ट्रिक्स हैं जो मुझे चेन रिप्लेसमेंट की अनुमति दे सकते हैं, लेकिन मैं अपनी त्वरित खोज में कोई भी ऑनलाइन नहीं खोज सका।

ओवी टेबल से जलका टेबल तक जाना बहुत कठिन है , जिसका मैं अनुमान लगा रहा हूं क्योंकि जलका टेबल में शब्दों को उच्चारण में आसान बनाने के लिए अतिरिक्त बारीकियां हैं।

---

यहाँ प्रतिस्थापन तालिका मैं काम कर रहा था:

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

Answer 3

पायथन 2, 371 - 25% = 278

जब तालिका 1 फ़ंक्शन च का इनपुट है, तो यह तालिका 2 लौटाता है। यदि इनपुट 1 तालिका नहीं है, तो यह आउटपुट अपरिभाषित है (हालांकि संभावना है कि लेकिन तालिका 2 वापस करने की गारंटी नहीं है)। उदाहरण के लिए, कॉलिंग f(9**9**9**9)शायद टेबल 2 नहीं लौटाएगी।

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

फ़ंक्शन जी के साथ एक ही तर्क का उपयोग किया जाता है:

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

कार्य स्वतंत्र हैं।

Answer 4

पायथन - 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]

यह अपरिभाषित व्यवहार को सही तालिका नहीं बल्कि इनपुट तालिका लौटाएगा।

Comments

यह हमेशा एक ही तालिका को वापस करने के लिए पूरी तरह से ठीक है। हालांकि, चुनौती बताती है कि फ़ंक्शन को परिभाषित करने के लिए उपयोग किए जाने वाले सभी कोड अलग-अलग होने चाहिए (यह थोड़ा अस्पष्ट हो सकता है, मैं इसे स्पष्ट करने की कोशिश करूंगा)। विशेष रूप से, आप परिभाषित नहीं कर सकते हैं xऔर yएक अभिव्यक्ति में, और एक में fऔर दूसरे में उपयोग करें y।

— जर्ग्ब

"इन y-"> "में g"

— जर्ग्बेल

Answer 5

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

Comments

क्या आपको केवल यह देखना नहीं होगा कि पहला वर्ण 'o' या 'j' है?

— Claudiu

@ कोलियु वास्तव में, कुछ भी जांचने की आवश्यकता नहीं है; फ़ंक्शंस जो उनके इनपुट को अनदेखा करते हैं और हमेशा एक ही तालिका वापस करते हैं वे मान्य उत्तर हैं। मैं चुनौती में इसे स्पष्ट करूँगा।

— जर्गब

@ बालुदु मैं इसके बारे में सोचता था, लेकिन अगर कोई इसे "ओ" पास करके चला जाए तो क्या होगा?

— फरेब

@Zgarb ऐसा लगता है जैसे आपको लगता है कि मेरे कार्य उनके इनपुट को अनदेखा कर रहे हैं, जो वे (तकनीकी रूप से) नहीं हैं। हालांकि, पात्रों का कोई अनुवाद नहीं है।

— phrebh

नहीं, मैं सिर्फ इतना कह रहा हूं कि वे केवल अपने इनपुट्स को नजरअंदाज कर सकते हैं और अभी भी मान्य हैं।

— ज़गर्ब

Answer 6

जावास्क्रिप्ट (ईएस 6) 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')

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

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
जालान: jalkojen
जालान: 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"))

ओवी: ovet
ओवन: ओवेन
ओवन: ovet
ओविया: ओविया
ओवेसा: ओविसा
ओवेस्टा: ओविस्टा
ओवेन: ओविएन
ovella: ovilla
ovelta: ovilta
ovelle: oville
ena: ovina
oveksi: oviksi
ovin
ovetta: ovitta
ovine