Compte rendu

Les extraterrestres se sont installés sur terre et étrangement, leur alphabet est exactement le même que le nôtre. Leur langage est également très similaire au nôtre avec quelques différences très distinctes et faciles à calculer.

Défi

Prenez une chaîne et sortez l'équivalent de la langue de l'étranger. La traduction fonctionne comme telle:

Échangez toutes les voyelles du mot avec le correspondant:

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

_{Vous pouvez également écrire un autre traducteur pour traduire Alien-> English, ceci est cependant facultatif.}

Exemples

Input: Shaun
Output: Shoboikin

Input: Java
Output: Jobovobo

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

Si la voyelle est en majuscule, vous mettez en majuscule la première lettre.

Input: Alan
Output: Obolobon

Input: Australia
Output: Oboikistroboliniobo

Règles

• Des échappatoires standard s'appliquent
• Doit fonctionner pour le texte qui contient de nouvelles lignes

• Vous pouvez soit écrire une fonction, lambda ou un programme complet

  Capingrobotikilobotiniapins apin wrinitining thunu runuvunursunu trobonslobotapir!

Haskell, 100 91 octets

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

Espérons que les extraterrestres utilisent des calculatrices TI-83/84;)

Programme principal, 173 octets

BONUS: Gardez la deuxième ou la troisième ligne selon que vous souhaitez un traducteur normal ou inversé.

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

Sous-programme ( prgmQ), 59 octets:

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

Sous-programme ( prgmR), 148 octets:

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 ~représente un jeton 0x81et @représente un jeton 0x7F, en savoir plus ici .

Une partie de comptage PPS pourquoi ces programmes ont un octet de poids fort est dû au fait sub(, inString(, length(et toutes les lettres minuscules sont deux octets chacun ...

Perl, 56 octets

Comprend +1 pour -p

Donnez votre avis sur STDIN

alien.pl:

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

Fonctionne comme indiqué, mais remplacez les \xXXéchappements par le personnage réel pour obtenir le score réclamé

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 octets

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

Sur ideone.com ...

Assez simple. Prenez simplement l'index dans lequel nous trouvons chaque caractère dans la liste des voyelles et utilisez-le pour extraire les trois caractères dont nous avons besoin. S'il n'est pas trouvé, .find()renvoie -1donc simplement coller le caractère actuel à la fin de la chaîne. Les espaces sont nécessaires pour que toute lettre "a"n'inclue pas l'ajout c. Les voyelles traduites sont regroupées par ordre alphabétique (la première lettre de chaque traduction, puis la seconde, puis la troisième).

05AB1E , 28 27 20 octets

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

Essayez-le en ligne!

Unuxplobonobotiniapin

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

PHP, 91 octets

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

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)

Découvrez-le sur ideone.com

Voici une version plus joliment formatée:

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)

Les parties les plus intéressantes sont celles { ... }.get(l.lower(), l)qui essaient de rechercher la lettre stockée lconvertie en minuscules dans le dictionnaire et retournent soit la version traduite (si trouvée), soit la lettre d'origine,
et [str, str.capitalize][ord(l) < 91]( ... )qui vérifie si la lettre d'origine était une majuscule ( Point de code ASCII inférieur à 91), puis appelle la str()fonction avec la lettre comme argument (si ce n'était pas une majuscule, ne fait rien) ou la str.capitalize()fonction (convertit la première lettre de la chaîne d'argument en majuscule).

C (gcc) , 150 141 136 134 octets

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

Essayez-le en ligne!

Basé sur la réponse de @algmyr et -8 grâce à @ ASCII uniquement

Version moins golfée

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

Lot, 215 octets

@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

Prend entrée sur STDIN. Le traitement caractère par caractère a l'avantage d'être sensible à la casse.

Pyth, 42 octets

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

Un programme qui prend l'entrée sur STDIN et imprime la sortie.

Essayez-le en ligne

Comment ça fonctionne

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

Je ne voulais vraiment pas rompre avec mon habitude de toujours faire les fonctions principales lors du codage C, mais c'est beaucoup plus court que la version avec un principal et de cette façon j'ai reçu une autre lettre pour épeler ce que je voulais!

Golfé

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

Commenté

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

Il y a quelque chose de spécial à propos de C et à quel point vous pouvez être horrible avec des pointeurs et autres.

Rétine , 60 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Javascript (ES6), 94 93 92 octets

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

1 octet enregistré grâce à edc65
1 octet enregistré grâce à Neil

Démo

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 octets

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

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

Et Alien revient à l'anglais (171 octets):

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

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

La chaîne à traduire se trouve dans 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 octets

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

Je ne sais pas si un programme plus court peut être obtenu en utilisant IgnoreCase->Trueune vérification de cas.

C 178 octets

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 octets

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 octets

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

Modifier (grâce à milk )

merci :) Je connais cette surcharge mais je l'ai complètement oubliée en écrivant ceci ..

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

C, 207 202 octets (merci à 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) Je déteste omettre le type avant tout type de déclarations

2) Je n'aime pas vraiment mettre du code inutilisable (sans fonction main ())

Usage:

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

Swift 2.2 196 octets

¯ \ _ (ツ) _ / ¯

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

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

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

Étendu:

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

(ajout de nouvelles lignes pour plus de clarté)

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

Recherchez simplement des tables et un commutateur booléen.

Recherchez chaque lettre dans le tableau (chaîne) de voyelles; s'il est trouvé, modifiez-le selon la règle du tableau s. Imprime chaque caractère suivi d'une chaîne: si une voyelle a été trouvée, imprime le caractère modifié par la valeur en ssuivi du reste de la syllabe stockée dans le tableau f; si aucune voyelle n'a été trouvée, imprimez le caractère original et une chaîne vide.

Rubis, 102 93 91 88 78 octets

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

Explication:

Exécutez la ligne comme ruby -pe "gsub(/[#{b='aeiouAEIOU'}]/){'obounuiniapiikiOboUnuIniApiIki'[b.index($&)*3,3]}", le type suivant, par exemple, Australiaelle devrait sortir:Oboikistroboliniobo .

C'est assez simple, remplacez toutes les voyelles par une sous-chaîne basée sur l'index de la voyelle à remplacer en (b), 3 fois et les 3 caractères suivants dans la chaîne de traduction.

TI-BASIC, 201 197 195 octets

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

Dire que je trouverais ici une autre réponse TI-BASIC!

Quoi qu'il en soit, l'entrée est une chaîne anglaise Ans.
La sortie est la chaîne traduite.

Exemples:

"HE
HE
prgmCDGF1A
HUnu
"Hello
Hello
prgmCDGF1A
Hunullapi

Explication:
(Ajout de nouvelles lignes pour plus de lisibilité. Plusieurs lignes de la même ligne seront signalées par un :dans le bloc de code suivant.)

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"

Remarques:

• TI-BASIC est un langage tokenisé. Le nombre de caractères n'est pas égal au nombre d'octets.

• Les lettres minuscules de TI-BASIC ont chacune deux octets.