Karakter kana Jepang berhubungan dengan satu suara dalam bahasa Jepang. Dengan pengecualian ん ( n ), setiap kana lainnya terdiri dari bagian konsonan dan bagian vokal. Ada pemesanan alami untuk kana Jepang, semacam "urutan alfabet", yang biasanya disusun dalam tabel 10 dengan 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

Pemesanan ini disebut gojuuon , atau "lima puluh suara", meskipun beberapa dari lima puluh sel dalam tabel sebenarnya kosong.

Tantangan

Masukan akan berupa kana yang terdaftar di atas, dengan pengecualian wo . Program atau fungsi Anda harus menampilkan kana berikutnya dalam urutan bacaan dari kiri ke kanan, dari atas ke bawah, misalnya:

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

Dengan pengecualian dari single trailing newline opsional, seharusnya tidak ada spasi spasi tambahan di belakang.

Ini adalah kode-golf , jadi tujuannya adalah untuk meminimalkan ukuran program, dalam byte.

Catatan tambahan

• Agar hal-hal sederhana, tantangan ini menggunakan romanisasi Nihon-shiki . Romanisasi Hepburn lebih umum, tetapi memiliki beberapa kekusutan yang membuat hal-hal lebih mengganggu untuk golf (misalnya si menjadi shi , hu menjadi fu ).

• Kana memang ada untuk tempat-tempat kosong (lihat SE Jepang ), tetapi mereka entah non-standar atau sekarang usang.

Retina , 54 53 byte

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

Cobalah online.

Penjelasan

Wooo, memamerkan lebih banyak fitur dari rilis 0.7.2 hari ini. :) ( Rilis mendahului tantangan ini sekitar 7 jam.)

T`au`ie`y.

Ini adalah transliterasi yang menggantikan adengan idan udengan e, tetapi hanya dalam kecocokan dengan y.. Tujuannya adalah untuk memperlakukan yadan yumenyukai yidan ye, masing-masing, untuk melewati celah.

wa
we

Ganti wadengan weuntuk melewati celah itu juga.

T`\oeuia`ao

Ini adalah fitur baru. Saat memutar set karakter, set "dari" dan "ke" dalam transliterasi biasanya hampir sama. Jadi sekarang kita punya o(tanpa backslash) untuk merujuk ke set lain, yang memungkinkan kita untuk menyingkirkan beberapa duplikasi. Yang \obenar - benar singkatan dari literal odalam kasus itu. Jadi dua set berkembang menjadi:

oeuia
aoeuia

Yang asing apada set kedua diabaikan dan vokal diganti secara siklis seperti yang diharapkan.

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

Ini melakukan hal yang sama untuk konsonan, tetapi menggunakan odi set pertama (hanya karena kita bisa ...). hdan wperlu melarikan diri karena mereka adalah kelas karakter. Set diperluas adalah:

kstnhmyrw
stnhmyrw

The .aMembatasi operasi ini untuk suku kata yang berakhir pada a, yaitu orang-orang yang membungkus ke baris berikutnya dari tabel.

^a
ka

Akhirnya, kami mengganti satu adengan ka, karena kasus itu tidak dapat ditangani oleh transliterasi sebelumnya.

Ruby, 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]}

Berkomentar dalam program uji

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

Komentar tidak termasuk dalam skor:

:                        # 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, ini mulai sangat mirip dengan @ Martin jawaban Retina (tapi lebih lama, tentu saja).

Pyth, 42 40 38 byte

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

Ini mengambil produk luar antara vokal dan konsonan, dan menghilangkan elemen pada ords dari setiap angka dalam $&./0. Kemudian output elemen setelah input.

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

Coba di sini .

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

Menjalankan:

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

• Brace ekspansi untuk membuat tabel penuh pada satu baris
• sed untuk:
  • remove yi, ye, wi, wudanwe
  • hapus semuanya hingga dan termasuk entri input (tetapi bukan entri berikutnya)
  • hapus semuanya setelah entri berikutnya

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]

Akui saja, Anda tidak dapat membayangkan solusi yang lebih konyol untuk menyelesaikan masalah ini;) ok, lakukan ini dengan cara yang lebih menarik.

Demo:

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

Cobalah online!

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"]adalah daftar semua kanas, termasuk "lubang". Saya memecah daftar menjadi bagian sebelum input kana dan dari input kana hingga akhir. Dari bagian 2 saya memilih elemen kedua. Pengecualian di sekitar "lubang" sebelumnya ditangkap oleh kasus yang terpisah.

Sunting: @xnor datang dengan ide menggunakan spanyang disimpan 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

Ini sesingkat yang saya bisa pada pertama saya pergi, saya mungkin punya celah lain nanti tapi saya merasa cukup baik tentang ini.

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

Penjelasan

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

Uji

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]

Mengharapkan input yang dilampirkan dalam tanda kutip, 'he'misalnya

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

Tidak Disatukan:

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

Pengujian:

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

Keluaran:

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

Ada pesan kesalahan jika 'dikirim.

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

Wandbox