日语假名字符对应于日语中的单个声音。除ん（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

即使表中的五十个单元格实际上是空的，这种排序也称为gojuuon或“五十种声音”。

挑战

输入将是上面列出的任何假名，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，因此目标是最小化程序大小（以字节为单位）。

附加条款

• 为了使事情简单，此挑战使用了Nishi-shiki罗马化。赫本的罗马化比较普遍，但是有一些扭结使高尔夫更加烦恼（例如si变成shi，hu变成fu）。

• 假名的确存在空白点（请参见日语SE），但它们不是标准的，或者已过时。

视网膜，54 53字节

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

在线尝试。

说明

Wooo，展示了当今0.7.2版本中的更多功能。：）（发行版比这项挑战早了约7个小时。）

T`au`ie`y.

这是一个音译它取代a与i和u用e，但只有在比赛y.。这样做的目的是分别对待ya和yu喜欢yi和ye，以便跳过差距。

wa
we

更换wa用we跳过这一差距为好。

T`\oeuia`ao

这是新功能。旋转字符集时，音译中的“ from”和“ to”集通常几乎相同。因此，现在我们o（没有反斜杠）可以引用其他集合，这使我们摆脱了一些重复。在这种情况下，\ojust代表文字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's Retina答案（当然更长）。

Pyth，42 40 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.

在这里尝试。

TXR Lisp中，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"

Bash + 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/ .*//"

• 进行括号扩展以在一行上创建完整表
• 达到：
  • 删除yi，ye，wi，wu和we
  • 删除直到输入条目（包括下一个条目）的所有内容（但不删除下一个条目）
  • 下次输入后删除所有内容

JavaScript中，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()))

杰普（Japt）75 70 68字节

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

在线尝试！

Haskell，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"]是所有kanas（包括“孔”）的列表。我将列表分成输入假名之前的部分以及从输入假名到末尾的部分。从第二部分中，选择第二个元素。围绕“漏洞”的例外是由单独的案例捕获的。

编辑：@xnor提出了使用span节省18个字节的想法。

Perl 6,105位元组

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

这是我第一次尝试时就可以得到的，我稍后可能会再遇到一些困难，但是我对此感觉很好。

JavaScript（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>

Perl 6，96位元组

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

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

魔盒