Les caractères kana japonais correspondent à un seul son dans la langue japonaise. À l'exception de ん ( n ), tous les autres kana se composent d'une partie consonne et d'une partie voyelle. Il existe un ordre naturel pour le kana japonais, une sorte d '"ordre alphabétique", qui est généralement organisé dans un tableau de 10 par 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

Cet ordre est appelé gojuuon , ou "cinquante sons", même si certaines des cinquante cellules du tableau sont en fait vides.

Le défi

L'entrée sera l'un des kana répertoriés ci-dessus, à l'exception de wo . Votre programme ou fonction doit sortir le kana suivant dans l'ordre de lecture de gauche à droite, de haut en bas, par exemple:

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

À l'exception d'un retour à la ligne unique facultatif, il ne doit pas y avoir d'espaces de début ou de fin dans la sortie.

Il s'agit de code-golf , donc l'objectif est de minimiser la taille du programme, en octets.

Notes complémentaires

• Afin de garder les choses simples, ce défi utilise la romanisation Nihon-shiki . La romanisation de Hepburn est plus courante, mais présente quelques plis qui rendent les choses plus ennuyeuses pour le golf (par exemple, si devient shi , hu devient fu ).

• Kana ne existent pour les endroits vides (voir japonais SE ), mais ils étaient soit non standard ou sont désormais obsolètes.

Rétine , 54 53 octets

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

Essayez-le en ligne.

Explication

Wooo, présentant encore plus de fonctionnalités de la version 0.7.2 d'aujourd'hui. :) ( La version est antérieure à ce défi d'environ 7 heures.)

T`au`ie`y.

Il s'agit d'une translittération qui remplace apar iet upar e, mais uniquement dans les correspondances de y.. Le but de cela est de traiter yaet d' yuaimer yiet ye, respectivement, afin de sauter les lacunes.

wa
we

Remplacez wapar wepour sauter cet écart également.

T`\oeuia`ao

Voici la nouvelle fonctionnalité. Lors de la rotation d'ensembles de caractères, les ensembles "de" et "à" dans une translittération sont généralement presque identiques. Alors maintenant, nous devons o(sans barre oblique inverse) faire référence à l'autre ensemble, ce qui nous permet de nous débarrasser de certains doublons. Le \ojuste représente un littéral odans ce cas. Les deux ensembles s'étendent donc à:

oeuia
aoeuia

L'étranger adans le deuxième ensemble est ignoré et les voyelles sont remplacées cycliquement comme prévu.

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

Cela fait la même chose pour les consonnes, mais en utilisant odans le premier set (juste parce qu'on peut ...). het ont wbesoin de s'échapper car ce sont des classes de caractères. Les ensembles étendus sont:

kstnhmyrw
stnhmyrw

Le .arestreint cette opération aux syllabes se terminant par a, c'est- à -dire celles qui se terminent par la ligne suivante du tableau.

^a
ka

Enfin, nous remplaçons un single apar ka, car ce cas ne peut pas être traité par la translittération précédente.

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

Commenté dans le programme de test

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

Commentaires non inclus dans la partition:

:                        # 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, cela commence à ressembler beaucoup à la réponse @ Martin's Retina (mais plus longtemps, bien sûr).

Pyth, 42 40 38 octets

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

Cela prend le produit extérieur entre les voyelles et les consonnes, et supprime les éléments aux ords de chaque nombre en $&./0. Ensuite, il sort l'élément après l'entrée.

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

Essayez-le ici .

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

Courir:

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

• Extension Brace pour créer une table complète sur une seule ligne
• sed à:
  • supprimer yi, ye, wi, wuetwe
  • supprimer tout jusqu'à et y compris l'entrée d'entrée (mais pas l'entrée suivante)
  • tout supprimer après la prochaine entrée

JavaScript, 145 162 131 118 118 octets

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

Admettez-le, vous ne pouviez pas imaginer une solution plus ridicule pour résoudre ce problème;) ok, faites cela d'une manière plus intéressante.

Démo:

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 octets

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

Essayez-le en ligne!

Haskell, 114 96 octets

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"]est une liste de tous les kanas, y compris les "trous". Je décompose la liste dans la partie avant le kana d'entrée et du kana d'entrée jusqu'à la fin. Dans la 2ème partie, je choisis le deuxième élément. Les exceptions autour des «trous» ont été prises auparavant par des cas distincts.

Edit: @xnor a eu l'idée d'utiliser spance qui a permis d'économiser 18 octets.

Perl 6, 105 octets

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

C'est aussi court que possible pour la première fois, je pourrais avoir une autre fissure plus tard, mais je me sens plutôt bien à ce sujet.

JavaScript (ES6), 127 octets

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

Explication

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

Tester

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 octets

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

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

Attend une entrée entre guillemets, 'he'par exemple

Raquette 151 octets

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

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

Essai:

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

Sortie:

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

Il y a un message d'erreur si 'wo est envoyé.

C, 138 135 octets

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