您遇到过一本古老的印度手稿，其中描述了成堆的埋藏宝藏。手稿还告诉您宝藏的位置，除了一些关键数字已间接编码到文本中。您会发现文本使用的是“ Kaadi”系统，这是更常见的“ Katapayadi”系统的受限子集。

（Katapayadi系统是一种古老的印度系统，将数字编码为字母，通常用作记忆长数字的助记符。）

您的任务是解码在Kaadi系统中编码的文本并打印出数值。

细节

输入字符

Kaadi系统基于Katapayadi系统的规则，但仅使用第一行辅音。您在此处的文字已音译为拉丁字母，并且仅包含：

• 元音“ a”，“ e”，“ i”，“ o”，“ u”
• 辅音'g'，'k'，'c'，'j'以及它们的大写形式（代表这些辅音的吸引形式）以及'ṅ'和'ñ'。

（如果用您的语言更方便，则可以选择将'ṅ'接收为'ng'，将'ñ'接收为'ny'。）

价值分配

在这个系统中

1. 每个辅音后跟一个元音都有一个与之关联的数字。这些是：

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

但是请注意，这些值仅在这些辅音后跟有元音时才适用。 kacCi具有与kaCi（ka，Ci=（1,7））相同的值，因为中间的c不带元音。

2. 此外，两个元音的初始元音或序列代表0 aikaCi将是：ai，ka，Ci=（0,1,7）

3. 文本中间其他任何地方的多余元音都没有值：kauCia与相同kaCi，多余元音可以忽略。

最终数值

一旦找出字母的数字值，就获得最终数字值，其顺序与这些数字相反，即文本中的第一个数字是最终值中的最低有效数字。

例如。
GucCi具有Guand Ci，所以（
kakakaGo4，7），所以最终值为74. 是（1,1,1,4），所以答案是4111.
guṅKo是（3,2），所以编码为23（gungKo如果使用ASCII -当量。）

输入值

• 包含Kaadi编码文本的字符串
  • 将仅包含元音和上述辅音
  • 元音总是小写，并且以不超过2个的组出现
  • 您可以选择接受5和0的字母作为Unicode字符“ṅ”和“ñ”，或者接受与ASCII等价的“ ng”和“ ny”（它们均以小写形式表示）
  • 您可能会认为没有空格或标点符号

输出量

• 由上述规则给定的文本的数值
  • 对于空输入，除了0外，还可以使用您选择的语言输出空或任何false-y输出
  • 对于无效的输入（除了元音和上述辅音以外的任何输入），输出是不确定的-任何东西

测试用例

"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

（最后一个可以是：

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

如果您愿意的话。）

I / O和漏洞的标准规则适用。愿最好的高尔夫球手获胜！

JavaScript（ES6），83个字节

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

在线尝试！

怎么样？

我们使用以下正则表达式匹配字符串的开头或Kaadi辅音之一，然后匹配元音：

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

对于输入字符串中的每个匹配项，我们调用以下回调函数，该函数将捕获组的内容c作为参数：

(_, c) => o = (s + s).search(c) % 10 + 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  -  ...

当我们匹配字符串的开头而不是辅音时，c是一个空字符串，其在正则表达式中的位置为0-在这种情况下，这是预期的结果。

最后，我们将此数字插入输出字符串o的开头。

视网膜，41字节

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

V`

在线尝试！链接包括测试用例。外植体：

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

翻译后跟元音的辅音。

^[aeiou]
0

处理主元音。

\D

删除其他所有内容。

V`

反转结果。

Python 2，93个字节

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

接受Unicode字符串的未命名函数，该字符串返回以10为基数的结果的字符串表示形式。

在线尝试！

爪哇8，136个 126字节

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

在线尝试。

说明：

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

果冻，27个字节

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

在线尝试！

Jelly内置... 1字节 ṅ。

说明

Żµ             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字节

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]

在线尝试！

Python 3中，104个 102字节

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]

在线尝试！

已保存

• -3个字节，感谢Rod

JavaScript（Node.js），126字节

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

在线尝试！

红，152个 143字节

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]

在线尝试！

可读性：

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字节

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

在线尝试！

（用'b'代替'd'来保存一个字节）
（-2个字节，感谢Luis Mendo）

MATLAB（以及MATL）将字符串视为一个愚蠢的字节序列，使得@TFeld的Python解决方案的移植比我想象的要难（也许在这里直接循环解决方案会更容易？）。结束了使用交替'ng'，'ny'输入方法，以及替换ng用b在开始时更容易处理。

说明：

        % 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 个字节

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

运行并调试