Anweisung

Außerirdische haben sich auf der Erde niedergelassen und seltsamerweise ist ihr Alphabet genau das gleiche wie unseres. Ihre Sprache ist auch unserer sehr ähnlich, mit einigen sehr deutlichen und leicht zu berechnenden Unterschieden.

Herausforderung

Nehmen Sie einen String und geben Sie das Sprachäquivalent des Aliens aus. Die Übersetzung funktioniert so:

Vertausche alle Vokale im Wort mit dem entsprechenden:

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

_{Sie können auch einen anderen Übersetzer schreiben, um Alien-> English zu übersetzen. Dies ist jedoch optional.}

Beispiele

Input: Shaun
Output: Shoboikin

Input: Java
Output: Jobovobo

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

Wenn der Vokal groß geschrieben ist, schreiben Sie den ersten Buchstaben groß.

Input: Alan
Output: Obolobon

Input: Australia
Output: Oboikistroboliniobo

Regeln

• Es gelten Standardlücken
• Muss für Text funktionieren, der neue Zeilen enthält

• Sie können entweder eine Funktion, Lambda oder ein vollständiges Programm schreiben

  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

Hoffentlich benutzen die Aliens TI-83/84-Taschenrechner;)

Hauptprogramm, 173 Bytes

BONUS: Behalten Sie die zweite oder dritte Zeile bei, je nachdem, ob Sie einen normalen oder einen umgekehrten Übersetzer wünschen.

"("+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

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

Unterprogramm ( 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 steht ~für Token 0x81und @stellt Token dar 0x7F, erfahren Sie mehr hier .

PPS Teil , warum diese Programme eine hohe Byteanzahl ist , weil sub(, inString(, length(und alle Kleinbuchstaben je zwei Bytes sind ...

Perl, 56 Bytes

Beinhaltet +1 für -p

Geben Sie eine Eingabe für STDIN ein

alien.pl:

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

Funktioniert wie gezeigt, aber ersetze die \xXXEscapezeichen durch die tatsächlichen Charaktere, um die beanspruchte Punktzahl zu erhalten

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)

Auf ideone.com ...

Ziemlich einfach. Nehmen Sie einfach den Index, bei dem wir jedes Zeichen in der Vokalliste finden, und verwenden Sie ihn, um die drei Zeichen zu ermitteln, die wir benötigen. Wenn es nicht gefunden wird, .find()kehrt -1es zurück , kleben Sie also einfach das aktuelle Zeichen an das Ende der Zeichenfolge. Die Leerzeichen sind erforderlich, damit "a"die hinzugefügten Buchstaben nicht enthalten sind c. Die übersetzten Vokale werden nach Buchstabenreihenfolge gruppiert (der erste Buchstabe jeder Übersetzung, dann der zweite, dann der dritte).

05AB1E , 28 27 20 Bytes

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

Probieren Sie es online!

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)

Sieh es dir auf ideone.com an

Hier ist eine besser formatierte Version:

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)

Die interessantesten Teile sind { ... }.get(l.lower(), l)die, bei denen versucht wird, den in Kleinbuchstaben lkonvertierten gespeicherten Buchstaben im Wörterbuch nachzuschlagen und entweder die übersetzte Version (falls gefunden) oder den Originalbuchstaben zurückzugeben
und zu [str, str.capitalize][ord(l) < 91]( ... )prüfen, ob der Originalbuchstabe ein Großbuchstabe war ( ASCII-Codepunkt kleiner als 91) und ruft dann entweder die str()Funktion mit dem Buchstaben als Argument auf (wenn es kein Großbuchstabe ist, hat dies keine Auswirkung) oder die str.capitalize()Funktion (konvertiert den ersten Buchstaben der Argumentzeichenfolge in Großbuchstaben).

C (gcc) , 150 141 136 134 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;}

Probieren Sie es online!

Basierend auf der Antwort von @algmyr und -8 nur dank @ ASCII

Weniger Golf Version

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

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

Übernimmt die Eingabe für STDIN. Bei der zeichenweisen Verarbeitung wird die Groß- und Kleinschreibung berücksichtigt.

Pyth, 42 Bytes

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

Ein Programm, das die STDIN-Eingabe annimmt und die Ausgabe druckt.

Probieren Sie es online aus

Wie es funktioniert

#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

Ich wollte wirklich nicht meine Gewohnheit aufgeben, beim Codieren von C immer Hauptfunktionen auszuführen, aber dies ist wesentlich kürzer als die Version mit einem Haupt und auf diese Weise bekam ich einen weiteren Buchstaben, der buchstabierte, was ich wollte!

Golf gespielt

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

Kommentiert

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 */
}

C hat etwas Besonderes und wie schrecklich Sie mit Zeigern und dergleichen umgehen können.

Netzhaut , 60 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online!

Javascript (ES6), 94 93 92 Bytes

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

1 Byte dank edc65 gespeichert 1 Byte dank Neil gespeichert

Demo

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

ungolfed:

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

Und Alien zurück zu Englisch (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;}

Ungolfed:

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

Die zu übersetzende Zeichenfolge befindet sich in der Variablen 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"}&

Not sure whether a shorter program can be obtained by using IgnoreCase->True together with a case check.

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

Edit (thanks to milk)

thank you :) I actually know this overload but somehow completely forgot it when writing this..

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

C, 207 202 bytes (thanks to 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) I hate to omit type before any kind of declarations

2) I don't really like to put unusable code (without main() function)

Usage:

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

unGolfed

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

Expanded:

# 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' )
}

Usage:

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

(newlines added for clarity)

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

Just lookup tables and a boolean switch.

Lookup each letter in table (string) of vowels; if found, then modify it according to the rule in table s. Print each character followed by a string: if a vowel was found, print the character modified by the value in s followed by the rest of the syllable stored in table f; if a vowel was not found, print the original character and an empty string.

Ruby, 102 93 91 88 78 bytes

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

Explanation:

Execute the line like ruby -pe "gsub(/[#{b='aeiouAEIOU'}]/){'obounuiniapiikiOboUnuIniApiIki'[b.index($&)*3,3]}", next up type, for example, Australia it should output: Oboikistroboliniobo.

It's pretty straightforward, replace all vowels with a substring based on the index of the to-be replaced vowel in (b), times 3 and the next 3 characters in the translation string.

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

To think that I'd find another TI-BASIC answer here!

Anyway, the input is an English string in Ans.
The output is the translated string.

Examples:

"HE
HE
prgmCDGF1A
HUnu
"Hello
Hello
prgmCDGF1A
Hunullapi

Explanation:
(Newlines added for readability. Multiple lines from the same line will be denoted with a : in the following code block.)

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"

Notes:

• TI-BASIC is a tokenized language. Character count does not equal byte count.

• Lowercase letters in TI-BASIC are two bytes each.