Decodifica del sistema Kaadi


14

Ti sei imbattuto in un vecchio manoscritto indiano, che descrive tumuli di tesori sepolti. Il manoscritto indica anche la posizione del tesoro, tranne per il fatto che alcuni numeri cruciali sono stati codificati indirettamente nel testo. Capisci che il testo utilizza un sistema "Kaadi", un sottoinsieme limitato del più comune sistema "Katapayadi".

(Il sistema Katapayadi è un antico sistema indiano per codificare i numeri come lettere, spesso usato come mnemonica per ricordare numeri lunghi.)

Il tuo compito qui è decodificare il testo codificato nel sistema Kaadi e stampare il valore numerico.

Dettagli

Caratteri di input

Il sistema Kaadi si basa sulle regole del sistema Katapayadi , ma utilizza solo la prima fila di consonanti. Il tuo testo qui è stato traslitterato in alfabeto latino ed è noto per contenere solo:

  • vocali "a", "e", "i", "o", "u"
  • consonanti 'g', 'k', 'c', 'j' e le loro forme capitali (per rappresentare la forma aspirata di quelle consonanti), e 'ṅ' e 'ñ'.

(Puoi scegliere di ricevere e gestire "ṅ" come "ng" e "ñ" come "ny" se è più conveniente nella tua lingua.)

Assegnazione valore

In questo sistema,

  1. a ciascuna consonante seguita da una vocale è associata una cifra. Questi sono:

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

Si noti tuttavia che questi valori si applicano solo quando queste consonanti sono seguite da una vocale. kacCiha lo stesso valore di kaCi( ka, Ci= (1,7)) poiché la c centrale non è accompagnata da una vocale.

  1. Inoltre, una vocale iniziale o sequenza di due vocali rappresenta uno 0. aikaCisarebbe: ai, ka, Ci= (0,1,7)

  2. Le vocali extra altrove nel mezzo del testo non hanno alcun valore: kauCiaè uguale kaCialle vocali extra che possono essere ignorate.

Valore numerico finale

Una volta individuati i valori delle cifre delle lettere, il valore numerico finale viene ottenuto come l'ordine inverso di quelle cifre, ovvero la prima cifra del testo è la cifra meno significativa del valore finale.

Per esempio.
GucCiha Gue Ci, quindi (4, 7), quindi il valore finale è 74.
kakakaGoè (1,1,1,4), quindi la risposta è 4111.
guṅKoè (3,2), quindi codifica 23. ( gungKose si utilizza ASCII -equivalente.)

Ingresso

  • Una stringa contenente un testo codificato in Kaadi
    • conterrà solo vocali e le consonanti di cui sopra
    • le vocali sono sempre in minuscolo e si presentano in gruppi di non più di 2
    • puoi scegliere di accettare le lettere per 5 e 0 come caratteri Unicode 'ṅ' e 'ñ' o come equivalenti ASCII 'ng' e 'ny' (sono in minuscolo in entrambe le forme)
    • puoi presumere che non ci siano spazi o punteggiatura

Produzione

  • Il valore numerico del testo, come indicato dalle regole precedenti
    • per input vuoto, è accettabile un output vuoto o qualsiasi output false-y nella lingua prescelta, oltre a 0
    • per input non valido (input con qualcosa di diverso dalle vocali e dalle consonanti sopra), l'output è indefinito - tutto va bene

Casi 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

(gli ultimi possono essere:

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

se preferisci quello.)

Si applicano le norme standard per I / O e scappatoie . Che vinca il migliore golfista!


1
Può aiaKaciessere inserito? (3 vocali principali)
Erik the Outgolfer,

Non esiste inoltre un caso di test che termina in una consonante; possiamo supporre che l'input finisca sempre in una vocale?
Erik the Outgolfer,

No per 3 vocali principali. In effetti, non penso che abbia senso che si verifichino 3 vocali conseguenti ovunque nell'ingresso (a volte sono necessarie 2 vocali inglesi per rappresentare un suono vocale vocalica, ma mai 3). Posso aggiungerlo adesso come vincolo di input o è troppo tardi?
Sundar - Ripristina Monica l'

2
Non è troppo tardi per chiarire che l'ingresso non avrà 3 vocali principali. Ciò non interromperà alcun invio e dubito che qualcuno abbia scritto un codice più lungo per tenerne conto e, se lo ha, può semplicemente rimuoverlo. Bella prima domanda a proposito! :)
Stewie Griffin,

2
Nel caso in cui aiuti in alcune lingue: ord(c)%47%10fornisce un indice univoco [0..9]per ciascuna consonante. (Con ord("ṅ")=7749e ord("ñ")=241.)
Arnauld

Risposte:


5

JavaScript (ES6), 83 byte

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

