अगला काना आउटपुट

Question

जापानी काना अक्षर जापानी भाषा में एकल ध्वनि के अनुरूप हैं। The ( n ) के अपवाद के साथ , हर दूसरे काना में एक व्यंजन भाग और एक स्वर भाग होता है। जापानी काना के लिए एक प्राकृतिक आदेश है, एक प्रकार का "वर्णमाला क्रम", जिसे आमतौर पर 10 से 5 तालिका में व्यवस्थित किया जाता है:

   |   a    i    u    e    o
-----------------------------
*  |   a    i    u    e    o
k  |  ka   ki   ku   ke   ko
s  |  sa   si   su   se   so
t  |  ta   ti   tu   te   to
n  |  na   ni   nu   ne   no
h  |  ha   hi   hu   he   ho
m  |  ma   mi   mu   me   mo
y  |  ya        yu        yo
r  |  ra   ri   ru   re   ro
w  |  wa                  wo

इस आदेश को गोजुओन या "पचास ध्वनियां" कहा जाता है , भले ही तालिका में पचास कोशिकाओं में से कुछ वास्तव में खाली हों।

चुनौती

इनपुट ऊपर सूचीबद्ध काना में से कोई भी होगा, जो कि wo के अपवाद के साथ है । आपके कार्यक्रम या फ़ंक्शन को अगले काना को बाएं से दाएं, ऊपर से नीचे पढ़ने के क्रम में आउटपुट करना चाहिए, जैसे:

Input       Output
------------------
a     ->    i
i     ->    u
o     ->    ka
ke    ->    ko
so    ->    ta
ni    ->    nu
ya    ->    yu
yu    ->    yo
wa    ->    wo
wo    ->    (undefined behaviour)

एक वैकल्पिक एकल अनुगामी न्यूलाइन के अपवाद के साथ, आउटपुट में कोई अग्रणी या अनुगामी व्हाट्सएप नहीं होना चाहिए।

यह कोड-गोल्फ है , इसलिए लक्ष्य बाइट्स में कार्यक्रम के आकार को कम करना है।

अतिरिक्त नोट्स

• चीजों को सरल रखने के लिए, यह चुनौती निहोन-शिकी रोमांस का उपयोग करती है । हेपबर्न romanisation ज्यादा आम है, लेकिन कुछ अड़चनों में जो गोल्फ के लिए चीजों को अधिक कष्टप्रद बनाने है (उदाहरण के लिए सी हो जाता है शि , हू हो जाता है फू )।

• काना कर खाली स्थानों के लिए अस्तित्व (देखें जापानी एसई ), लेकिन वे या तो गैर मानक थे या अब अप्रचलित हैं।

Comments

मुझे लगता है कि हेपबर्न अपवादों का उपयोग करना और छोरों को woबदलने के लिए बहुत अधिक मजेदार होगा । na

— Jan

Answer 1

रेटिना , 54 53 बाइट्स

T`au`ie`y.
wa
we
T`\oeuia`ao
T`ko`stn\hmyr\w`.a
^a
ka

इसे ऑनलाइन आज़माएं।

व्याख्या

वू, आज के 0.7.2 रिलीज से और भी अधिक सुविधाएँ दिखा रहा है। :) ( रिलीज ने इस चुनौती को लगभग 7 घंटे तक बढ़ा दिया है।)

T`au`ie`y.

यह एक लिप्यंतरण जो बदल देता है aके साथ iऔर uसाथ eहै, लेकिन केवल के मैचों में y.। इसका उद्देश्य गैप्स को छोड़ना है और क्रमशः इलाज yaऔर yuपसंद करना है।yiye

wa
we

बदलें waसाथ weही साथ उस खाई को छोड़ने के लिए।

T`\oeuia`ao

यहाँ नई सुविधा है जब वर्णों के घूर्णन सेट, एक लिप्यंतरण में "से" और "से" सेट आमतौर पर लगभग समान होते हैं। तो अब हम oदूसरे सेट को संदर्भित करने के लिए (बैकस्लैश के बिना) मिल गए हैं, जो हमें कुछ दोहराव से छुटकारा पाने की अनुमति देता है। \oबस एक शाब्दिक के लिए खड़ा है oउस मामले में। तो दो सेटों का विस्तार:

oeuia
aoeuia

aदूसरे सेट में बाहरी को नजरअंदाज कर दिया जाता है और स्वर को अपेक्षित रूप से बदल दिया जाता है।

T`ko`stn\hmyr\w`.a

