Te has encontrado con un viejo manuscrito indio, uno que describe montones de tesoros enterrados. El manuscrito también le dice la ubicación del tesoro, excepto que algunos números cruciales se han codificado indirectamente en el texto. Usted se da cuenta de que el texto usa un sistema 'Kaadi', un subconjunto restringido del sistema más común 'Katapayadi'.

(El sistema Katapayadi es un antiguo sistema indio para codificar números como letras, a menudo utilizado como mnemotecnia para recordar números largos).

Su tarea aquí es decodificar texto codificado en el sistema Kaadi e imprimir el valor numérico.

Detalles

Caracteres de entrada

El sistema Kaadi se basa en las reglas del sistema Katapayadi , pero usa solo la primera fila de consonantes. Su texto aquí se ha transcrito al alfabeto latino y se sabe que contiene solo:

• vocales 'a', 'e', ​​'i', 'o', 'u'
• consonantes 'g', 'k', 'c', 'j' y sus formas capitales (para representar la forma aspirada de esas consonantes), y 'ṅ' y 'ñ'.

(Puede elegir recibir y manejar 'ṅ' como 'ng' y 'ñ' como 'ny' si eso es más conveniente en su idioma).

Asignación de valor

En este sistema

1. cada consonante cuando es seguida por una vocal tiene un dígito asociado. Estos son:

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

Sin embargo, tenga en cuenta que estos valores se aplican solo cuando estas consonantes son seguidas por una vocal. kacCitiene el mismo valor que kaCi( ka, Ci= (1,7)) ya que el medio c no está acompañado por una vocal.

2. Además, un vocal inicial o la secuencia de dos vocales representa un 0. aikaCiser sería: ai, ka, Ci= (0,1,7)

3. Las vocales adicionales en cualquier otro lugar en el medio del texto no tienen valor: kauCiaes lo mismo kaCi, las vocales adicionales pueden ignorarse.

Valor numérico final

Una vez que se han calculado los valores de los dígitos de las letras, el valor numérico final se obtiene como el orden inverso de esos dígitos, es decir, el primer dígito del texto es el dígito menos significativo en el valor final.

P.ej.
GucCitiene Guy Ci, entonces (4, 7), entonces el valor final es 74.
kakakaGoes (1,1,1,4), entonces la respuesta es 4111.
guṅKoes (3,2), entonces codifica 23. ( gungKosi usa ASCII -equivalente.)

Entrada

• Una cadena que contiene un texto codificado en Kaadi
  • contendrá solo vocales y las consonantes anteriores
  • las vocales siempre están en minúsculas y ocurren en grupos de no más de 2
  • puede elegir aceptar las letras para 5 y 0 como sus caracteres Unicode 'ṅ' y 'ñ' o como sus equivalentes ASCII 'ng' y 'ny' (están en minúsculas en cualquier forma)
  • puede suponer que no hay espacios ni signos de puntuación

Salida

• El valor numérico del texto, dado por las reglas anteriores.
  • para entradas vacías, una salida vacía o cualquier salida falsa y en su idioma de elección es aceptable, además de 0
  • para la entrada no válida (entrada con cualquier otra cosa que no sean vocales y las consonantes anteriores), la salida no está definida: todo vale

Casos de prueba

"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

(los últimos pueden ser:

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

si prefieres eso)

Se aplican reglas estándar para E / S y lagunas . ¡Que gane el mejor golfista!

JavaScript (ES6), 83 bytes

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

Pruébalo en línea!

¿Cómo?

Usamos la siguiente expresión regular para unir el comienzo de la cuerda o una de las consonantes de Kaadi, seguido de una vocal:

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

Para cada coincidencia en la cadena de entrada, invocamos la siguiente función de devolución de llamada que toma el contenido c del grupo de captura como parámetro:

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

Encontramos el valor de la consonante buscando su posición en la expresión regular (coaccionada a una cadena al agregarla a sí misma).

Las consonantes están ordenadas de tal manera que su valor es igual a su posición módulo 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  -  ...

Cuando hacemos coincidir el comienzo de la cadena en lugar de una consonante, c es una cadena vacía cuya posición en la expresión regular es 0 , que, convenientemente, es el resultado esperado en ese caso.

Finalmente, insertamos este dígito al comienzo de la cadena de salida o .

Retina , 41 bytes

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

V`

Pruébalo en línea! El enlace incluye casos de prueba. Explantación

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

Traduce las consonantes que siguen las vocales.

^[aeiou]
0

Maneja una vocal principal.

\D

Eliminar todo lo demás.

V`

Invierte el resultado.

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]

Una función sin nombre que acepta una cadena Unicode que devuelve una representación de cadena del resultado base diez.

Pruébalo en línea!

Java 8, 136126 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);}

Pruébalo en línea.

Explicación:

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

Jalea , 27 bytes

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

Pruébalo en línea!

Jelly se ha incorporado para ... 1 byte ṅ.

Explicación

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

Pruébalo en línea!

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]

Pruébalo en línea!

Salvado

• -3 bytes, gracias a Rod

JavaScript (Node.js) , 126 bytes

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

Pruébalo en línea!

Rojo , 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]

Pruébalo en línea!

Legible:

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

Pruébalo en línea!

('b' en lugar de 'd' para guardar un byte)
(-2 bytes gracias a Luis Mendo)

MATLAB (y, por lo tanto, MATL) tratar las cadenas como una serie tonta de bytes hizo que portar la solución Python de @ TFeld fuera más difícil de lo que imaginaba (¿tal vez una solución de bucle directo hubiera sido más fácil aquí?). Terminamos utilizando la alternativa 'ng', 'ny'el método de entrada, y la sustitución ngcon bal comienzo para el procesamiento más fácil.

Explicación:

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

Ejecutar y depurarlo