Sie sind auf ein altes indisches Manuskript gestoßen, das Hügel vergrabener Schätze beschreibt. Das Manuskript informiert Sie auch über die Position des Schatzes, mit der Ausnahme, dass einige wichtige Zahlen indirekt in den Text kodiert wurden. Sie stellen fest, dass der Text ein 'Kaadi'-System verwendet, eine eingeschränkte Teilmenge des allgemeineren' Katapayadi'-Systems.

(Das Katapayadi- System ist ein altes indisches System zum Kodieren von Ziffern als Buchstaben, das häufig als Mnemonik zum Speichern langer Zahlen verwendet wird.)

Ihre Aufgabe hier ist es, im Kaadi-System kodierten Text zu dekodieren und den numerischen Wert auszudrucken.

Einzelheiten

Zeichen eingeben

Das Kaadi-System basiert auf den Regeln des Katapayadi-Systems , verwendet jedoch nur die erste Reihe von Konsonanten. Ihr Text hier wurde ins lateinische Alphabet übersetzt und enthält bekanntermaßen nur:

• Vokale 'a', 'e', ​​'i', 'o', 'u'
• Konsonanten 'g', 'k', 'c', 'j' und ihre Kapitalformen (um die aspirierte Form dieser Konsonanten darzustellen ) sowie 'ṅ' und 'ñ'.

(Sie können wählen, ob Sie 'ṅ' als 'ng' und 'ñ' als 'ny' empfangen und verarbeiten möchten, wenn dies in Ihrer Sprache praktischer ist.)

Wertzuweisung

In diesem System

1. Jedem Konsonanten, dem ein Vokal folgt, ist eine Ziffer zugeordnet. Diese sind:

   'k'=>1, 'K'=>2,
'g'=>3, 'G'=>4,
'ṅ'=>5,
'c'=>6, 'C'=>7,
'j'=>8, 'J'=>9,
'ñ'=>0

Beachten Sie jedoch, dass diese Werte nur gelten, wenn auf diese Konsonanten ein Vokal folgt. kacCihat den gleichen Wert wie kaCi( ka, Ci= (1,7)), da das mittlere c nicht von einem Vokal begleitet wird.

2. Zusätzlich ist eine erste Vokal oder eine Folge von zwei Vokalen a 0 aikaCiwäre: ai, ka, Ci= (0,1,7)

3. Zusätzliche Vokale an einer anderen Stelle in der Mitte des Textes haben keinen Wert: kauCiaEntspricht dem kaCi, dass die zusätzlichen Vokale ignoriert werden können.

Endgültiger numerischer Wert

Sobald die Ziffernwerte der Buchstaben herausgefunden worden sind, wird der endgültige numerische Wert in umgekehrter Reihenfolge dieser Ziffern erhalten, dh die erste Ziffer aus dem Text ist die am wenigsten signifikante Ziffer im endgültigen Wert.

Z.B.
GucCihat Guund Ci, also (4, 7), also ist der Endwert 74.
kakakaGoist (1,1,1,4), also ist die Antwort 4111.
guṅKoist (3,2), also codiert 23. ( gungKowenn ASCII verwendet wird) -Äquivalent.)

Eingang

• Eine Zeichenfolge, die einen Kaadi-codierten Text enthält
  • wird nur Vokale und die oben genannten Konsonanten enthalten
  • Die Vokale sind immer in Kleinbuchstaben und kommen in Gruppen von nicht mehr als 2 vor
  • Sie können die Buchstaben für 5 und 0 entweder als Unicode-Zeichen 'ṅ' und 'ñ' oder als ASCII-Entsprechungen 'ng' und 'ny' akzeptieren (in beiden Formaten in Kleinbuchstaben).
  • Sie können davon ausgehen, dass es keine Leerzeichen oder Interpunktionen gibt

Ausgabe

• Der numerische Wert des Texts gemäß den obigen Regeln
  • Für leere Eingaben ist eine leere Ausgabe oder eine falsche y-Ausgabe in der Sprache Ihrer Wahl zulässig, zusätzlich zu 0
  • Für ungültige Eingaben (Eingaben mit Ausnahme von Vokalen und den oben genannten Konsonanten) ist die Ausgabe undefiniert - alles ist möglich

Testfälle

