I residenti di Flapus usano un sistema numerico di base 8. I numeri sono:

0 - Kuzla
1 - Ponara
2 - Boqkel
3 - Colopee
4 - Vruenat
5 - Foham
6 - Stikty
7 - Kricola

Per i numeri superiori a 7, viene prima il nome completo dell'ultima cifra, seguito dall'apostrofo e dai primi caratteri dell'altra / e cifra / e, fino alla prima vocale compresa:

11 - Ponara (1) 'po (1)
13 - Colopee (3)' po (1)
64 - Vruenat'sti
55 - Foham'fo
47 - Kricola'vru

Quando i numeri salgono, la formula rimane la stessa: il nome completo dell'ultima cifra viene prima, seguito da un apostrofo e dai primi caratteri delle altre cifre, fino alla prima vocale inclusa. Si noti che a parte la cifra finale (prima parola), l'ordine rimane lo stesso.

123 - Colopee (3) 'po (1) bo (2)
205 - Foham (5)' bo (2) ku (0)
1123 - Colopee'popobo
7654 - Vruenat'kristifo

L'eccezione alla regola è per i numeri che terminano con 0. Qui la parola inizia con Ku e si completa con le prime lettere delle altre cifre, fino alla prima vocale inclusa. Nessun apostrofo viene utilizzato.

10 - Kupo
70 - Kukri
350 - Kucofo
630 - Kustico
1000 - Kupokuku

Sfida

Scrivi un programma o una funzione che accetta un numero base-8 valido e produca l'equivalente parlato. Puoi presumere che riceverai sempre un numero valido. Spazio vuoto finale / nuova riga singola dopo che la tua risposta è ok. Il primo carattere deve essere in maiuscolo, come da esempi.

Questo è code-golf . Vince il codice più breve in byte. Si applicano scappatoie standard. Le risposte le cui lunghezze vengono convertite e inoltre inviate in flapussiano ricevono cookie aggiuntivi.

Casi test

0 -> Kuzla
1 -> Ponara
2 -> Boqkel
3 -> Colopee
4 -> Vruenat
5 -> Foham
6 -> Stikty
7 -> Kricola
10 -> Kupo
11 -> Ponara'po
23 -> Colopee'bo
56 - > Stikty'fo
70 -> Kukri
100 -> Kupoku
222 -> Boqkel'bobo
2345 -> Foham'bocovru

