Ký tự kana Nhật Bản tương ứng với một âm thanh duy nhất trong ngôn ngữ Nhật Bản. Ngoại trừ ( n ), mọi kana khác bao gồm một phần phụ âm và một phần nguyên âm. Có một thứ tự tự nhiên đối với kana Nhật Bản, một loại "thứ tự chữ cái", thường được sắp xếp theo bảng 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

Thứ tự này được gọi là gojuuon , hoặc "năm mươi âm thanh", mặc dù một số năm mươi ô trong bảng thực tế là trống rỗng.

Các thách thức

Đầu vào sẽ là bất kỳ kana được liệt kê ở trên, ngoại trừ wo . Chương trình hoặc chức năng của bạn sẽ xuất kana tiếp theo theo thứ tự đọc từ trái sang phải, từ trên xuống dưới, ví dụ:

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

Ngoại trừ một dòng mới theo dõi duy nhất tùy chọn, sẽ không có khoảng trắng hàng đầu hoặc dấu ở đầu ra.

Đây là môn đánh gôn , vì vậy mục tiêu là giảm thiểu kích thước chương trình, tính bằng byte.

Ghi chú bổ sung

• Để giữ cho mọi thứ đơn giản, thử thách này sử dụng La Mã hóa Nihon-shiki . Hepburnation là phổ biến hơn, nhưng có một vài kink làm cho mọi thứ khó chịu hơn cho golf (ví dụ: si trở thành shi , hu trở thành fu ).

• Kana làm tồn tại cho các vị trí trống (xem SE Nhật Bản ), nhưng họ đã hoặc phi tiêu chuẩn hay bây giờ là lỗi thời.

Võng mạc , 54 53 byte

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

Hãy thử trực tuyến.

Giải trình

Wooo, thể hiện nhiều tính năng hơn nữa từ phiên bản 0.7.2 ngày hôm nay. :) ( Bản phát hành trước thử thách này khoảng 7 giờ.)

T`au`ie`y.

Đây là phiên âm thay thế acho ivàu với e, nhưng chỉ trong các trận đấu của y.. Mục đích của việc đó là điều trị yavà yuthích yivà ye, tương ứng, để bỏ qua các khoảng trống.

wa
we

Thay thế wabằng weđể bỏ qua khoảng cách đó là tốt.

T`\oeuia`ao

Đây là tính năng mới. Khi xoay các bộ ký tự, bộ "từ" và "đến" trong phiên âm thường gần như giống hệt nhau. Vì vậy, bây giờ chúng tôi đã có o(không có dấu gạch chéo ngược) để tham chiếu đến bộ khác, cho phép chúng tôi thoát khỏi một số trùng lặp. Chỉ \olà viết tắt của một nghĩa đen otrong trường hợp đó. Vì vậy, hai bộ mở rộng để:

oeuia
aoeuia

Không liên tục atrong bộ thứ hai được bỏ qua và các nguyên âm được thay thế theo chu kỳ như mong đợi.

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

Điều này cũng làm điều tương tự cho các phụ âm, nhưng sử dụng otrong tập đầu tiên (chỉ vì chúng ta có thể ...).hvà wcần thoát vì chúng là các lớp nhân vật. Các bộ mở rộng là:

kstnhmyrw
stnhmyrw

Các .a giới hạn hoạt động này đối với các âm tiết kết thúc a, tức là những âm tiết bao bọc đến dòng tiếp theo của bảng.

^a
ka

Cuối cùng, chúng ta thay thế một đĩa đơn avới ka, bởi vì trường hợp đó không thể được xử lý bởi các phiên trước đó.

Hồng ngọc, 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]}

Nhận xét trong chương trình thử nghiệm

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

Nhận xét không bao gồm trong điểm:

:                        # 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

Oy, điều này bắt đầu giống như câu trả lời Retina của @ Martin (nhưng dĩ nhiên lâu hơn).

Pyth, 42 40 38 byte

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

Cái này lấy sản phẩm bên ngoài giữa nguyên âm và phụ âm, và loại bỏ các phần tử ở các quỹ đạo của mỗi số trong $&./0. Sau đó, nó xuất ra phần tử sau đầu vào.

@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.

Hãy thử nó ở đây .

TXR Lisp, 135 127 124 91 byte

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

Chạy:

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

• Mở rộng cú đúp để tạo bảng đầy đủ trên một dòng
• quyến rũ để:
  • loại bỏ yi, ye, wi,wu vàwe
  • xóa mọi thứ lên đến và bao gồm cả mục nhập đầu vào (nhưng không phải mục tiếp theo)
  • xóa mọi thứ sau lần nhập tiếp theo

JavaScript, 145 162 131 118 byte

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

Thừa nhận nó, bạn không thể tưởng tượng ra một giải pháp lố bịch hơn để giải quyết vấn đề này;) ok, thực hiện điều này theo một cách thú vị hơn.

Bản giới thiệu:

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 byte

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

Hãy thử trực tuyến!

Haskell, 114 96 byte

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"]là một danh sách của tất cả các chuối, bao gồm cả "lỗ". Tôi chia danh sách thành phần trước kana đầu vào và từ kana đầu vào cho đến hết. Từ phần 2 tôi chọn phần tử thứ hai. Các trường hợp ngoại lệ xung quanh các "lỗ hổng" được bắt trước bởi các trường hợp riêng biệt.

Chỉnh sửa: @xnor nảy ra ý tưởng sử dụng spanlưu 18 byte.

Perl 6, 105 byte

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

Điều này là ngắn như tôi có thể có được nó trong lần đầu tiên của tôi, tôi có thể có một vết nứt khác sau đó nhưng tôi cảm thấy khá tốt về điều này.

JavaScript (ES6), 127 byte

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

Giải trình

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

Kiểm tra

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 byte

{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 byte

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

Mong đợi đầu vào kèm theo trong dấu ngoặc kép, 'he'ví dụ

Vợt 151 byte

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

Ung dung:

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

Kiểm tra:

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

Đầu ra:

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

Có một thông báo lỗi nếu 'wo được gửi.

C, 138 135 byte

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

Cây đũa phép