"GucCi"
=> 74
"kakakaGo"
=> 4111
"aiKaCiigukoJe"
=> 913720
""
=> 0 //OR empty/falsey output
"a"
=> 0
"ukkiKagijeCaGaacoJiiKka"
=> 1964783210
"kegJugjugKeg"
=> 2891
"guṅKo"
=> 23
"Guñaaka"
=> 104
"juñiKoṅe"
=>5208

(Die letzten können sein:

"gungKo"
=> 23
"Gunyaaka"
=> 104
"junyiKonge"
=>5208

wenn du das vorziehst.)

Es gelten die Standardregeln für E / A und Lücken . Möge der beste Golfer gewinnen!

JavaScript (ES6), 83 Byte

s=>s.replace(s=/(^|[ṅcCjJñkKgG])[aeiou]/g,(_,c)=>o=(s+s).search(c)%10+o,o='')&&o

Probieren Sie es online!

Wie?

Wir verwenden den folgenden regulären Ausdruck, um entweder den Anfang der Zeichenfolge oder einen der Kaadi-Konsonanten abzubilden, gefolgt von einem Vokal:

/(^|[ṅcCjJñkKgG])[aeiou]/g

Für jede Übereinstimmung in der Eingabezeichenfolge rufen wir die folgende Rückruffunktion auf, die den Inhalt c der Erfassungsgruppe als Parameter verwendet:

(_, c) => o = (s + s).search(c) % 10 + o

Wir finden den Wert des Konsonanten, indem wir nach seiner Position im regulären Ausdruck suchen (erzwungen zu einer Zeichenfolge, indem wir ihn zu sich selbst hinzufügen).

Die Konsonanten sind so angeordnet, dass ihr Wert gleich ihrer Position modulo 10 ist :

string   : /  (  ^  |  [  ṅ  c  C  j  J  ñ  k  K  g  G  ]  )  [  a  e  i  o  u  ]  /  g
position : 0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 ...
modulo 10: -  -  -  -  -  5  6  7  8  9  0  1  2  3  4  -  ...

Wenn wir den Anfang der Zeichenfolge anstelle eines Konsonanten abgleichen, ist c eine leere Zeichenfolge, deren Position im regulären Ausdruck 0 ist - was günstigerweise das erwartete Ergebnis in diesem Fall ist.

Schließlich fügen wir diese Ziffer am Anfang der Ausgabezeichenfolge o ein .

Retina , 41 Bytes

T`ñkKgGṅcCjJ`d`.[aeiou]
^[aeiou]
0
\D

V`

Probieren Sie es online! Link enthält Testfälle. Erklärung:

T`ñkKgGṅcCjJ`d`.[aeiou]

Übersetzen Sie die Konsonanten, auf die Vokale folgen.

^[aeiou]
0

Fassen Sie einen führenden Vokal an.

\D

Alles andere löschen.

V`

Kehre das Ergebnis um.

Python 2 , 93 Bytes

lambda s,h=u'ñkKgGṅcCjJ'.find:''.join(`h(c)`*(0>h(v)<h(c))for c,v in zip(u'ñ'+s,s))[::-1]

Eine unbenannte Funktion, die eine Unicode-Zeichenfolge akzeptiert, die eine Zeichenfolgendarstellung des Basis-Zehn-Ergebnisses zurückgibt.

Probieren Sie es online!

Java 8, 136 126 Bytes

s->{for(int i=s.length,t;i-->0;)if("aeiou".contains(s[i]))System.out.print(i<1?0:(t="ñkKgGṅcCjJ".indexOf(s[i-1]))<0?"":t);}

Probieren Sie es online aus.

Erläuterung:

s->{                           // Method with String-array parameter and String return-type
  for(int i=s.length,t;i-->0;) //  Loop backwards over the input-characters
    if("aeiou".contains(s[i])) //   If the current character is a vowel:
      System.out.print(        //    Print:
         i<1?                  //     If we're at the first character:
          0                    //      Print a 0
         :                     //     Else:
          (t="ñkKgGṅcCjJ".indexOf(s[i-1]))<0?
                               //      If the character before the vowel is also a vowel:
           ""                  //       Print nothing
          :                    //      Else:
           t);}                //       Print the correct digit of the consonant

Gelee , 27 Bytes

Żµe€Øẹœpṫ€0F“kKgGṅcCjJ”iⱮUḌ

Probieren Sie es online!

Jelly ist für 1 Byte integriert ṅ.

Erläuterung

