Los residentes de Flapus usan un sistema de números de base 8. Los números son:

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

Para los números superiores a 7, el nombre completo del último dígito viene primero, seguido del apóstrofe y los primeros caracteres del otro dígito, hasta la primera vocal inclusive:

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

A medida que aumentan los números, la fórmula permanece igual: el nombre completo del último dígito es el primero, seguido de un apóstrofe y los primeros caracteres de los otros dígitos, hasta e incluyendo la primera vocal. Tenga en cuenta que, aparte del último dígito (primera palabra), el orden sigue siendo el mismo.

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

La excepción a la regla es para los números que terminan en 0. Aquí la palabra comienza con Ku y se completa con las primeras letras de los otros dígitos, hasta e incluyendo la primera vocal. No se usa apóstrofe.

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

Reto

Escriba un programa o función que acepte un número válido de base 8 y genere el equivalente hablado. Puede suponer que siempre recibirá un número válido. El espacio en blanco final / nueva línea única después de su respuesta está bien. El primer carácter debe estar en mayúscula, como en los ejemplos.

Este es el código de golf . El código más corto en bytes gana. Se aplican lagunas estándar. Las respuestas cuyas longitudes se convierten y se envían adicionalmente en Flapussian obtienen cookies adicionales.

Casos de prueba

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

Transpilado a mano a 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 , Colopee'pokri, 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'

El avance de línea final es significativo.

Pruébalo en línea!

Explicación

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

Comenzamos llevando el dígito final al frente e insertando un apóstrofe después. Tenga en cuenta que esto deja los números de un solo dígito sin cambios, ya que la expresión regular no coincide, por lo que esos nunca obtienen un apóstrofe en primer lugar.

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

Esto reemplaza cada dígito con su nombre completo, independientemente de dónde aparezca.

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

Esto acorta todos los nombres de dígitos que aparecen después de un apóstrofe. Tenga en cuenta que solo las vocales iouaparecen primero en el nombre de un dígito, por lo que verificamos una posición que está justo después de una de ellas, y después de un apóstrofe y luego hacemos coincidir (y eliminar) todas las letras minúsculas que siguen a esa posición. Como hemos insertado los nombres de los dígitos en el caso del título, esto se detendrá antes del siguiente dígito.

T`L`l`'.+

Esto usa la transliteración para convertir todos los caracteres en mayúsculas L, en su contraparte en minúsculas l, siempre que se encuentren en una coincidencia que comience con '(para dejar intacta la capital principal).

zla'

Lo único que queda es manejar correctamente los múltiplos de (octal) 10. En ese caso, tendremos un resultado que comienza con el Kuzla'que queremos comenzar Ku. Entonces simplemente eliminamos todas las ocurrencias 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)

Prueba

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)

Justo cuando pensaba que ya no podía jugar más golf, ¡encontré otros 33 bytes! ¡Muy complacido! Los mayores ahorros fueron al cambiar a matrices de caracteres (más cortas a mayúsculas / minúsculas) y reutilizar la matriz de cadenas de entrada para las palabras.

¡Descubriendo montones de trucos de golf, hasta menos de 400! En teoría, aún podría reducir esto más, ya que dije que una función estaría bien en las reglas, mientras que este es un programa completo.

Actualizado Usando el enfoque de Martin Büttner, refactoré para usar regex en su lugar. ¡Logré guardar otros 10 bytes! Gracias 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);}}

Sin golf

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

Una solución de trabajo con comprensión de listas en 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)

Explicación

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

Ganar 3 bytes con la versión de división (versión anterior: d="Kuzla","Ponara",...)

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

Inicialización del resultado en función del último dígito.

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

Cambie la lista d para mantener los primeros 2 o 3 caracteres y poner en 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)

Ahorré un montón de bytes gracias 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))

Devuelve una función que toma un entero y devuelve su 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))

Tenga cuidado con el uso más sorprendente powque verá en toda su vida. u**v¡es equivalente en el contexto booleano como el u|(not v)que previamente se jugó con la bonita ~v+2|uexpresión!