Instrucciones

Los alienígenas se han asentado en la tierra y, curiosamente, su alfabeto es exactamente el mismo que el nuestro. Su lenguaje también es muy similar al nuestro con algunas diferencias muy distintas y fáciles de calcular.

Desafío

Tome una cadena y emita el equivalente del idioma del alienígena. La traducción funciona como tal:

Intercambia todas las vocales de la palabra con el correspondiente:

  Vowel |   With
--------+--------
   a    |   obo
   e    |   unu
   i    |   ini
   o    |   api
   u    |   iki

_{También puede escribir otro traductor para traducir Alien-> English, sin embargo, esto es opcional.}

Ejemplos

Input: Shaun
Output: Shoboikin

Input: Java
Output: Jobovobo

Input: Hello, World!
Output: Hunullapi, Wapirld!

Si la vocal está en mayúscula, entonces escribe en mayúscula la primera letra.

Input: Alan
Output: Obolobon

Input: Australia
Output: Oboikistroboliniobo

Reglas

• Se aplican lagunas estándar
• Debe funcionar para texto que contiene nuevas líneas

• Puede escribir una función, lambda o un programa completo

  Capingrobotikilobotiniapins apin wrinitining thunu runuvunursunu trobonslobotapir!

Haskell, 100 91 bytes

(>>= \x->last$[x]:[y|(z:y)<-words"aobo eunu iini oapi uiki AObo EUnu IIni OApi UIki",z==x])

TI-Basic, 173 + 59 + 148 = 380 bytes

Esperemos que los extraterrestres usen calculadoras TI-83/84;)

Programa principal, 173 bytes

BONIFICACIÓN: Mantenga la segunda o tercera línea dependiendo de si desea un traductor normal o inverso.