यह व्यंजन के लिए एक ही काम करता है, लेकिन oपहले सेट में उपयोग कर रहा है (सिर्फ इसलिए कि हम कर सकते हैं ...)। hऔर wभागने की जरूरत है क्योंकि वे चरित्र वर्ग हैं। विस्तारित सेट निम्न हैं:

kstnhmyrw
stnhmyrw

.aसम्बन्धी सीमाओं अक्षरों को यह कार्रवाई में अंत a, यानी उन है कि तालिका के अगली पंक्ति में चादर।

^a
ka

अंत में, हम एक एकल के aसाथ प्रतिस्थापित करते हैं ka, क्योंकि उस मामले को पिछले लिप्यंतरण द्वारा नियंत्रित नहीं किया जा सकता है।

Comments

चुनौती पोस्ट किए जाने के बाद आपकी भाषा के एक संस्करण का उपयोग नहीं करता है, जिससे आपकी प्रविष्टि प्रतिस्पर्धा से अयोग्य हो जाती है ? (लगता है कि मैंने इस बारे में उस दूसरी जगह पर क्यों पूछा?)

— एलेक्स

@ इस चुनौती को पोस्ट करने से पहले मैंने उस संस्करण को जारी किया।

— मार्टिन एंडर

ठीक है। मैं क्षमाप्रार्थी हूं। आपके संपादन ने इसे अन्यथा प्रदर्शित किया। मैंने सिर्फ आपकी रिलीज़ की सूची सत्यापित की है (शायद ऐसा करना चाहिए था कि चारों ओर आरोप लगाने से पहले)।

— एलेक्स

Answer 2

रूबी, 105

->n{a=['wo','wa']
'rymhntsk '.chars{|c|a+='*o *e *u *i *a'.tr(?*,c).split}
a[8..10]='yu'
a[a.index(n)-1]}

परीक्षण कार्यक्रम में टिप्पणी की

f=->n{a=['wo','wa']                     #initialize array to last line of table, begin to build table backwards                                
  'rymhntsk '.chars{|c|                 #for each consonant, 
    a+='*o *e *u *i *a'.tr(?*,c).split  #perform a sustitution to get that line of table in string form,  
  }                                     #then split into array at spaces and append to a
  a[8..10]='yu'                         #substitute 3 elements ye yu yi with 1 element yu
  a[a.index(n)-1]                       #return element before argument (array is backwards.)
}

puts f[gets.chop]

Comments

आप के साथ कुछ बाइट्स बचा सकते हैं a=%w{wo wa}।

— जॉर्डन

इसके अलावा: "rymhntsk ".chars{|c|"oeuia".chars{|d|a<<c+d}}हालांकि मुझे एक डराने वाला संदेह है, लेकिन इसे आगे बढ़ाया जा सकता है।

— जॉर्डन

Answer 3

GNU sed, 65

टिप्पणियाँ स्कोर में शामिल नहीं हैं:

:                        # Define unnamed label
y/aiueo/iueoa/           # Rotate vowels
/a/y/kstnhmyr/stnhmyrw/  # If at end of row, rotate consonants
s/^a/ka/                 # If at end of 1st row, prefix a "k"
/[yw][ie]\|wu/b          # If one of the invalid values, jump back to label and redo

ओह, यह @ मार्टिन की तरह लग रहा है रेटिना उत्तर (लेकिन अब, निश्चित रूप से) की देने लगा है ।

Answer 4

पायथ, ४२ ४० 38 बाइट्स

s.r]z.DrR6*" kstnhmyrw""aiueo"CM"$&./0

यह बाहरी उत्पाद को स्वर और व्यंजन के बीच ले जाता है, और प्रत्येक संख्या के ऑर्डी में तत्वों को निकालता है $&./0 । फिर यह इनपुट के बाद तत्व को आउटपुट करता है।

@J.DrR6*" kstnhmyrw""aiueo"CM"$&./0"hxJz    Implicit: z=input()
       *" kstnhmyrw""aiueo"                 Outer product: [' a',...,' o','ka',...]
    rR6                                     Strip each string—'a'~'o' now single letters
                           CM"$&./0"        Map ord onto the string: [36,38,46,47,48]
  .D                                        Remove elements at those indices.
 J                                          That's the list of kana; assign it to J
                                     xJz    Find the index (x) of z in J,
                                    h       add one,
