Japanische Kana-Zeichen entsprechen einem einzelnen Ton in der japanischen Sprache. Mit Ausnahme von ん ( n ) besteht jedes zweite Kana aus einem Konsonantenteil und einem Vokalteil. Es gibt eine natürliche Reihenfolge zum japanischen Kana, eine Art "alphabetische Reihenfolge", die normalerweise in einer 10 mal 5-Tabelle angeordnet ist:

   |   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

Diese Reihenfolge wird als Gojuuon oder "fünfzig Töne" bezeichnet, obwohl einige der fünfzig Zellen in der Tabelle tatsächlich leer sind.

Die Herausforderung

Die Eingabe erfolgt in einem der oben aufgeführten Kana-Werte, mit Ausnahme von wo . Ihr Programm oder Ihre Funktion sollte das nächste Kana von links nach rechts und von oben nach unten ausgeben, z.

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

Mit Ausnahme einer optionalen einzelnen nachgestellten Zeile sollte die Ausgabe keine führenden oder nachgestellten Leerzeichen enthalten.

Dies ist Codegolf , daher besteht das Ziel darin, die Programmgröße in Bytes zu minimieren.

Zusätzliche Bemerkungen

• Um die Dinge einfach zu halten, verwendet diese Herausforderung eine Nihon-Shiki-Romanisierung . Hepburn-Romanisierung ist häufiger, hat aber ein paar Knicke, die die Sache für das Golfspiel ärgerlicher machen (z. B. Si wird Shi , Hu wird Fu ).

• Kana gibt es für die leeren Stellen (siehe japanische SE ), aber sie waren entweder nicht standardisiert oder sind jetzt veraltet.

Netzhaut , 54 53 Bytes

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

Probieren Sie es online aus.

Erläuterung

Wooo, zeigt noch mehr Funktionen aus der heutigen Version 0.7.2. :) ( Die Veröffentlichung liegt ungefähr 7 Stunden vor dieser Herausforderung .)

T`au`ie`y.

Dies ist eine Transliteration, die amit iund umit ersetzt e, jedoch nur in Streichhölzern von y.. Der Zweck davon ist , zu behandeln yaund yudergleichen yiund yejeweils um die Lücken zu überspringen.

wa
we

Ersetzen Sie wadurch we, um diese Lücke ebenfalls zu überspringen.

T`\oeuia`ao

Hier ist die neue Funktion. Beim Drehen von Zeichensätzen sind die in einer Transliteration festgelegten Zeichen "von" und "bis" in der Regel fast identisch. Jetzt müssen wir o(ohne Backslash) auf die andere Menge verweisen, wodurch wir einige Duplikate entfernen können. Das \oGerechte steht oin diesem Fall für ein wörtliches Wort. Die beiden Sets erweitern sich also zu:

oeuia
aoeuia

Das Fremdwort aim zweiten Satz wird ignoriert und die Vokale werden wie erwartet zyklisch ersetzt.

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

Dies macht das Gleiche für die Konsonanten, aber mit odem ersten Satz (nur weil wir können ...). hund wmüssen entkommen, weil sie Zeichenklassen sind. Die erweiterten Sets sind:

kstnhmyrw
stnhmyrw

Das .abeschränkt diese Operation auf Silben, die auf enden a, dh auf solche, die in die nächste Zeile der Tabelle umgebrochen werden.

^a
ka

Schließlich ersetzen wir eine einzelne adurch ka, da dieser Fall von der vorherigen Transliteration nicht behandelt werden kann.

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

Kommentiert im Testprogramm

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

Kommentare, die nicht in der Partitur enthalten sind:

:                        # 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, das sieht schon sehr nach Martins Retina-Antwort aus (aber natürlich länger).

Pyth, 42 40 38 Bytes

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

Dies nimmt das äußere Produkt zwischen Vokalen und Konsonanten und entfernt Elemente bei den Ordnungen jeder Zahl in $&./0. Dann gibt es das Element nach der Eingabe aus.

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

Probieren Sie es hier aus .

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

Lauf:

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

• Klammern Sie die Erweiterung, um eine vollständige Tabelle in einer Zeile zu erstellen
• sed to:
  • Entfernen yi, ye, wi, wuundwe
  • entferne alles bis einschließlich des Eingabeeintrags (aber nicht den nächsten)
  • entferne alles nach dem nächsten Eintrag

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]

Gib es zu, du könntest dir keine lächerlichere Lösung vorstellen, um dieses Problem zu lösen;) ok, das auf eine interessantere Art und Weise gemacht.

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 Bytes

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

Probieren Sie es online!

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"]ist eine Liste aller Kanas, einschließlich der "Löcher". Ich zerlege die Liste in den Teil vor dem Eingabe-Kana und vom Eingabe-Kana bis zum Ende. Aus dem 2. Teil wähle ich das zweite Element. Die Ausnahmen rund um die "Löcher" werden vorher von einzelnen Fällen aufgefangen.

Edit: @xnor hatte die Idee, span18 Bytes zu speichern.

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

Das ist so kurz, wie ich es auf Anhieb kriegen kann. Vielleicht habe ich später noch einen Knall, aber ich fühle mich ziemlich gut dabei.

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

Erläuterung

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

Prüfung

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]

Erwartet 'he'beispielsweise in Anführungszeichen eingeschlossene Eingaben

Schläger 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)))

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

Testen:

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

Ausgabe:

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

Es wird eine Fehlermeldung ausgegeben, wenn "wo" gesendet wird.

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

Wandbox