Riunione

Gli alieni si sono stabiliti sulla terra e stranamente, il loro alfabeto è esattamente uguale al nostro. Anche il loro linguaggio è molto simile al nostro con alcune differenze molto distinte e facili da calcolare.

Sfida

Prendi una stringa e genera l'equivalente nella lingua dell'alieno. La traduzione funziona come tale:

Scambia tutte le vocali nella parola con il corrispondente:

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

_{Puoi anche scrivere un altro traduttore per tradurre Alien> Inglese, tuttavia è facoltativo.}

Esempi

Input: Shaun
Output: Shoboikin

Input: Java
Output: Jobovobo

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

Se la vocale è in maiuscolo, allora si capitalizza la prima lettera.

Input: Alan
Output: Obolobon

Input: Australia
Output: Oboikistroboliniobo

Regole

• Si applicano scappatoie standard
• Deve funzionare per il testo che contiene nuove righe

• Puoi scrivere una funzione, lambda o un programma completo

  Capingrobotikilobotiniapins apin wrinitining thunu runuvunursunu trobonslobotapir!

Haskell, 100 91 byte

(>>= \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 byte

Spero che gli alieni utilizzino i calcolatori TI-83/84;)

Programma principale, 173 byte

BONUS: mantieni la seconda o la terza riga a seconda che tu voglia un traduttore normale 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

Sottoprogramma ( prgmQ), 59 byte:

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

Sottoprogramma ( prgmR), 148 byte:

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 ~rappresenta il token 0x81e @rappresenta il token 0x7F, ulteriori informazioni qui .

PPS Parte del motivo per cui questi programmi hanno un elevato numero di byte è perché sub(, inString(, length(, e tutte le lettere minuscole sono due byte ogni ...

Perl, 56 byte

Include +1 per -p

Dare input su STDIN

alien.pl:

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

Funziona come mostrato, ma sostituisci le \xXXfughe con il personaggio reale per ottenere il punteggio richiesto

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 byte

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

Su ideone.com ...

Abbastanza semplice. Basta prendere l'indice in cui troviamo ciascun personaggio nell'elenco delle vocali e usarlo per estrarre i tre caratteri di cui abbiamo bisogno. Se non viene trovato, .find()restituisce -1quindi attaccare il carattere corrente alla fine della stringa. Gli spazi sono necessari in modo che qualsiasi lettera "a"non includa l'aggiunta c. Le vocali tradotte sono raggruppate per ordine di lettera (la prima lettera di ogni traduzione, quindi la seconda, quindi la terza).

05AB1E , 28 27 20 byte

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

Provalo online!

Unuxplobonobotiniapin

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

PHP, 91 byte

<?=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 byte

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)

Guardalo in esecuzione su ideone.com

Ecco una versione più ben formattata:

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)

Le parti più interessanti sono quelle { ... }.get(l.lower(), l)che cercano di cercare la lettera memorizzata in lminuscole convertite nel dizionario e restituiscono la versione tradotta (se trovata), oppure la lettera originale,
e [str, str.capitalize][ord(l) < 91]( ... )che controlla se la lettera originale era una lettera maiuscola ( Punto di codice ASCII inferiore a 91) e quindi chiama la str()funzione con la lettera come argomento (se non era una lettera maiuscola, non fa nulla) o la str.capitalize()funzione (converte la prima lettera della stringa dell'argomento in maiuscolo).

C (gcc) , 150 141 136 134 byte

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

Provalo online!

Basato sulla risposta di @algmyr e -8 grazie solo a @ ASCII

Versione meno giocata a golf

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

Lotto, 215 byte

@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

Accetta input su STDIN. L'elaborazione carattere per carattere ha la comodità di essere sensibile al maiuscolo / minuscolo.

Pyth, 42 byte

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

Un programma che accetta input su STDIN e stampa l'output.

Provalo online

Come funziona

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

Non volevo davvero rompere l'abitudine di fare sempre le funzioni principali quando codificavo C, ma questo è sostanzialmente più breve della versione con un principale e in questo modo ho avuto un'altra lettera per scrivere ciò che volevo!

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

Commentate

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'è qualcosa di speciale in C e quanto orribile puoi essere con i puntatori e così via.

Retina , 60 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online!

Javascript (ES6), 94 93 92 byte

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

Salvato 1 byte grazie a edc65
Salvato 1 byte grazie a Neil

dimostrazione

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 byte

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

E Alien torna in inglese (171 byte):

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 byte

La stringa da tradurre si trova nella variabile 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 byte

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

Non sono sicuro se è possibile ottenere un programma più breve utilizzando IgnoreCase->Trueinsieme a un controllo del caso.

C 178 byte

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 byte

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 byte

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

Modifica (grazie a milk)

grazie :) In realtà conosco questo sovraccarico ma in qualche modo l'ho completamente dimenticato durante la scrittura di questo ..

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

C, 207 202 byte (grazie 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 omettere il tipo prima di qualsiasi tipo di dichiarazione

2) Non mi piace molto inserire codice inutilizzabile (senza funzione main ())

Uso:

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

Swift 2.2 196 byte

¯ \ _ (ツ) _ / ¯

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 byte

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

Allargato:

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

(nuove righe aggiunte per maggiore chiarezza)

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

Basta cercare le tabelle e un interruttore booleano.

Cerca ogni lettera nella tabella (stringa) di vocali; se trovato, quindi modificarlo secondo la regola nella tabellas . Stampa ogni carattere seguito da una stringa: se viene trovata una vocale, stampa il carattere modificato dal valore in sseguito dal resto della sillaba memorizzata nella tabella f; se non è stata trovata una vocale, stampa il carattere originale e una stringa vuota.

Ruby, 102 93 91 88 78 byte

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

Spiegazione:

Esegui la riga come ruby -pe "gsub(/[#{b='aeiouAEIOU'}]/){'obounuiniapiikiOboUnuIniApiIki'[b.index($&)*3,3]}", tipo successivo, ad esempio,Australia dovrebbe produrre:Oboikistroboliniobo .

È piuttosto semplice, sostituisci tutte le vocali con una sottostringa basata sull'indice della vocale da sostituire in (b), volte 3 e i successivi 3 caratteri nella stringa di traduzione.

TI-BASIC, 201 197 195 byte

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

Pensare che avrei trovato un'altra risposta TI-BASIC qui!

Comunque, l'input è una stringa inglese in Ans .
L'output è la stringa tradotta.

Esempi:

"HE
HE
prgmCDGF1A
HUnu
"Hello
Hello
prgmCDGF1A
Hunullapi

Spiegazione:
(Newline aggiunte per leggibilità. Più righe della stessa riga saranno indicate con un :nel seguente blocco di codice.)

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"

Appunti:

• TI-BASIC è un linguaggio tokenizzato. Il conteggio dei caratteri non equivale al conteggio dei byte.

• Le lettere minuscole in TI-BASIC sono due byte ciascuna.