@J                                          and access J at that index.

इसे यहाँ आज़माएँ ।

Comments

वाह, यह भाषा पागल है!

— बस एक शिक्षार्थी

Answer 5

TXR लिस्प, 135 127 124 91 बाइट्स

(ret[(memqual @1(diff(maprod(op trim-str`@1@2`)" kstnhmyrw""aiueo")'#"yi ye wi wu we"))1])

चलाएँ:

1> (ret[(memqual @1(diff(maprod(op trim-str`@1@2`)" kstnhmyrw""aiueo")'#"yi ye wi wu we"))1])
#<interpreted fun: lambda (#:arg-1-0208 . #:arg-rest-0207)>
2> [*1 "a"]
"i"
3> [*1 "o"]
"ka"
4> [*1 "ki"]
"ku"
5> [*1 "mu"]
"me"
6> [*1 "ya"]
"yu"
7> [*1 "yo"]
"ra"
8> [*1 "wa"]
"wo"

Answer 6

बैश + सेड, 83३

echo {,k,s,t,n,h,m,y,r,w}{a,i,u,e,o}|sed -E "s/[yw][ie]|wu//g;s/.*\b$1 +//;s/ .*//"

• एक पंक्ति पर पूर्ण तालिका बनाने के लिए ब्रेस विस्तार
• सेड:
  • निकालें yi, ye, wi, wuऔरwe
  • इनपुट प्रविष्टि (और अगली प्रविष्टि नहीं) सहित सब कुछ निकालें
  • अगली प्रविष्टि के बाद सब कुछ हटा दें

Answer 7

जावास्क्रिप्ट, 145 162 131 118 बाइट्स

x=>(d=" kstnhmyrw".replace(/./g,"$&a$&i$&u$&e$&o").replace(/ |yi|ye|wiwuwe/g,"").match(/[^aiueo]?./g))[d.indexOf(x)+1]

इसे स्वीकार करें, आप इस समस्या को हल करने के लिए एक अधिक हास्यास्पद समाधान की कल्पना नहीं कर सकते;) ठीक है, यह एक और अधिक दिलचस्प तरीके से किया।

डेमो:

function p(x) {
  return (d=" kstnhmyrw".replace(/./g,"$&a$&i$&u$&e$&o") //build the sequence of kana, regex rulez!
        .replace(/ |yi|ye|wiwuwe/g,"")                   //remove the spaces and excess kana
        .match(/[^aiueo]?./g))[d.indexOf(x)+1]           //split it into array using regex and get the index of input in it
}

alert(p(prompt()))

Comments

@ Sp3000 ओह, यह अफ़सोस की बात है, आपको तब उल्लेख करना चाहिए कि इन अतिरिक्त (अनुगामी / अग्रणी) रिक्त स्थान की अनुमति नहीं है।

— nicael

@nicael मैं कल्पना जिसका अर्थ में कुछ भी है कि वे नहीं दिख रहे हैं वर्तमान में अनुमति दी।

— मार्टिन एंडर

@ Sp3000 निश्चित रिक्ति।

— निकेल

Answer 8

Japt, 75 70 68 बाइट्स

X=" kstnhmyrw"£"aiueo"®+X w} r" |yi|ye|wiwuwe"P f"[^aiueo]?.")g1+XbU

इसे ऑनलाइन आज़माएं!

Comments

बहुत अच्छा! मैंने इसे और नीचे गिराने की कोशिश की, लेकिन मैं केवल 3 बाइट्स ही काट सका:X=" kstnhmyrw"£"aiueo"mZ{X+Z} } r" |yi|ye|wiwuwe"P f"[^aiueo]?.")g1+XbU

— ETHproductions

@ हाँ, और आपको भी } }:) में एक अतिरिक्त जगह मिल गई है

— nicael

ओह्ह ठीक है, मैं भूल गया कि स्वचालित रूप से जोड़ा गया था :)

— ETHproductions

@ देखो, हम इसे आपके जादू के शॉर्टकट से दो बाइट्स प्राप्त कर सकते हैं: D

— nicael

रुको, कि वास्तव में काम करता है? अच्छा लगा, आपने मुझे अपमानित किया है;)

— 18

Answer 9

हास्केल, 114 96 बाइट्स

f"ya"="yu"
f"yu"="yo"
f"wa"="wo"
f x=snd(span(/=x)[words[a,b]!!0|a<-" kstnhmyrw",b<-"aiueo"])!!1

