I caratteri kana giapponesi corrispondono a un singolo suono in lingua giapponese. Con l'eccezione di ん ( n ), ogni altro kana è costituito da una parte consonante e una parte vocale. Esiste un ordinamento naturale per la kana giapponese, una sorta di "ordine alfabetico", che in genere è organizzato in una tabella 10 per 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

Questo ordinamento si chiama gojuuon , o "cinquanta suoni", anche se alcune delle cinquanta celle nella tabella sono in realtà vuote.

La sfida

L'input sarà uno dei kana sopra elencati, ad eccezione di wo . Il tuo programma o funzione dovrebbe emettere il kana successivo seguendo l'ordine di lettura da sinistra a destra, dall'alto verso il basso, ad esempio:

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

Ad eccezione di una nuova riga finale singola facoltativa, non dovrebbero esserci spazi bianchi iniziali o finali nell'output.

Questo è code-golf , quindi l'obiettivo è ridurre al minimo le dimensioni del programma, in byte.

Note aggiuntive

• Per semplificare le cose, questa sfida utilizza la romanizzazione Nihon-shiki . La romanizzazione di Hepburn è più comune, ma presenta alcuni nodi che rendono le cose più fastidiose per il golf (es. Si diventa shi , hu diventa fu ).

• Kana do esiste per i posti vuoti (vedi Japanese SE ), ma erano o non standard o sono ormai obsoleti.

Retina , 54 53 byte

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

Provalo online.

Spiegazione

Bene, mostrando ancora più funzionalità della versione 0.7.2 di oggi. :) ( La versione precede questa sfida di circa 7 ore.)

T`au`ie`y.

Questa è una traslitterazione che sostituisce acon ie ucon e, ma solo in corrispondenza di y.. Lo scopo è quello di trattare yae yuapprezzare yie ye, rispettivamente, al fine di saltare le lacune.

wa
we

Sostituisci wacon weper saltare anche questo spazio.

T`\oeuia`ao

Ecco la nuova funzionalità. Quando si ruotano insiemi di caratteri, i "da" e "a" in una traslitterazione sono generalmente quasi identici. Quindi ora abbiamo o(senza una barra rovesciata) di fare riferimento all'altro set, che ci consente di sbarazzarci di qualche duplicazione. Il \osolo sta per un letterale oin quel caso. Quindi i due set si espandono in:

oeuia
aoeuia

L'estraneo anel secondo set viene ignorato e le vocali vengono sostituite ciclicamente come previsto.

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

Questo fa la stessa cosa per le consonanti, ma usando onel primo set (solo perché possiamo ...). he hanno wbisogno di scappare perché sono classi di caratteri. I set espansi sono:

kstnhmyrw
stnhmyrw

Le .alimita questa operazione per sillabe che terminano in a, cioè quelli che avvolgono alla riga successiva della tabella.

^a
ka

Infine, sostituiamo un singolo acon ka, perché quel caso non può essere gestito dalla precedente traslitterazione.

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

Commentato nel programma di 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

Commenti non inclusi nel punteggio:

:                        # 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, questo sta cominciando ad assomigliare molto alla risposta Retina di @ Martin (ma più a lungo, ovviamente).

Pyth, 42 40 38 byte

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

Questo prende il prodotto esterno tra vocali e consonanti e rimuove gli elementi in corrispondenza delle ordinazioni di ciascun numero in $&./0. Quindi emette l'elemento dopo l'ingresso.

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

Provalo qui .

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

Correre:

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

• Espandere l'espansione per creare una tabella completa su una riga
• sed a:
  • remove yi, ye, wi, wuewe
  • rimuovi tutto fino alla voce di input inclusa (ma non alla voce successiva)
  • rimuovere tutto dopo la voce successiva

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]

Ammettilo, non potresti immaginare una soluzione più ridicola per risolvere questo problema;) ok, fatto in un modo più interessante.

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

Provalo 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"]è un elenco di tutti i kana, inclusi i "buchi". Spezzo l'elenco nella parte prima dell'input kana e dall'input kana fino alla fine. Dalla seconda parte scelgo il secondo elemento. Le eccezioni attorno ai "buchi" vengono colte in precedenza da casi separati.

Modifica: @xnor ha avuto l'idea di utilizzare spanche ha salvato 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

Questo è il più breve possibile per il mio primo tentativo, potrei avere un altro crack in seguito, ma mi sento abbastanza bene.

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

Spiegazione

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

Test

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]

Prevede input racchiusi tra virgolette, 'he'ad esempio

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

Ungolfed:

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

test:

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

Produzione:

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

C'è un messaggio di errore se 'wo viene inviato.

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