일본어 가나 문자는 일본어의 단일 사운드에 해당합니다. ん ( n )을 제외 하고 다른 모든 가나는 자음 부분과 모음 부분으로 구성됩니다. 일본어 가나에는 일종의 "알파벳 순서"라는 자연스러운 순서가 있으며 일반적으로 10 x 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

이 순서는 표의 50 개 셀 중 일부가 실제로 비어 있더라도 gojuuon 또는 "50 개의 사운드"라고합니다.

도전

입력은 위에 나열된 가나 중 하나이며 wo 제외합니다 . 프로그램 또는 함수는 다음 가나를 왼쪽에서 오른쪽으로, 위에서 아래로 읽는 순서로 출력해야합니다. 예 :

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

선택적 단일 후행 줄 바꿈을 제외하고 출력에 선행 또는 후행 공백이 없어야합니다.

이것은 code-golf 이므로 목표는 프로그램 크기를 바이트 단위로 최소화하는 것입니다.

추가 사항

• 일을 단순하게 유지하기 위해,이 도전은 니혼 시키 로마자를 사용 합니다. 헵번 로마자 표기 가 더 흔하지 만 골프를 더 성가 시게하는 몇 가지 꼬임이 있습니다 (예 : si 는 shi , hu 는 fu 가됩니다) ).

• 가나 는 빈 자리에 존재 하지만 ( 일본 SE 참조 ) 표준이 아니거나 현재는 사용되지 않습니다.

망막 , 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같은 yi과 ye의 간극을 이동시키기 위해, 각각.

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바꿉니다.

루비, 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]

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

야, 이것은 @Martin 의 Retina 답변 과 비슷하게 보이기 시작합니다 (물론 더 길다).

Pyth, 42 40 38 바이트

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

이것은 모음과 자음 사이의 외부 곱을 취하고의 각 숫자의 ord에있는 요소를 제거합니다 $&./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.

여기에서 시도 하십시오 .

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"

배쉬 + sed, 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/ .*//"

• 한 줄에 전체 테이블을 작성하기위한 브레이스 확장
• sed :
  • 제거 yi, ye, wi, wu및we
  • 입력 항목을 포함하여 모든 항목을 제거합니다 (다음 항목은 제외)
  • 다음 항목 이후에 모든 것을 제거하십시오

자바 스크립트, 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()))

apt, 75 70 68 바이트

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

온라인으로 사용해보십시오!

하스켈, 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 바이트를 절약 한 아이디어를 사용했습니다 .

펄 6, 105 바이트

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

이것은 내가 처음 갈 때 얻을 수있는 한 짧습니다. 나중에 또 다른 균열이있을 수 있지만 이것에 대해 꽤 기분이 좋습니다.

자바 스크립트 (ES6), 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>

펄 6, 96 바이트

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

파이썬 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'예를 들어 따옴표로 묶은 입력을 예상합니다.

라켓 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)))

언 골프 드 :

(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가 전송되면 오류 메시지가 나타납니다.

C, 138135 바이트

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]);}

완드 박스