[words[a,b]!!0|a<-" kstnhmyrw",b<-"aiueo"]"छेद" सहित सभी कंस की एक सूची है। मैं इनपुट काना से पहले और अंत तक इनपुट काना से पहले भाग में सूची को तोड़ता हूं। दूसरे भाग से मैं दूसरा तत्व चुनता हूं। अलग-अलग मामलों से पहले पकड़े गए "छेद" के आसपास के अपवाद।

संपादित करें: @xnor ने span18 बाइट्स का उपयोग करने के विचार के साथ आया ।

Comments

(snd$span(/=x)k)!!1लुकअप के लिए काम नहीं करना चाहेंगे ?

— xnor

@xnor: अब जब मैं इसे देख रहा हूं, तो यह स्पष्ट है। बहुत बहुत धन्यवाद!

— nimi

Answer 10

पर्ल 6, 105 बाइट्स

.[.first(@*ARGS[0],:k)+1].say with (" kstnhmyrw".comb X~ <a e i o u>).grep(* !~~/[y|w][i|e]|wu/)».trim

यह उतना ही छोटा है जितना कि मैं इसे अपने पहले दौर में प्राप्त कर सकता हूं, बाद में मुझे इसमें एक और दरार पड़ सकती है लेकिन मैं इस बारे में बहुत अच्छा महसूस करता हूं।

Answer 11

जावास्क्रिप्ट (ईएस 6), 127 बाइट्स

s=>s>"yt"?"yo":s=="ya"?"yu":s=="wa"?"wo":(m=[].concat(...["",..."kstnhmyrw"].map(c=>[..."aiueo"].map(v=>c+v))),m[m.indexOf(s)+1])

व्याख्या

s=>

  // Hardcode "yu", "ya" and "wa"
  s>"yt"?"yo":
  s=="ya"?"yu":
  s=="wa"?"wo":

  // Generate table
  (m=[].concat(...                                   // flatten the array of arrays
    ["",                                             // first consonant is blank
    ..."kstnhmyrw"].map(c=>[..."aiueo"].map(v=>c+v)) // combine each consonant and vowel
  ))[m.indexOf(s)+1]                                 // return the next sound

परीक्षा

var solution = s=>s>"yt"?"yo":s=="ya"?"yu":s=="wa"?"wo":(m=[].concat(...["",..."kstnhmyrw"].map(c=>[..."aiueo"].map(v=>c+v))),m[m.indexOf(s)+1])

<input type="text" id="input" value="mo" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Answer 12

पर्ल 6, 96 बाइट्स

{my @a=(" kstnhmyrw".comb X~ <a i u e o>).grep({!/[y|w][e|i]|wu/})>>.trim;@a[[e-mail]($_,:k)]}

Answer 13

पायथन 2, 107 बाइट्स

L=[(x+y).lstrip()for x in' kstnhmyrw'for y in'aiueo'if x+y not in'yiyewiwuwe']
print L[L.index(input())+1]

'he'उदाहरण के लिए , उद्धरणों में संलग्न इनपुट की अपेक्षा करता है

Answer 14

रैकेट 151 बाइट्स

(second(member s '(a i u e o ka ki ku ke ko sa si su se so ta ti tu te to na
ni nu ne no ha hi hu he ho ma mi mu me mo ya yu yo ra ri ru re ro wa wo)))

Ungolfed:

(define (f s)
  (second
   (member s
           '(a i u e o ka ki ku ke ko sa si su se so ta ti tu te to na ni nu ne
               no ha hi hu he ho ma mi mu me mo ya yu yo ra ri ru re ro wa wo))))

परिक्षण:

(f 'a)
(f 'i)
(f 'o)
(f 'ke)
(f 'so)
(f 'ni)
(f 'ya)
(f 'yu)
(f 'wa)

आउटपुट:

'i
'u
'ka
'ko
'ta
'nu
'yu
'yo
'wo

'Wo भेजे जाने पर एक त्रुटि संदेश है।

Answer 15

सी, 138 135 बाइट्स

char*s="aiueokstnhmyrw";i,j;k(*v){j=strchr(s,*v>>8)-s;i=strchr(s,*v)-s;j=i<4?i++:j<4?j-~(2520%i&3):!++i;printf("%c%c",s[i],i<5?:s[j]);}

Wandbox