Pyth, 117 byte (Kricola'popo)

Jc"Ku Po Bo Co Vru Fo Sti Kri";K+kc"nara qkel lopee enat ham kty cola";=TsezIszp@JTp@KTp?&T>sz7\'kVPzpr@JsN0;.?"Kuzla

Trascritto a mano in pseudocodice pitonico:

                                           z = input()      # unevaluated, raw
                                           k = ""
Jc"Ku Po Bo Co Vru Fo Sti Kri";            J = "Ku Po...Kri".split()
K+kc"nara qkel lopee enat ham kty cola";   K = k + "nara...cola".split() # k casted to [""]
=Tsez                                      T = int(end(z))  # end(z) means z[-1]
Isz                                        if int(z):
  p@JT                                         print(J[T])
  p@KT                                         print(K[T])
  p?&T>sz7\'k                                  print("'" if T and s > z else k)
  VPz                                          for N in z[:-1]:  # P(z) is z[:-1]
    pr@JsN0                                        print(J[int(N)].lower())
.?                                         else:
  "Kuzla                                       print("Kuzla")

Retina , Colopee'pokri, 165 157 143 127 123 byte

(.+)(.)
$2'$1
0
Kuzla
1
Ponara
2
Boqkel
3
Colopee
4
Vruenat
5
Foham
6
Stikty
7
Kricola
(?<='.*[iou])[a-z]+

T`L`l`'.+
zla'

L'alimentazione di linea finale è significativa.

Provalo online!

Spiegazione

(.+)(.)
$2'$1

Iniziamo portando la cifra finale in primo piano e inserendo un apostrofo dopo di essa. Nota che questo lascia invariati i numeri a una cifra, poiché la regex non corrisponde, quindi quelli non ottengono mai un apostrofo in primo luogo.

0
Kuzla
1
Ponara
2
Boqkel
3
Colopee
4
Vruenat
5
Foham
6
Stikty
7
Kricola

Questo sostituisce ogni cifra con il suo nome completo, indipendentemente da dove appare.

(?<='.*[iou])[a-z]+

Questo accorcia tutti i nomi delle cifre che compaiono dopo un apostrofo. Nota che solo le vocali ioucompaiono per prime nel nome di una cifra, quindi controlliamo una posizione subito dopo una di quelle, e dopo un apostrofo e quindi abbiniamo (e rimuoviamo) tutte le lettere minuscole che seguono quella posizione. Poiché abbiamo inserito i nomi delle cifre nel caso del titolo, questo si fermerà prima della cifra successiva.

T`L`l`'.+

Questo utilizza la traslitterazione per trasformare tutti i caratteri maiuscoli L, nella loro controparte minuscola l, a condizione che vengano trovati in una corrispondenza che inizia con '(al fine di lasciare intatta la capitale principale).

zla'

L'unica cosa che rimane è gestire correttamente i multipli di (ottale) 10. In tal caso, avremo un risultato che inizia con Kuzla', che invece vogliamo iniziare Ku. Quindi rimuoviamo semplicemente tutte le occorrenze di zla'.

JavaScript (ES6), 171

n=>(x='Kuzla Ponara Boqkel Colopee Vruenat Foham Stikty Kricola ku po bo co vru fo sti kri'.split` `,r=x[d=+(n=[...n]).pop()],n.map(d=>r+=x[+d+8],n[0]?r=d?r+"'":'Ku':0),r)

Test

F=n=>(
  x='Kuzla Ponara Boqkel Colopee Vruenat Foham Stikty Kricola ku po bo co vru fo sti kri'.split` `,
  r=x[d=+(n=[...n]).pop()],
  n.map(d=>r+=x[+d+8],n[0]?r=d?r+"'":'Ku':0),
  r
)  


console.log=x=>O.textContent+=x+'\n'

o=''
for(i=0;i<999;i++)
  o+=i.toString(8) +':'+ F(i.toString(8))+(i%8!=7?' ':'\n')
console.log(o)

#O { font-size:12px }

<pre id=O></pre>

Java (1.8) - Vruenat'fobo ( 486 340 byte)

Proprio quando pensavo di non poter più giocare a golf, ho trovato altri 33 byte! Molto soddisfatto! I maggiori risparmi sono stati dal passaggio agli array di caratteri (da breve a maiuscolo / minuscolo) e dal riutilizzo dell'array di stringhe di input per le parole.

Alla scoperta di un sacco di trucchi per il golf, fino a meno di 400! In teoria potrei ancora ridurlo ulteriormente, come ho detto che una funzione sarebbe ok nelle regole, mentre questo è un programma completo.

Aggiornato usando l'approccio di Martin Büttner, mi sono rifatturato per usare invece regex. Gestito per salvare altri 10 byte! Grazie Martin.

interface F{static void main(String[]n){String t="",o,a=n[0];n="Kuzla,Ponara,Boqkel,Colopee,Vruenat,Foham,Stikty,Kricola".split(",");int i=0,l=a.length()-1;char f=a.charAt(l);o=n[f-48]+(l>0?"'":"");while(i<l)t+=n[a.charAt(i++)-48];o+=t.replaceAll("(?<=.*[iou])[a-z]+","").toLowerCase();if(f==48)o=o.replace("zla'","");System.out.print(o);}}

Ungolfed

interface Flapus {
static void main(String[] names) {
    String temp="",out, a = names[0];
    names = "Kuzla,Ponara,Boqkel,Colopee,Vruenat,Foham,Stikty,Kricola".split(",");
    int i=0, last = a.length()-1;
    char lastchar = a.charAt(last);

    out=names[lastchar-48]+(last>0?"'":"");
    while(i<last) {
        temp+=names[a.charAt(i++)-48];
    }
    out+=temp.replaceAll("(?<=.*[iou])[a-z]+", "").toLowerCase();
    if (lastchar==48) {
        out=out.replace("zla'","");
    }
    System.out.print(out);
}
}

Python (3.5) 225 222 217 202 byte

Una soluzione funzionante con comprensione dell'elenco in Python

s=input()
d="Kuzla,Ponara,Boqkel,Colopee,Vruenat,Foham,Stikty,Kricola".split(',')
r=d[int(s[-1])]+"'"if s[-1]!='0'else'Ku'
d=[i[:2+(i[2]in'ui')].lower()for i in d]
for i in s[:-1]:r+=d[int(i)]
print(r)

Spiegazione

d="Kuzla,Ponara,Boqkel,Colopee,Vruenat,Foham,Stikty,Kricola".split(',')

Vinci 3 byte con la versione divisa (versione precedente: d="Kuzla","Ponara",... )

r=d[int(s[-1])]+"'"if s[-1]!='0'else'Ku'

Inizializzazione del risultato in funzione dell'ultima cifra

d=[i[:2+(i[2]in'ui')].lower()for i in d]

Modificare l'elenco d per mantenere i primi 2 o 3 caratteri e metterli in minuscolo

for i in s[:-1]:r+=d[int(i)]

Cat la stringa

Javascript ES6, 231 228 225 222 204 byte

a=[...prompt(c="Kuzla,Ponara,Boqkel,Colopee,Vruenat,Foham,Stikty,Kricola".split`,`)];b=c[a.pop()];a.length?b=b==c[0]?"Ku":b+"'":0;for(;a.length;)b+=c[a.shift()].match(/.+?[iou]/)[0].toLowerCase();alert(b)

Ho salvato un sacco di byte grazie a Neil.

F #, 364 288 250 byte (Kubofo)

let M="Ku-Ponara-Boqkel-Colopee-Vruenat-Foham-Stikty-Kricola".Split '-'
let m="Ku-Po-Bo-Co-Vru-Fo-Sti-Kri".Split '-'
let rec r a=function|0->a|i->r(m.[i%10].ToLower()::a)(i/10)
fun i->String.concat""<|M.[i%10]::((if(i%10)=0 then""else"'")::r[](i/10))

Restituisce una funzione che accetta un numero intero e restituisce il suo equivalente Flapus. = D

Python 3 - 181 177 byte (Ponara'bosti)

a='Ku Po Bo Co Vru Fo Sti Kri zla nara qkel lopee enat ham kty cola'.split()
*y,x=map(int,input())
u=x>0
v=y>[]
print(a[x]+a[x+8]*u**v+"'"*(u&v)+''.join(a[i].lower()for i in y))

Fai attenzione all'uso più straordinario powche avrai mai visto in tutta la tua vita. u**vequivale a un contesto booleano come in u|(not v)precedenza era golfato alla bella ~v+2|uespressione!