Você encontrou um antigo manuscrito indiano, que descreve montes de tesouros enterrados. O manuscrito também informa a localização do tesouro, exceto que alguns números cruciais foram codificados indiretamente no texto. Você descobre que o texto usa um sistema 'Kaadi', um subconjunto restrito do sistema 'Katapayadi' mais comum.

(O sistema Katapayadi é um sistema indiano antigo para codificar números como letras, frequentemente usado como mnemônica para lembrar números longos.)

Sua tarefa aqui é decodificar o texto codificado no sistema Kaadi e imprimir o valor numérico.

Detalhes

Caracteres de entrada

O sistema Kaadi é baseado nas regras do sistema Katapayadi , mas usa apenas a primeira linha de consoantes. Seu texto aqui foi transliterado para o alfabeto latino e é conhecido por conter apenas:

• vogais 'a', 'e', ​​'i', 'o', 'u'
• consoantes 'g', 'k', 'c', 'j' e suas formas de capital (para representar a forma aspirada dessas consoantes) e 'ṅ' e 'ñ'.

(Você pode optar por receber e manipular 'ṅ' como 'ng' e 'ñ' como 'ny' se for mais conveniente no seu idioma.)

Atribuição de valor

Neste sistema,

1. cada consoante quando seguida por uma vogal tem um dígito associado a ela. Esses são:

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

Observe, no entanto, que esses valores se aplicam somente quando essas consoantes são seguidas por uma vogal. kacCitem o mesmo valor que kaCi( ka, Ci= (1,7)), pois o meio c não é acompanhado por uma vogal.

2. Além disso, uma vogal inicial ou sequência de duas vogais representa um 0. aikaCiseria: ai, ka, Ci= (0,1,7)

3. Vogais extras em qualquer outro lugar no meio do texto não têm valor: kauCiaé o mesmo que kaCi, as vogais extras podem ser ignoradas.

Valor numérico final

Uma vez calculados os valores dos dígitos das letras, o valor numérico final é obtido na ordem inversa desses dígitos, ou seja, o primeiro dígito do texto é o dígito menos significativo no valor final.

Por exemplo.
GucCitem Gue Ci, então (4, 7), então o valor final é 74.
kakakaGoé (1,1,1,4), então a resposta é 4111.
guṅKoé (3,2), então codifica 23. ( gungKose estiver usando ASCII -equivalente.)

Entrada

• Uma sequência que contém um texto codificado por Kaadi
  • conterá apenas vogais e as consoantes acima
  • as vogais estão sempre em minúsculas e ocorrem em grupos de no máximo 2
  • você pode aceitar as letras 5 e 0 como caracteres Unicode 'ṅ' e 'ñ' ou como seus equivalentes ASCII 'ng' e 'ny' (eles estão em minúsculas nos dois formatos)
  • você pode assumir que não há espaços ou pontuações

Resultado

• O valor numérico do texto, conforme determinado pelas regras acima
  • para entrada vazia, é aceitável uma saída vazia ou qualquer saída falsa no idioma de sua escolha, além de 0
  • para entrada inválida (entrada com outra coisa que não vogais e consoantes acima), a saída é indefinida - tudo acontece

Casos de teste

"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

(os últimos podem ser:

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

se você preferir.)

Aplicam-se regras padrão para E / S e brechas . Que ganhe o melhor jogador de golfe!

JavaScript (ES6), 83 bytes

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

Experimente online!

Quão?

Usamos a seguinte expressão regular para corresponder ao início da string ou a uma consoante Kaadi, seguida por uma vogal:

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

Para cada correspondência na sequência de entrada, chamamos a seguinte função de retorno de chamada que usa o conteúdo c do grupo de captura como parâmetro:

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

Encontramos o valor da consoante procurando sua posição na expressão regular (forçada a uma cadeia de caracteres adicionando-a a ela mesma).

As consoantes são ordenadas de forma que seu valor seja igual ao seu módulo de posição 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  -  ...

Quando combinamos o início da string em vez de uma consoante, c é uma string vazia cuja posição na expressão regular é 0 - o que, convenientemente, é o resultado esperado nesse caso.

Finalmente, inserimos esse dígito no início da string de saída o .

Retina , 41 bytes

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

V`

Experimente online! O link inclui casos de teste. Explicação:

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

Traduza as consoantes que são seguidas por vogais.

^[aeiou]
0

Manuseie uma vogal principal.

\D

Exclua todo o resto.

V`

Inverta o 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]

Uma função sem nome que aceita uma string Unicode que retorna uma representação de string do resultado da base dez.

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

Experimente online.

Explicação:

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

Gelatina , 27 bytes

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

Experimente online!

A geléia foi incorporada para ... 1 byte ṅ .

Explicação

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

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

Experimente online!

Salvou

• -3 bytes, graças 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

Experimente online!

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

Experimente online!

Legível:

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

Experimente online!

('b' em vez de 'd' para salvar um byte)
(-2 bytes graças a Luis Mendo)

O MATLAB (e, portanto, o MATL) tratando as strings como uma série de bytes idiotas tornou mais difícil a portabilidade da solução Python do @ TFeld do que eu imaginava (talvez uma solução de loop direto fosse mais fácil aqui?). Terminou-se com a alternativa 'ng', 'ny'o método de entrada, e substituindong com bno início para um processamento mais fácil.

Explicação:

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

Execute e depure