Os moradores de Flapus usam um sistema numérico de base 8. Os números são:

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

Para números acima de 7, o nome completo do último dígito é o primeiro, seguido pelo apóstrofo e os primeiros caracteres do (s) outro (s) dígito (s), até e incluindo a primeira vogal:

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

À medida que os números aumentam, a fórmula permanece a mesma - o nome completo, último dígito, é o primeiro, seguido de um apóstrofo e os primeiros caracteres dos outros dígitos, incluindo a primeira vogal. Observe que, além do dígito final (primeira palavra), a ordem permanece a mesma.

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

A exceção à regra é para números que terminam em 0. Aqui a palavra começa com Ku e é completada com as primeiras letras dos outros dígitos, até e incluindo a primeira vogal. Nenhum apóstrofo é usado.

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

Desafio

Escreva um programa ou função que aceite um número base-8 válido e produz o equivalente falado. Você pode assumir que sempre receberá um número válido. Espaço em branco à direita / nova linha após sua resposta estar correta. O primeiro caractere precisa estar em maiúsculas, conforme exemplos.

Isso é código-golfe . O menor código em bytes vence. Aplicam-se brechas padrão. As respostas cujos comprimentos são convertidos e enviados adicionalmente em flapussiano recebem cookies extras.

Casos de teste

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

Pitão, 117 bytes (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

Transpilados manualmente para pseudocódigo pitônico:

                                           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 , Colópico, 165 157 143 127 123 bytes

(.+)(.)
$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'

O avanço de linha à direita é significativo.

Experimente online!

Explicação

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

Começamos trazendo o dígito final para a frente e inserindo um apóstrofo depois dele. Observe que isso mantém os números de um dígito inalterados, pois a regex não corresponde - portanto, esses nunca recebem um apóstrofo em primeiro lugar.

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

Isso substitui cada dígito pelo seu nome completo, independentemente de onde ele aparece.

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

Isso reduz todos os nomes de dígitos que aparecem após um apóstrofo. Observe que apenas as vogais iouaparecem primeiro no nome de um dígito; portanto, verificamos uma posição logo após uma delas e depois de um apóstrofo e, em seguida, combinamos (e removemos) todas as letras minúsculas que seguem essa posição. Como inserimos os nomes dos dígitos na caixa do título, isso será interrompido antes do próximo dígito.

T`L`l`'.+

Isso usa a transliteração para transformar todos os caracteres maiúsculos L, em letras minúsculas l, desde que sejam encontrados em uma correspondência que começa com '(para deixar o capital principal intocado).

zla'

A única coisa que resta é lidar corretamente com múltiplos de (octal) 10. Nesse caso, teremos um resultado começando com o Kuzla'qual queremos começar Ku. Então, simplesmente removemos todas as ocorrências de 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)

Teste

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 bytes)

Quando pensei que não poderia mais jogar golfe, encontrei outros 33 bytes! Muito satisfeito! As maiores economias foram de mudar para matrizes de caracteres (mais curtas para maiúsculas / minúsculas) e reutilizar a matriz de strings de entrada para as palavras.

Descobrindo um monte de truques de golfe, abaixo de 400! Em teoria, eu ainda poderia reduzir mais isso, pois eu disse que uma função estaria bem nas regras, enquanto este é um programa completo.

Atualizado Usando a abordagem de Martin Büttner, refatorei o uso de regex. Conseguiu salvar outros 10 bytes! Obrigado 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 bytes

Uma solução funcional com compreensão de lista em 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)

Explicação

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

Ganhe 3 bytes com a versão dividida (versão anterior: d="Kuzla","Ponara",... )

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

Inicialização do resultado em função do último dígito

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

Altere a lista d para manter os 2 ou 3 primeiros caracteres e coloque em minúsculas

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

Cat the string

Javascript ES6, 231 228 225 222 204 bytes

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)

Economizou um monte de bytes graças a Neil.

F #, 364 288 250 bytes (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))

Retorna uma função que recebe um número inteiro e retorna seu equivalente Flapus. = D

Python 3 - 181 177 bytes (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))

Cuidado com o uso mais incrível que powvocê já viu em toda a sua vida. u**vé equivalente no contexto booleano, como u|(not v)anteriormente foi jogado com a bela ~v+2|uexpressão!