Vous êtes tombé sur un vieux manuscrit indien, qui décrit des monticules de trésors enfouis. Le manuscrit vous indique également l'emplacement du trésor, sauf que certains nombres cruciaux ont été encodés indirectement dans le texte. Vous comprenez que le texte utilise un système «Kaadi», un sous-ensemble restreint du système «Katapayadi» plus courant.

(Le système Katapayadi est un ancien système indien pour coder des chiffres sous forme de lettres, souvent utilisé comme mnémonique pour se souvenir de nombres longs.)

Votre tâche ici est de décoder le texte encodé dans le système Kaadi et d'imprimer la valeur numérique.

Détails

Saisir des caractères

Le système Kaadi est basé sur les règles du système Katapayadi , mais n'utilise que la première rangée de consonnes. Votre texte ici a été translittéré en alphabet latin et ne contient que:

• voyelles 'a', 'e', ​​'i', 'o', 'u'
• les consonnes «g», «k», «c», «j» et leurs formes majuscules (pour représenter la forme aspirée de ces consonnes), et «ṅ» et «ñ».

(Vous pouvez choisir de recevoir et de gérer «ṅ» comme «ng» et «ñ» comme «ny» si cela est plus pratique dans votre langue.)

Attribution de valeur

Dans ce système,

1. chaque consonne suivie d'une voyelle est associée à un chiffre. Ceux-ci sont:

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

Notez cependant que ces valeurs ne s'appliquent que lorsque ces consonnes sont suivies d'une voyelle. kacCia la même valeur que kaCi( ka, Ci= (1,7)) car le milieu c n'est pas accompagné d'une voyelle.

2. En outre, une voyelle ou une séquence de deux voyelles représente un 0. aikaCiserait: ai, ka, Ci= (0,1,7)

3. Les voyelles supplémentaires n'importe où ailleurs au milieu du texte n'ont aucune valeur: kauCiaest la même que kaCi, les voyelles supplémentaires peuvent être ignorées.

Valeur numérique finale

Une fois que les valeurs des chiffres des lettres ont été déterminées, la valeur numérique finale est obtenue comme l'ordre inverse de ces chiffres, c'est-à-dire que le premier chiffre du texte est le chiffre le moins significatif de la valeur finale.

Par exemple.
GucCia Guet Ci, donc (4, 7), donc la valeur finale est 74.
kakakaGoest (1,1,1,4), donc la réponse est 4111.
guṅKoest (3,2), donc code 23. ( gungKosi vous utilisez ASCII -équivalent.)

Contribution

• Une chaîne contenant un texte encodé en Kaadi
  • ne contiendra que des voyelles et les consonnes ci-dessus
  • les voyelles sont toujours en minuscules et apparaissent en groupes de 2 au maximum
  • vous pouvez choisir d'accepter les lettres pour 5 et 0 soit comme leurs caractères Unicode '' 'et' ñ 'ou comme leurs équivalents ASCII' ng 'et' ny '(ils sont en minuscules dans les deux formes)
  • vous pouvez supposer qu'il n'y a ni espace ni ponctuation

Production

• La valeur numérique du texte, telle que donnée par les règles ci-dessus
  • pour une entrée vide, une sortie vide ou toute sortie faux-y dans la langue de votre choix est acceptable, en plus de 0
  • pour une entrée invalide (entrée avec autre chose que des voyelles et les consonnes ci-dessus), la sortie n'est pas définie - tout va

Cas de test

"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

(les derniers peuvent être:

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

si vous préférez.)

Les règles standard pour les E / S et les failles s'appliquent. Que le meilleur golfeur gagne!

JavaScript (ES6), 83 octets

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

Essayez-le en ligne!

Comment?

Nous utilisons l'expression régulière suivante pour faire correspondre le début de la chaîne ou l'une des consonnes de Kaadi, suivie d'une voyelle:

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

Pour chaque correspondance dans la chaîne d'entrée, nous invoquons la fonction de rappel suivante qui prend le contenu c du groupe de capture en paramètre:

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

Nous trouvons la valeur de la consonne en recherchant sa position dans l'expression régulière (contraint à une chaîne en l'ajoutant à lui-même).

Les consonnes sont ordonnées de telle sorte que leur valeur soit égale à leur position modulo 10 :

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

Lorsque nous faisons correspondre le début de la chaîne au lieu d'une consonne, c est une chaîne vide dont la position dans l'expression régulière est 0 - ce qui, commodément, est le résultat attendu dans ce cas.

Enfin, nous insérons ce chiffre au début de la chaîne de sortie o .

Rétine , 41 octets

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

V`

Essayez-le en ligne! Le lien inclut des cas de test. Explantion:

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

Traduisez les consonnes suivies des voyelles.

^[aeiou]
0

Manipulez une voyelle de tête.

\D

Supprimez tout le reste.

V`

Inverse le résultat.

Python 2 , 93 octets

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

Une fonction sans nom acceptant une chaîne Unicode qui renvoie une représentation sous forme de chaîne du résultat de base dix.

Essayez-le en ligne!

Java 8, 136 126 octets

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

Essayez-le en ligne.

Explication:

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

Gelée , 27 octets

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

Essayez-le en ligne!

Jelly a intégré pour ... 1 octet ṅ .

Explication

Żµ             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 octets

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]

Essayez-le en ligne!

Python 3 , 104 102 octets

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]

Essayez-le en ligne!

Enregistré

• -3 octets, grâce à Rod

JavaScript (Node.js) , 126 octets

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

Essayez-le en ligne!

Rouge , 152 143 octets

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]

Essayez-le en ligne!

Lisible:

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 octets

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

Essayez-le en ligne!

('b' au lieu de 'd' pour enregistrer un octet)
(-2 octets grâce à Luis Mendo)

MATLAB (et donc MATL) traitant les chaînes comme une série stupide d'octets a rendu le portage de la solution Python de @ TFeld plus difficile que je ne l'imaginais (peut-être qu'une solution en boucle droite aurait été plus facile ici?). Se terminant à l' aide de l'alternative 'ng', la 'ny'méthode d' entrée, et en remplaçant ngavecb au début pour faciliter le traitement.

Explication:

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

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

Exécuter et déboguer