"("+Ans+")→Str1
"@a~obo@A~Obo@e~unu@E~Unu@i~ini@I~Ini@o~api@O~Api@u~iki@U~Iki@→Str2    <-- English to Alien
"@obo~a@Obo~A@unu~e@Unu~E@ini~i@Ini~I@api~o@Api~O@iki~u@Iki~U@→Str2    <-- Alien to English
For(I,2,length(Ans
If "@"=sub(Str2,I-1,1
Then
Str1+"~"+sub(Str2,I,inString(Str2,"@",I)-I
prgmQ
Ans→Str1
End
End

Subprograma ( prgmQ), 59 bytes:

Ans→Str9
inString(Ans,"~
sub(Str9,Ans,length(Str9)-Ans+1→Str8
Str9
prgmR
Repeat Str9=Ans+Str8
Ans+Str8→Str9
prgmR
End

Subprograma ( prgmR), 148 bytes:

Ans→Str0
inString(Ans,"~→Z
inString(Str0,"~",Ans+1→Y
inString(sub(Str0,1,Z-1),sub(Str0,Z+1,Ans-Z-1→X
sub(Str0,1,-1+inString(Str0,"~
If X
sub(Str0,1,X-1)+sub(Str0,Y+1,length(Str0)-Y)+sub(Str0,X+length(sub(Str0,Z+1,Y-Z-1)),Z-X-length(sub(Str0,Z+1,Y-Z-1

PS ~representa token 0x81y @representa token 0x7F, obtenga más información aquí .

PPS parte de por qué estos programas tienen un alto recuento de bytes se debe a que sub(, inString(, length(, y todas las letras minúsculas son dos bytes cada uno ...

Perl, 56 bytes

Incluye +1 para -p

Dar entrada sobre STDIN

alien.pl:

#!/usr/bin/perl -p
s%\w%"`"&$&|("A\x0fboE\x15nuI\x09niO\x01piU\x09ki"=~/\u$&\K.../,$&)%eg

Funciona como se muestra, pero reemplaza los \xXXescapes por el personaje real para obtener el puntaje reclamado

sed 89

s,a,&b\n,gi
s,i,&n\r,gi
s,o,&p\r,gi
s,u,&k\r,gi
s,e,&n\f,gi
y,aeouAEOU\n\r\f,ouaiOUAIoiu,

Python, 99 95 93 bytes

lambda s:"".join(("ouiaiOUIAI bnnpkbnnpk ouiiiouiii"+c)["aeiouAEIOU".find(c)::11] for c in s)

En ideone.com ...

Bastante simple. Simplemente tome el índice en el que encontramos cada carácter en la lista de vocales y úselo para obtener los tres caracteres que necesitamos. Si no se encuentra, .find()regresa , -1así que simplemente pegue el carácter actual al final de la cadena. Los espacios son necesarios para que cualquier letra "a"no incluya el agregado c. Las vocales traducidas se agrupan por orden de letras (la primera letra de cada traducción, luego la segunda, luego la tercera).

05AB1E , 28 27 20 bytes

žÀ.•₅%~≠#ùÛãú•3ôD™«‡

Pruébalo en línea!

Unuxplobonobotiniapin

žÀ                    # the string "aeiouAEIOU"
  .•₅%~≠#ùÛãú•        # the string "obounuiniapiiki"
              3ô      # split in pieces of 3
                D™«   # concatenate with a title-case copy
                   ‡  # transliterate

PHP, 91 bytes

<?=strtr($argv[1],[A=>Obo,E=>Unu,I=>Ini,O=>Api,U=>Iki,a=>obo,e=>unu,i=>ini,o=>api,u=>iki]);

Python, 129 bytes

lambda s:"".join([str,str.capitalize][ord(l)<91]({"a":"obo","e":"unu","i":"ini","o":"api","u":"iki"}.get(l.lower(),l))for l in s)

Véalo en ideone.com

Aquí hay una versión con mejor formato:

lambda s: \
    "".join(
        [str, str.capitalize][ord(l) < 91](
            {"a":"obo", "e":"unu", "i":"ini", "o":"api", "u":"iki"}
            .get(l.lower(), l)
        )
    for l in s)

Las partes más interesantes son las { ... }.get(l.lower(), l)que intentan buscar la letra almacenada en lminúsculas convertidas en el diccionario y devuelve la versión traducida (si se encuentra), o bien la letra original,
y [str, str.capitalize][ord(l) < 91]( ... )que comprueba si la letra original era mayúscula ( Punto de código ASCII inferior a 91) y luego llama a la str()función con la letra como argumento (si no fue una letra mayúscula, no hace nada) o la str.capitalize()función (convierte la primera letra de la cadena del argumento en mayúsculas).

C (gcc) , 150141136134 bytes

a;i;e(char*n){for(char*v=" AEIOUIAI",*t;i=*n++;printf(&a))t=index(v,i-i/96*32),a=t?t-v:0,a=a?v[a+3]|L" 潢畮楮楰楫"[a]<<8|i&32:i;}

Pruébalo en línea!

Basado en la respuesta de @algmyr y -8 gracias a @ ASCII-only

Versión menos golfizada

a;i;
e(char*n){
  for(char*v=" AEIOUIAI",*t;i=*n++;printf(&a))
    t=index(v,i-i/96*32),
    a=t?t-v:0,
    a=a?v[a+3]|L" 潢畮楮楰楫"[a]<<8|i&32:i;
}

Lote, 215 bytes

@echo off
set/pt=
set s=
:l
if "%t%"=="" echo(%s%&exit/b
set c=%t:~0,1%
for %%a in (obo.a unu.e ini.i api.o iki.u Obo.A Unu.E Ini.I Api.O Iki.U)do if .%c%==%%~xa set c=%%~na
set s=%s%%c%
set t=%t:~1%
goto l

Toma entrada en STDIN. El procesamiento carácter por carácter tiene la conveniencia de ser sensible a mayúsculas y minúsculas.

Pyth, 42 bytes

#sXw"aeiouAEIOU"+Jc"obounuiniapiiki"3mrd3J

Un programa que toma entrada en STDIN e imprime la salida.

Pruébalo en línea

Cómo funciona

#sXw"aeiouAEIOU"+Jc"obounuiniapiiki"3mrd3J  Program.
#                                           Loop until error statement:
   w                                         Get w, the next line of the input
                   "obounuiniapiiki"         Yield string literal "obounuiniapiiki"
                  c                 3        Split that into groups of three characters
                 J                           Assign that to J and yield J
                                     mrd3J   Map title case over J
                +                            Merge the lower and title groups
    "aeiouAEIOU"                             Yield string literal "aeiouAEIOU"
  X                                          Translate w from that to the three-character
                                             groups
 s                                           Concatenate that
                                             Implicitly print

C, 167 bytes

Realmente no quería romper mi hábito de hacer siempre las funciones principales al codificar C, pero esto es sustancialmente más corto que la versión con un principal y de esta manera obtuve otra letra para deletrear lo que quería.

Golfed

a;l;i;e(char*n){for(;i=*n++;l=i>90,i-=32*l,a=!(i-65)+2*!(i-69)+3*!(i-73)+4*!(i-79)+5*!(i-85),printf(a?"%c%c%c":"%c",(a?"HOUIAI"[a]:i)+l*32,"ibnnpk"[a],"!ouiii"[a]));}

Comentado

a;l;i;
e(char*n)
{
    for(;
        i = *n++;  /* Get char and advance */
        l = i>90,  /* Is lowercase? */
        i -= 32*l, /* Make uppercase */

        /* Is 1,2,3,4,5 depeding on the vowel and 0 for no vowel */
        a = !(i-65) + 2*!(i-69) + 3*!(i-73) + 4*!(i-79) + 5*!(i-85),

        printf(a?"%c%c%c":"%c",        /* Print 1 or 3 chars? */
               (a?"HOUIAI"[a]:i)+l*32, /* Print appropriate char+case */
                  "ibnnpk"[a],            /* Print appropriate char */
                  "!ouiii"[a]));          /* Print appropriate char */
}

Hay algo especial sobre C y lo horrible que puede ser con punteros y demás.

Retina , 60 bytes

El recuento de bytes asume la codificación ISO 8859-1.

[A-Z]
»$&
T`L`l
i
ini
u
iki
e
unu
a
·b·
o
api
·
o
T`»l`_L`».

Pruébalo en línea!

Javascript (ES6), 94 93 92 bytes

s=>s.replace(/[aeiou]/gi,c=>"OUIAIouiai"[n="AEIOUaeiou".search(c)]+"bnnpk"[n%=5]+"ouiii"[n])

Guardado 1 byte gracias a edc65
Guardado 1 byte gracias a Neil

Manifestación

let f =
s=>s.replace(/[aeiou]/gi,c=>"OUIAIouiai"[n="AEIOUaeiou".search(c)]+"bnnpk"[n%=5]+"ouiii"[n])

function translate() {
  document.getElementById("o").value = f(document.getElementById("i").value);
}
translate();

<input id="i" size=80 oninput="translate()" value="Hello, World!"><br><input id="o" size=80 disabled>

Java 8, 172 bytes

String f(String s){String v="AEIOUaeiou",r="OboUnuIniApiIkiobounuiniapiiki",o="";for(char c:s.toCharArray()){int n=v.indexOf(c);o+=n>-1?r.substring(n*3,n*3+3):c;}return o;}

sin golf:

String f(String s){
    String v="AEIOUaeiou",r="OboUnuIniApiIkiobounuiniapiiki",o="";
    for(char c:s.toCharArray()){
        int n=v.indexOf(c);
        o+=n>-1?r.substring(n*3,n*3+3):c;
    }
    return o;
}

Y Alien vuelve al inglés (171 bytes):

String g(String s){String[] v="AEIOUaeiou".split(""),r="Obo Unu Ini Api Iki obo unu ini api iki".split(" ");for(int i=0;i<v.length;i++)s=s.replaceAll(r[i],v[i]);return s;}

Sin golf:

String g(String s){
    String[] v="AEIOUaeiou".split(""),r="Obo Unu Ini Api Iki obo unu ini api iki".split(" ");
    for(int i=0;i<v.length;i++)s=s.replaceAll(r[i],v[i]);
    return s;
}

Tcl, 75 bytes

La cadena a traducir está en la variable s.

string map {A Obo a obo E Unu e unu I Ini i ini O Api o api U Iki u iki} $s

Mathematica, 128 bytes

#~StringReplace~{"a"->"obo","A"->"Obo","e"->"unu","E"->"Unu","i"->"ini","I"->"Ini","o"->"api","O"->"Api","u"->"iki","U"->"Iki"}&

No estoy seguro de si se puede obtener un programa más corto al usarlo IgnoreCase->Truejunto con una verificación de casos.

C 178 bytes

char*p[256],*a="obo\0unu\0ini\0api\0iki\0Obo\0Unu\0Ini\0Api\0Iki",*b="aeiouAEIOU";main(c){for(c=0;b[c];++c)p[b[c]]=a+4*c;for(;(c=getchar())>0;)p[c]?printf("%s",p[c]):putchar(c);}

C, 163 162 159 bytes

char*t="aeiou";n,k;q(char*x){for(;*x;n<0||(*x=t[n>1?n%2?0:2:n+3])&&k>90||(*x-=32),printf("%c%.2s",*x++,n<0?"":&"bonunipiki"[2*n]))n=strchr(t,tolower(k=*x))-t;}

C #, 133 121 bytes

s=>{int i;return string.Concat(s.Select(c=>(i ="AIUEOaiueo".IndexOf(c))>-1?"OboIniIkiUnuApioboiniikiunuapi".Substring(i*3,3):c+""));}

Editar (gracias a milk)

gracias :) En realidad conozco esta sobrecarga, pero de alguna manera la olvidé por completo al escribir esto ...

s=>string.Concat(s.Select((c,i)=>(i="AIUEOaiueo".IndexOf(c))>-1?"OboIniIkiUnuApioboiniikiunuapi".Substring(i*3,3):c+""));

C, 207 202 bytes (gracias a Cyoce)

#include <stdio.h>
#define r(c,t) case c:printf(t);continue;
int main(){int c;while(~(c=getchar())){switch(c){r('a',"obo")r('e',"unu")r('i',"ini")r('o',"api")r('u',"iki")default:putchar(c);}}return 0;}

1) Odio omitir el tipo antes de cualquier tipo de declaraciones

2) Realmente no me gusta poner código inutilizable (sin la función main ())

Uso:

c89 cg.c -o cg; echo "Testing" | ./cg

Swift 2.2 196 bytes

¯ \ _ (ツ) _ / ¯

Golfed

var r = ["a":"obo","e":"unu","i":"ini","o":"api","u":"iki"];var q={(s:String) in var o = "";for var i in s.lowercaseString.characters{o += r[String(i)] != nil ? r[String(i)]!:String(i)};print(o);}

sin golf

var r = ["a":"obo","e":"unu","i":"ini","o":"api","u":"iki"]
var q={(s:String) in
    var o = ""
    for var i in s.lowercaseString.characters {
        o += r[String(i)] != nil ? r[String(i)]!:String(i)
    }
    print(o)
}

Perl 6 ,  84  82 bytes

{my%o=<a obo e unu i ini o api u iki>;S:i:g[<{%o.keys}>]=%o{$/.lc}.samecase($/~'a')}

{my%o=<a obo e unu i ini o api u iki>;S:i:g[<[aeiou]>]=%o{$/.lc}.samecase($/~'a')}

Expandido:

# bare block lambda with implicit parameter ｢$_｣
{
  # create the mapping
  my %v = <a obo e unu i ini o api u iki>;

  # replace vowels in ｢$_｣
  S
    :ignorecase
    :global
  [
    <[aeiou]>
  ]

  = # replace them with:

  %v{ $/.lc }
  # change it to be the same case as what was matched, and a lowercase letter
  .samecase( $/ ~ 'a' )
}

Uso:

my &english-to-alien = {my%o=<a obo e unu i ini o api u iki>;S:i:g[<[aeiou]>]=%o{$/.lc}.samecase($/~'a')}

say english-to-alien 'Australia'; # Oboikistroboliniobo

C - 192 bytes

(nuevas líneas agregadas para mayor claridad)

int c,j,b;main(){
char*f[]={"bo","nu","ni","pi","ki",""},
s[]={14,16,0,-14,-12};
while(c=getchar()){for(b=j=0;j<10;++j)
{if(c=="aeiouAEIOU"[j]){c+=s[j%=5];b=1;break;}}
printf("%c%s",c,f[b?j:5]);}}

Simplemente busque tablas y un interruptor booleano.

Busque cada letra en la tabla (cadena) de vocales; si se encuentra, modifíquelo según la regla de la tabla s. Imprima cada carácter seguido de una cadena: si se encuentra una vocal, imprima el carácter modificado por el valor sseguido del resto de la sílaba almacenada en la tabla f; Si no se encuentra una vocal, imprima el carácter original y una cadena vacía.

Ruby, 102 93 91 88 78 bytes

gsub(/[#{b='aeiouAEIOU'}]/){'obounuiniapiikiOboUnuIniApiIki'[b.index($&)*3,3]}

Explicación:

Ejecutar la línea como ruby -pe "gsub(/[#{b='aeiouAEIOU'}]/){'obounuiniapiikiOboUnuIniApiIki'[b.index($&)*3,3]}", hasta el próximo tipo, por ejemplo, Australiaque la Salida: Oboikistroboliniobo.

Es bastante sencillo, reemplace todas las vocales con una subcadena basada en el índice de la vocal que se va a reemplazar en (b), multiplicado por 3 y los siguientes 3 caracteres en la cadena de traducción.

TI-BASIC, 201 197 195 bytes

Ans+" →Str1:"AEIOUaeiou→Str2:"OUIAIouiai→Str3:"bonunipiki→Str4:1→X:While X<length(Str1:inString(Str2,sub(Str1,X,1→A:5fPart(.2A→B:If A:sub(Str1,1,X-1)+sub(Str3,A,1)+sub(Str4,2B-1,2)+sub(Str1,X+1,length(Str1)-X→Str1:X+1+2(A>0→X:End:sub(Str1,1,length(Str1)-1

¡Pensar que encontraría otra respuesta TI-BASIC aquí!

De todos modos, la entrada es una cadena en inglés Ans.
La salida es la cadena traducida.

Ejemplos:

"HE
HE
prgmCDGF1A
HUnu
"Hello
Hello
prgmCDGF1A
Hunullapi

Explicación:
(Se agregaron nuevas líneas para facilitar la lectura. Múltiples líneas de la misma línea se denotarán con un :en el siguiente bloque de código).

Ans+" →Str1                     ;append a space to the input string and store the result
                                ; in "Str1"
"AEIOUaeiou→Str2                ;store the upper- and lowercase vowels in "Str2"
"OUIAIouiai→Str3                ;store the beginning letter of each corresponding translated
                                ; vowel in "Str3"
"bonunipiki→Str4                ;store the remaining letters of each translated vowel
                                ; in "Str4"
1→X                             ;store 1 in "X"
While X<length(Str1             ;loop until all English letters have been checked
inString(Str2,sub(Str1,X,1→A    ;get the current letter and store its index in "Str2"
                                ; into "A"
5fPart(.2A→B                    ;get which translated vowel end should be used
                                ; B ranges from 1 to 5
If A                            ;if the current letter is a vowel
sub(Str1,1,X-1)                 ;extract the substring of the input before the
                                ; current letter
: +sub(Str3,A,1)                ;append the translated vowel start
: +sub(Str4,2B-1,2)             ;append the translated vowel end
: +sub(Str1,X+1,length(Str1)-X  ;append the remaining substring of the input
: →Str1                         ;store the result of these concatenations into "Str1"
X+1+2(A>0→X                     ;check if A>0 (if the current letter was a vowel)
                                ; if true, increment "X" by three
                                ; if false, increment "X" by one
End
sub(Str1,1,length(Str1)-1       ;remove the trailing space and store the result in "Ans"
                                ;implicit print of "Ans"

Notas:

• TI-BASIC es un lenguaje tokenizado. El recuento de caracteres no es igual al recuento de bytes.

• Las letras minúsculas en TI-BASIC son de dos bytes cada una.