Los caracteres kana japoneses corresponden a un solo sonido en el idioma japonés. Con la excepción de ん ( n ), cada otra kana consiste en una parte consonante y una parte vocal. Hay una ordenación natural de la kana japonesa, una especie de "orden alfabético", que generalmente se organiza en una tabla de 10 por 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

Este orden se llama gojuuon , o "cincuenta sonidos", aunque algunas de las cincuenta celdas de la tabla están vacías.

El reto

La entrada será cualquiera de los kana enumerados anteriormente, con la excepción de wo . Su programa o función debe mostrar el siguiente kana en orden de lectura de izquierda a derecha, de arriba a abajo, por ejemplo:

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

Con la excepción de una nueva línea final opcional, no debe haber espacios en blanco iniciales o finales en la salida.

Este es el código de golf , por lo que el objetivo es minimizar el tamaño del programa, en bytes.

Notas adicionales

• Para simplificar las cosas, este desafío utiliza la romanización Nihon-shiki . La romanización de Hepburn es más común, pero tiene algunos problemas que hacen que las cosas sean más molestas para el golf (por ejemplo, si se convierte en shi , hu se convierte en fu ).

• Kana hacer existe para el espacios vacíos (ver japonesa SE ), pero eran bien no estándar o ya son obsoletos.

Retina , 54 53 bytes

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

Pruébalo en línea.

Explicación

Wooo, mostrando aún más características de la versión 0.7.2 de hoy. :) ( El lanzamiento es anterior a este desafío en aproximadamente 7 horas).

T`au`ie`y.

Esta es una transliteración que reemplaza acon iy ucon e, pero solo en coincidencias de y.. El propósito de esto es tratar yay dar me yugusta yiy ye, respectivamente, para saltear las brechas.

wa
we

Reemplace wacon wepara omitir ese espacio también.

T`\oeuia`ao

Aquí está la nueva característica. Al rotar conjuntos de caracteres, los conjuntos "de" y "a" en una transliteración suelen ser casi idénticos. Entonces ahora tenemos o(sin una barra invertida) para referirnos al otro conjunto, lo que nos permite deshacernos de algunas duplicaciones. El \ojusto representa un literal oen ese caso. Entonces los dos conjuntos se expanden a:

oeuia
aoeuia

Lo extraño aen el segundo conjunto se ignora y las vocales se reemplazan cíclicamente como se esperaba.

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

Esto hace lo mismo para las consonantes, pero se usa oen el primer conjunto (solo porque podemos ...). hy wnecesitan escapar porque son clases de personajes. Los conjuntos expandidos son:

kstnhmyrw
stnhmyrw

El .arestringe esta operación a sílabas que terminan en a, es decir, aquellas que se ajustan a la siguiente línea de la tabla.

^a
ka

Finalmente, reemplazamos un solo acon ka, porque ese caso no puede ser manejado por la transliteración previa.

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

Comentó en el programa de prueba

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

Comentarios no incluidos en la puntuación:

:                        # 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, esto está comenzando a parecerse mucho a la respuesta de Retina de @ Martin (pero más larga, por supuesto).

Pyth, 42 40 38 bytes

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

Esto toma el producto externo entre vocales y consonantes, y elimina elementos en los ords de cada número en $&./0. Luego emite el elemento después de la entrada.

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

Pruébalo aquí .

TXR Lisp, 135 127 124 91 bytes

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

Correr:

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

• Expansión de llaves para crear una tabla completa en una línea
• sed a:
  • eliminar yi, ye, wi,wu ywe
  • eliminar todo hasta la entrada de entrada incluida (pero no la siguiente entrada)
  • eliminar todo después de la próxima entrada

JavaScript, 145 162 131 118 bytes

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

Admítelo, no podrías imaginar una solución más ridícula para resolver este problema;) ok, hecho esto de una manera más interesante.

Manifestación:

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 bytes

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

Pruébalo en línea!

Haskell, 114 96 bytes

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"]es una lista de todos los kanas, incluidos los "agujeros". Divido la lista en la parte anterior a la entrada kana y desde la entrada kana hasta el final. De la segunda parte elijo el segundo elemento. Las excepciones en torno a los "agujeros" fueron atrapados antes por casos separados.

Editar: a @xnor se le ocurrió la idea de usar lo spanque ahorró 18 bytes.

Perl 6, 105 bytes

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

Esto es lo más corto que puedo obtener en mi primer intento, podría tener otra oportunidad más tarde, pero me siento bastante bien con esto.

JavaScript (ES6), 127 bytes

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

Explicación

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

Prueba

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 bytes

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

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

Espera entradas entre comillas, 'he'por ejemplo

Raqueta 151 bytes

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

Sin golf:

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

Pruebas:

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

Salida:

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

Hay un mensaje de error si se envía 'wo.

C, 138 135 bytes

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

Caja de varitas