Provalo online!

Come?

Usiamo la seguente espressione regolare per abbinare l'inizio della stringa o una delle consonanti Kaadi, seguita da una vocale:

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

Per ogni corrispondenza nella stringa di input, invochiamo la seguente funzione di callback che accetta il contenuto c del gruppo di acquisizione come parametro:

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

Troviamo il valore della consonante cercando la sua posizione nell'espressione regolare (costretta a una stringa aggiungendola a se stessa).

Le consonanti sono ordinate in modo tale che il loro valore sia uguale alla loro posizione 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  -  ...

Quando abbiniamo l'inizio della stringa invece di una consonante, c è una stringa vuota la cui posizione nell'espressione regolare è 0 - che, convenientemente, è il risultato atteso in quel caso.

Infine, inseriamo questa cifra all'inizio della stringa di output o .


4

Retina , 41 byte

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

V`

Provalo online! Il link include casi di test. explantion:

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

Traduci le consonanti seguite dalle vocali.

^[aeiou]
0

Gestire una vocale principale.

\D

Elimina tutto il resto.

V`

Invertire il risultato.


4

Python 2 , 93 byte

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 funzione senza nome che accetta una stringa Unicode che restituisce una rappresentazione in stringa del risultato base dieci.

Provalo online!


3

Java 8, 136 126 byte

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

Provalo online.

Spiegazione:

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

3

Gelatina , 27 byte

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

Provalo online!

Jelly ha incorporato per ... 1 byte .

Spiegazione


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

Non ho trovato un modo per salvare i byte con quello, ma O%47%10fornisce un indice univoco [0...9]per ogni consonante. (Il che significa che O%47con il modulo implicito di consentirebbe di raccogliere il valore corretto in una matrice di 10 voci.)
Arnauld

1
@Arnauld 6;µe€Øẹœpṫ€0O%47ị“ ʠḷ’Œ?’¤Ṛma anche 27 a meno che non possa essere giocato a golf.
Jonathan Allan,

3

Python 2 , 101 byte

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]

Provalo online!

Python 3 , 104 102 byte

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]

Provalo online!


Salvato

  • -3 byte, grazie a Rod

Bene, puoi aggiungere l'header , ma ho dimenticato il prefisso unicode nelle stringhe, dopo tutto, salverebbe un singolo byte
Rod

@ Rod, ah grazie, mi ero dimenticato del prefisso unicode :)
TFeld,

1

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

Provalo online!


1
puoi salvare qualche byte cambiando x=[..."ñkKgGṅcCjJ"]in solo x="ñkKgGṅcCjJ"perché indexOffunziona anche con Stringhe
WaffleCohn

1
Questo non sembra trattare le vocali iniziali come 0, quindi fallisce i casi di test 3 e 6 (come si può vedere nell'Output su TIO).
Sundar - Ripristina Monica l'

@sundar Il mio male, fisso.
Luis felipe De jesus Munoz,

1

Rosso , 152 143 byte

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]

Provalo online!

Leggibile:

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
]

1

MATL , 48 47 45 byte

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

Provalo online!

('b' invece di 'd' per salvare un byte)
(-2 byte grazie a Luis Mendo)

MATLAB (e quindi MATL) trattando le stringhe come una stupida serie di byte ha reso il porting della soluzione Python di @ TFeld più difficile di quanto immaginassi (forse una soluzione ad anello dritto qui sarebbe stata più semplice?). Finito con l'alternativa 'ng', 'ny'metodo di input e sostituzione ngcon ball'inizio per una più facile elaborazione.

Spiegazione:

        % 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

Grazie fatto. Sai se MATLAB / Octave ha qualcosa in cui indicizzare / iterare attraverso una stringa attraverso punti di codice Unicode anziché byte? Non sembra, il loro supporto Unicode sembra atrocemente in generale, ma forse mi sono perso qualcosa.
Sundar - Ripristina Monica il

1
Inoltre, il manuale MATL menziona "se l'input è una stringa o una matrice di caratteri" in un paio di punti: sono due cose diverse? Che c'entra qualcosa con le nuove fantasiose stringhe a doppia virgoletta in MATLAB?
Sundar - Ripristina Monica il

1
Matlab ha unicode2native, ma penso che sia quello che vuoi ora. Sono d'accordo, il supporto Unicode in MATLAB non è il migliore. E non iniziare con Octave :-D Per quanto riguarda MATL, è stato progettato prima che esistesse il nuovo tipo di dati stringa in MATLAB (e comunque non mi piace molto), quindi in MATL una "stringa" è la stessa come era nelle vecchie versioni di MATLAB: un vettore di righe di caratteri. Ho preso nota per chiarire che nella documentazione, grazie per averlo notato!
Luis Mendo,

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.