Żµ             Prepend 0 to the string.
  e€  œp       Split at...
    Øẹ           the vowels. (0 is not a vowel)

ṫ€0            For each sublist `l` takes `l[-1:]`.
                 If the initial list is empty the result is empty,
                 otherwise the result is a list contain the last element.
   F           Flatten. (concatenate the results)

“kKgGṅcCjJ”iⱮ  Find the index of each character in the list.
                 Get 0 if not found (i.e., for `0` or `ñ`)
UḌ             Upend (reverse) and then convert from decimal.

Python 2 , 101 Bytes

lambda s,S=u'ñkKgGṅcCjJ':''.join(`S.find(c)`for c,n in zip(u'ñ'+s,s)if c in(n in'aeiou')*S)[::-1]

Probieren Sie es online!

Python 3 , 104 102 Bytes

lambda s,S='ñkKgGṅcCjJ':''.join(str(S.find(c))for c,n in zip('ñ'+s,s)if c in(n in'aeiou')*S)[::-1]

Probieren Sie es online!

Gerettet

• -3 Bytes, danke an Rod

JavaScript (Node.js) , 126 Byte

_=>(l=_.match(/[kgñṅcj][aeiou]/gi))?l.map(a=>"ñkKgGṅcCjJ".indexOf(a[0])).reverse``.join``+(/[ aiueo]/.test(_[0])?0:''):0

Probieren Sie es online!

Rot , 152 143 Bytes

func[s][t:"ñkKgGṅcCjJ"c: charset t
d: copy{}parse s[opt[1 2 not c(alter d 0)]any[copy n c not c(insert
d(index? find/case t n)- 1)| skip]]d]

Probieren Sie es online!

Lesbar:

f: func[s] [
    t: "ñkKgGṅcCjJ"
    c: charset t
    d: copy {}
    parse s [
        opt [ 1 2 not c (alter d 0) ]
        any [ 
              copy n c not c (insert d (index? find/case t n) - 1)
            | skip 
        ]
    ]
    d
]

MATL , 48 47 45 Bytes

'ng'98Ztt'y'whw11Y2m)'ykKgGbcCjJ'tfqXEt10<)oP

Probieren Sie es online!

('b' statt 'd', um ein Byte zu speichern)
(-2 Byte dank Luis Mendo)

MATLAB (und damit MATL) hat die Portierung von @ TFelds Python-Lösung schwieriger gemacht, als ich es mir vorgestellt hatte (vielleicht wäre eine Straight-Loop-Lösung hier einfacher gewesen?). Am Ende mit dem alternativen 'ng', 'ny'Eingabeverfahren, und das Ersetzen ngmit bam Anfang für eine einfachere Verarbeitung.

Erläuterung:

        % Implicit input (assume 'junyiKonge')
 'ng'   % string literal
 98     % 'b'
 Zt     % replace substring with another (stack: 'junyiKobe')
 t      % duplicate that (stack: 'junyiKobe' 'junyiKobe')
 'y'    % string literal
 w      % swap elements in stack so 'y' goes before input (stack: 'junyiKobe' 'y' 'junyiKobe')
 h      % horizontal concatenation (prepend 'y' to input string) (stack: 'junyiKobe' 'yjunyiKobe')
 w      % swap stack (stack: 'yjunyiKobe' 'junyiKobe')
 11Y2   % place 'aeiou' in stack (stack: 'yjunyiKobe' 'junyiKobe' 'aeiou')
 m      % set places with a vowel to True i.e. 1 (stack: 'yjunyiKobe' 0 1 0 1 0 1 0 0 1)
 )      % index into those places (stack: 'jyKd')
 'ykKgGdcCjJ' % string literal
 tfq    % generate numbers 0 to 9 (stack: 'jyKd' 'ykKgGdcCjJ' 0 1 2 3 4 5 6 7 8 9)
 XE     % replace elements in first array which are found in second,
        %  with corresponding elements from third
 t10<)  % keep only elements that are less than 10 (removes extraneous vowels)
 o      % convert from string to double (numeric) array (stack: 8 0 2 5)
 P      % flip the order of elements (stack: 5 2 0 8)
        % (implicit) convert to string and display

Stax , 27 Bytes

âΔxñW⌡╪c§âaQ&δ▓äHê╠$╞╣;→◄vΓ

Führen Sie es aus und debuggen Sie es