Lorsque les bébés ouvrent la bouche, ils ne se contentent pas de cracher du charabia. Ils parlent en fait dans un chiffrement très avancé et à l'épreuve des adultes ...

Le chiffre Baby-Talk

Quand un bébé parle, cela pourrait ressembler à quelque chose. gogooa gagooook aagaaoooy Chaque section séparée par un espace représente un caractère (donc l'exemple ci-dessus représente 3 caractères).

Pour déchiffrer une section, nous devons compter le nombre d'As et d'Os qu'elle contient. Cependant, nous ne comptons que ceux qui sont adjacents à une autre voyelle. Par exemple, le A dans «gag» ne compterait pas, mais le A et O dans «gaog» le feraient.

Compter l'exemple ci-dessus ressemblerait à ceci:

Section    | Num Os | Num As

gogooa     | 2      | 1
gagooook   | 4      | 0
aagaaoooy  | 3      | 4

Nous utilisons ensuite ces valeurs pour convertir l'entrée en texte brut sur un carré de Polybe. Il s'agit d'une représentation 5x5 de l'alphabet anglais, en omettant 'J' (veuillez noter que, dans baby-talk, les règles de comptage 0 s'appliquent au tableau):

  0 1 2 3 4
0 A B C D E
1 F G H I K
2 L M N O P
3 Q R S T U
4 V W X Y Z

En utilisant le nombre d'Os comme colonne et le nombre d'As comme ligne, nous trouvons quel caractère chaque section représente:

Section    | Num Os | Num As | Character

gogooa     | 2      | 1      | (2,1) -> H
gagooook   | 4      | 0      | (4,0) -> E
aagaaoooy  | 3      | 4      | (3,4) -> Y

Ce qui nous dit que le bébé venait de dire "HEY".

Remarques :
- Si une section représentant un personnage a plus de 4 As ou Os, ignorez les extras, car 4 est la valeur maximale sur la table. - Pour cette tâche, Y n'est pas une voyelle - seulement A, E, I, O et U.

Le défi

Votre tâche consiste à créer un programme complet qui prend une entrée, un mot en langage bébé et l'imprime en texte clair.

• Votre programme doit être en mesure de saisir des données en majuscules, en minuscules et un mélange des deux.
• L'entrée ne contiendra que des lettres de l'alphabet ASCII (AZ et az), avec des espaces simples pour séparer les mots du bébé.
• Le texte de sortie peut être dans tous les cas.
• Vous devez prendre l'entrée STDINet imprimer le texte en clair STDOUT. Si votre langue n'en possède pas, utilisez l'équivalent le plus proche.
• Il s'agit de code-golf , donc le code le plus court en octets l'emporte - mais toute solution est la bienvenue.

Cas de test

'GLOOG KAKAAOOO ARGOOO OOOOOGUGUU' -> CODE
'oaka pooopaa gaau augu' -> GOLF
'Aoao U oOOAoa oaoAoo aoAoAOa' -> NAPPY
'GUG gAGaA gOougOou' -> ALE
'OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI' -> HELLO

05AB1E , 46 octets

lð¡vyžNvyð:}ð¡D€g1›ÏJ©'a¢4‚W5*®'o¢4‚Ws\+A'j-è?

Essayez-le en ligne!

Explication par étapes

1. diviser les espaces pour former des mots
2. remplacer les konsonants dans les mots par des espaces
3. diviser les mots sur les espaces pour former des groupes de voyelles
4. supprimer les groupes de voyelles d'une longueur inférieure à 2
5. obtenir min de compte (a) et 4, multiplier par 5
6. obtenir min de compte (o) et 4
7. ajouter des comptes
8. obtenir la lettre à cet index de l'alphabet (à l'exception de "j")

Perl, 82 octets

Comprend +1 pour -a

Donnez votre avis sur STDIN:

perl -M5.010 baby.pl <<< "OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI"

baby.pl:

#!/usr/bin/perl -a
say map{$A=$O=$_=uc;y/AEIOU/@/c;s/(\B.|.\B)/$$1+=$$1<4/eg;(A..I,K..Z)[5*$A+$O]}@F

Cela suppose une version suffisamment récente de Perl où cela -aimplique -n. Si votre perl est trop ancien, vous devrez ajouter une -noption explicite .

Cela suppose également que les bébés ne peuvent pas dire des chaînes ASCII générales qui commencent par des chiffres comme 1 this will not work

brainfuck, 656 octets

+[[>>>,[>++++[<-------->-]]<]<<[>]<-[+[<+>>+<-]----[>>+<<----]>>+[<[-<]<[>]>>-]-<[[-]>+<]>[[-[->]<<+>]<->>>]<<<[>>>+<<<-]<<-]>>>>>[[<+>>+<-]----[>-<----]>--[----<]<[>]>[----<]<[>]>[------<]<[>]>[------<]<[>]><+>[[-]<->]>>]<<<[>->]<[<]>[>[<<<<<+>>>>>>+<-]<<<<]<[-]>>>>[<[>[>+<-]<-]>[-]->[<+>-]>>]<<<[-<----[>-<----]>[>+>+<<-]+>[<->[-]<]<[<]>[[<<<]<+>>>>[>>>]<<<-]>+>--------------[<->[-]]<[-<<<<[<<<]>+>>[>>>]>]<<<<]<[<+<+>>-]>++++[<<[->]>[<]>-]+<<[[-]++++<[-]>>]>[<]<<[>+<-]>>+>->[>+>+<<-]<++++[>>[-<]<[>]<-]>>[[-]++++>[-]]<<<[>]<->>>>[<+>-]<[<<<+>>>-]<<<<[>+++++<-]>[>+>+<<-]<++++++++[>>[-<]<[>]<-]>>[[-]>+<]----[>+<----]>++.[-]+>>>,[<++++[>--------<-]]>]

C'était un très bon moyen de tuer quelques heures.

Nécessite un interpréteur brainfuck qui utilise des cellules d'habillage 8 bits, vous permet d'aller à gauche de la cellule 0 et renvoie 0 si ,est utilisé lorsque stdin est vide. D'après mon expérience, ce sont les paramètres les plus courants.

Ce programme ne considère pas Y comme une voyelle, mais si OP le souhaite, c'est une solution facile.

Il semble qu'écrire ceci serait une tâche intimidante mais si vous avez une certaine connaissance de la langue, il n'y a rien de surprenant ou de nouveau dans le code. Tactiques standard de brainfuck: lisez l'entrée mais assurez-vous de laisser quelques cellules vides entre chaque octet, utilisez ces cellules vides pour stocker des données sur l'entrée, utilisez les données que vous avez stockées pour décider comment la transformer et cracher quelque chose à la fin . Dans ce cas, il s'agissait d'obtenir l'entrée, de mettre tout en majuscules, de déterminer quelles cellules sont des voyelles, de jeter ces informations après les avoir utilisées pour déterminer quelles cellules sont à côté des voyelles, de définir tout ce qui n'est pas à côté d'une voyelle pour certains valeur qui ne sera jamais pertinente, donc ils ne vous gêneront pas plus tard, et vous avez essentiellement terminé. De là, il suffit de compter vos As et Os, multipliezAs par 5 et ajoutez le nombre de Os, tout cas spécial supérieur à 8 pour éviter J et la sortie. J'ai choisi de gérer ce mot à la fois, plutôt que de prendre la totalité de l'entrée en même temps, j'ai donc dû configurer la partie du code qui lit stdin pour casser à 0 ou 32, mais ce n'est pas trop gros un problème (juste envelopper la soustraction de 32 dans une condition il ne se produit pas si la valeur est déjà 0, puis corriger tout <ou >instructions que vous avez manqué plus tard).

Je ne sais pas à quel point ce sera utile parce que je l'ai écrit principalement pour garder mes pensées droites plutôt que comme une véritable explication, mais voici le code avec mes commentaires et son indentation d'origine:

+[[>>>,[>++++[<-------->-]]<]get an entire word of input
                            each character lowered by 32
                            two empty cells between characters
                            stops when reaching a space or null byte

any lowercase letters have become uppercase; anything with a value below 65 used
to be an uppercase character; fix it

<<[>]<-[+                for each character until hitting 1:
  [<+>>+<-]              make a backup
  subtract 64 from the character but stop if it hits 0
  ----[>>+<<----]>>+     generate the number 64
  [                      64 times:
    <[                     if the character is not 0:
      -                    subtract 1
      <                    go to a guaranteed 0 cell to break the loop
    ]

    we're either on the character or to the left of it; sync up
    <[>]

  >>-]
  -<[[-]>+<]>            logical NOT of character

  [                      if logical NOT returns true:
    [-[->]<<+>]<-          add 32 to backup of character
  >>>]

  <<<[>>>+<<<-]          move copy over to make room
<<-]
  >>>>>[                 for each character:
  [<+>>+<-]              make copies
  ----[>-<----]>--       check if it's A
  [----<]<[>]>           check if it's E
  [----<]<[>]>           check if it's I
  [------<]<[>]>         check if it's O
  [------<]<[>]>         check if it's U

  IF YOU NEED TO ADD Y; THIS IS THE PLACE

  <+>[[-]<->]            logical NOT to complete vowel check
>>]

<<<[                if the last char is a vowel; prevent a side effect
  >->
]

<[<]>[                 for each character:
  >[                     if it's a vowel:
    <<<<<+>>>>>>+<-          leave a flag to the left and right to show that a
  ]                          vowel is adjacent
<<<<]

<[-]>                  clean up a side effect left behind if first char is vowel

>>>[                   for each char:
  <[                     if it's adjacent to a vowel:
    >[>+<-]<-              move it to the side
  ]
  >[-]-                otherwise; destroy it
  >[<+>-]              move backup over if it exists (subtracting 1)
>>]

all characters without a vowel beside them have been set to 255
all characters with a vowel beside them are set to itself minus 1

notable charaters are: 'A' minus 1 = 64
                       'O' minus 1 = 78

<<<[                 for each character:
  -<----[>-<----]      subtract 64
  >[>+>+<<-]           make a copy
  +>[<->[-]<]<[<]>     logical NOT

  [[<<<]<+>>>>[>>>]<<<-] if NOT returns true; record an A

  >+>--------------  subtract 14 from backup

  [<->[-]]<          logical NOT
  [-<<<<[<<<]>+>>[>>>]>] if NOT returns true; record an O
<<<<]


<[<+<+>>-]           make a backup of A count
>++++[<<[->]>[<]>-]  subtract 4 but don't go below 0
+<<[                   if the char was greater than 3:
  [-]++++<[-]>>          put 4 there
]
>[<]                  resynchronise
<<[>+<-]              if there were fewer than 4 As put the number back

same thing but for the O count

>>+>->[>+>+<<-]       make a backup of O count
<++++[>>[-<]<[>]<-]   subtract 4 but don't go below 0
>>[                     if the char was greater than 3:
  [-]++++>[-]             put 4 there
]
<<<[>]                resynchronise
<->>>>[<+>-]          if there were fewer than 4 Os put the number back

<[<<<+>>>-]<<<<[>+++++<-] A*5 plus B = index of character to output

>[>+>+<<-]            make a backup
<++++++++[>>[-<]<[>]<-] subtract 8 but don't go below 0
>>[[-]>+<]            if the result is nonzero it is late enough in the alphabet
                      that it must be increased by 1 to exclude J as a possible
                      output
----[>+<----]>++      add 65 to make it a letter
.[-]+>>>,             output and get new input
[<++++[>--------<-]]> sub 32 if not 0
]

JavaScript (ES6), 145 octets

alert(prompt().replace(/\S+ ?/g,x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)))

Remplace chaque mot (et l'espace suivant) par sa lettre correspondante.

s.split` `.map().join`` est de 3 octets de plus:

alert(prompt().split` `.map(x=>(g=r=>(q=(x.match(/[aeiou]{2,}/gi)+"").split(r).length-1)>4?4:q,(g(/a/i)*5+g(/o/i)+10)*20/19|0).toString(36)).join``)

Perl, 159 +1 = 160 octets

+1 octet pour l'indicateur -n. Les espaces ne font pas partie du code et ne sont fournis qu'à des fins de lisibilité.

for(split$",lc){
    $b=0;
    @a=sort/([ao](?=[aeiou])|(?<=[aeiou])[ao])/g;
    $b++until$b>$#a||$a[$b]eq o;
    $c=($d=$#a-$b+1)>4?4:$d;
    $b=$b>4?4:$b;
    print+(a..i,k..z)[5*$b+$c];
}

Le code divise l'entrée par des espaces et convertit chaque mot bébé en minuscules avant de continuer. L'expression régulière trouve toutes les voyelles a ou o qui sont suivies par une autre voyelle, ou qui sont précédées par une voyelle, et les trie, un au début, un à la fin, puis trouve l'index du premier `` o ''. Si le nombre de correspondances restantes (aka, le nombre de 'a') est supérieur à 4, alors nous nous soucions de 4 a, et s'il y a plus de 4 o, nous nous soucions de 4 o. Ensuite, il extrait la lettre appropriée de la matrice et l'imprime, puis passe au mot bébé suivant.

Brainfuck, 283 octets

,[[<[>-[>>>-<<<----[----[>+<------[>-<------[<[-]>>>>[-]->>[-]<<<<<-]]]]]>[>>>>+
<<<<-]>>+<[>[>+<-]>>[>+<-]<<<-]<,<<[>>>+<<<-]>]>+[<+>[-<<]>[[-]+++++[<++++++>-]<
+<]>>>]<]>>[-]>+>>+[[-]>[<+>-[<+>-[<+>-[<+>[-]]]]]<<<]>->[>+<-[[>+<-]>>+>]>[+>--
--[->]]]+[-<+]>>+++++++++++++[>+++++<-]>.,]

Formaté:

,
[
  [
    <
    [
      >-
      [
        not a
        >>>-<<<
        ----
        [
          not e
          ----
          [
            not i
            >+<
            ------
            [
              not o
              >-<
              ------
              [
                consonant
                <[-]>
                >>>[-]->>[-]<<<<<-
              ]
            ]
          ]
        ]
      ]
      >[>>>>+<<<<-]> >+<
      [
        prev was vowel
        >[>+<-]>>[>+<-]<<<-
      ]
      <,<<[>>>+<<<-]
      >
    ]
    >+
    [
      <+>[-<<]
      >[[-]+++++[<++++++>-]<+<]
      >>>
    ]
    <
  ]
  >>[-]>+>>+
  [
    [-]
    >[<+>-[<+>-[<+>-[<+>[-]]]]]<
    <<
  ]
  >->
  [
    >+<-
    [
      [>+<-]
      >>+>
    ]
    >
    [
      +>----[->]
    ]
  ]
  +[-<+]
  >>+++++++++++++[>+++++<-]
  >.,
]

Cela fonctionne avec ou sans retour à la ligne dans l'entrée.

Essayez-le en ligne.

Chaque caractère est traité mod 32 (avec un flux de contrôle tel que le code implémentant l'opération mod ne se produit qu'une seule fois dans le programme). Cela permet une insensibilité à la casse, ainsi que de réduire le caractère d'espace et l'EOF en un seul cas. Une nouvelle ligne de fin est traitée de la même manière que J, ce qui n'affecte pas la sortie.

Croquis de la disposition de la mémoire:

0 x C c y a A b B

où cest le caractère d'entrée, Cest le mod de caractère 32, xest-ce qu'il s'agit d'une voyelle, yest-ce que le caractère précédent était une voyelle, Aet Bsont les nombres de valides (à côté des voyelles) aet de ocaractères respectivement, et aet bsont leurs tampons respectifs qui obtenir copié ou effacé selon qu'il existe une voyelle adjacente.

Lorsqu'un espace ou EOF est atteint, certains jonglages sont effectués pour réduire les nombres supérieurs à 4 et pour sauter la lettre J, puis le caractère décodé est imprimé.

PHP, 163 octets

<?php for(;$c=preg_replace('/(?<![AEIOU]).(?![AEIOU])/','',strtoupper($argv[++$i]));$j=min($d[79],4)+5*min($d[65],4),print range(A,Z)[$j+($j>8)])$d=count_chars($c);

Version plus lisible:

<?php
for (
    ;
    $c = preg_replace(
        '/(?<![AEIOU]).(?![AEIOU])/',
        '',
        strtoupper($argv[++$i])
    );
    $j = min($d[79], 4) + 5 * min($d[65], 4),
    print range(A, Z)[$j + ($j > 8)]
)
    $d = count_chars($c);

Tests:

$ php babytalk.php GLOOG KAKAAOOO ARGOOO OOOOOGUGUU
CODE
$ php babytalk.php oaka pooopaa gaau augu
GOLF
$ php babytalk.php Aoao U oOOAoa oaoAoo aoAoAOa
NAPPY
$ php babytalk.php GUG gAGaA gOougOou
ALE
$ php babytalk.php OOaGOG GoGOOoGoU gAA bLAA GOUGoOUgAIGAI
HELLO

Java 8, 272 266 251 249 octets

interface M{static void main(String[]i){String z="(?=[AEIOU])|(?<=[AEIOU])";for(String s:i[0].split(" ")){int a=s.split("(?i)A"+z+"A",-1).length-1,o=s.split("(?i)O"+z+"O",-1).length-1,t=(a>4?4:a)*5+(o>4?4:o);System.out.printf("%c",t>9?t+66:t+65);}}}

-6 octets grâce à @Joba .
-1 octet de conversion de Java 7 à 8, et 14 16 octets supplémentaires enregistrés en changeant la partie d'impression.

Explication:

Essayez-le ici.

interface M{                   // Class:
  static void main(String[]i){ //  Main method:
    String z="(?=[AEIOU])|(?<=[AEIOU])";
                               //   Regex-part for look-ahead or look-behind of vowels
    for(String s:i[0].split(" ")){  
                               //    Loop over the program-arguments
      int a=s.split("(?i)A"+z+"A",-1).length-1,
                               //     The amount of A's with adjacent vowels
          o=s.split("(?i)O"+z+"O",-1).length-1,
                               //     The amount of O's with adjacent vowels
          t=(a>4?4:a)          //     If `a` is larger than 4, just take 4, else take `a`
            *5                 //     Multiply it by 5
            +(o>4?4:o);        //     And add 4 if `o` is larger than 4, else take `o`
       System.out.printf("%c", //     Print a character:
        t>9?                   //      If `t` is larger than 9 (index of J)
         t+66                  //       Take character unicode (skipping J)
        :                      //      Else:
         t+65);                //       Take character unicode (prior to J)
    }                          //   End of loop
  }                            //  End of main-method
}                              // End of program

Python 3, 163 162 157 146 octets

import re
for W in input().upper().split():S=''.join(re.findall("[AEIOU]{2,}",W)).count;I=min(S('A'),4)*5+min(S('O'),4);print(end=chr(65+I+(I>9)))

Utilise l'expression régulière pour trouver toutes les chaînes de voyelles supérieures à 2, compte les As et les Os avec un maximum de 4, puis imprime.

APL, 60

{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶

Notez que ⎕IO ← 0 et ⎕ML ← 3

Exemple:

fn←{⎕A[a+9<a←5⊥+/¨'ao'∊⍨¨⊂⍵/⍨0(,∨,⍨)2∧/⍵∊'aeiou']}¨' '(≠⊂⊢)819⌶
fn 'Aoao U oOOAoa oaoAoo aoAoAOa'
NAPPY

Fonctionne dans Dyalog 15.0 , car c'est la version dans laquelle 819⌶ a été introduit pour mettre une chaîne en minuscules.

Pyth, 64 octets

Peut probablement être joué plus loin. Essayez-le ici!

L?<b5b4DebK+ds:rbZ"[aeiou]{2,}"1J+*/K\a5y/K\oR@G?<J9JhJu+GeHcQd"

R, 261 octets

Je pense que j'ai passé beaucoup trop de temps juste pour que cela fonctionne et je pense que c'est une solution inutilement compliquée, bien que cela fonctionne. Prend l'entrée de stdin, il est important que la chaîne soit placée entre guillemets.

x=el(strsplit(toupper(scan(,""))," "))
cat(apply(sapply(c("A","O"),function(y)sapply(sapply(regmatches(x,gregexpr("[AEIOU]{2,}",x,)),paste,collapse=""),function(s)min(sum(el(strsplit(s,""))%in%y),4)))+1,1,function(z)t(matrix(LETTERS[-10],5))[z[1],z[2]]),sep="")

L'utilisation de quatre applyfamilles imbriquées pourrait théoriquement être réduite à seulement deux en utilisant à la mapplyplace. Mais parce que les entrées mapplyne seront pas de la même longueur, la plus courte est recyclée, ce qui complique les choses et je n'ai pas pu trouver de solution de travail.

Si quelqu'un est intéressé, j'ajouterai une explication non approuvée plus tard.

Essayez tous les cas de test sur R-fiddle

Veuillez noter que cette version prend l'entrée comme argument de fonction à la place de stdin car scanne fonctionne pas sur R-fiddle. De plus, une nouvelle ligne a été ajoutée pour faciliter la lecture.

Python 3, 262 octets

import re;f,b,v,n,r,l,t,g,a,o=re.findall,input().lower(),'aeiou',list(range(26)),'[aeiou]','abcdefghiklmnopqrstuvwxyz','',len,'a','o';del n[9],
for w in b.split():
 O,A=g(f(o+r,w))+g(f(r+o,w)),g(f(a+r,w))+g(f(r+a,w))
 if O>4:O=4
 if A>4:A=4
 t+=l[A*5+O]
print(t)

Moins golfé (Les commentaires sont les variables du code abrégé):

import re
findAll = re.findall #f
babyTalk = input('Baby Talk: ').lower() #b
vowels = 'aeiou' #v
numbers = list(range(26)) #n
del numbers[9]
letters = 'abcdefghiklmnopqrstuvwxyz' #l
finalText = '' #t
length = len #g
regex = '[aeiou]' #r
o = 'o' #o
a = 'a' #a
for word in babyTalk.split(): #w in b
 Os = len(findAll('o[aeiou]', word)) + len(findAll('[aeiou]o', word)) #O
 As = len(findAll('a[aeiou]', word)) + len(findAll('[aeiou]a', word)) #A
 if Os > 4: Os = 4
 if As > 4: As = 4
 print(As, Os)
 finalText += letters[As*5+Os]
 print(finalText)

Essayez-le en ligne!

Kotlin , 221 209 octets

Maintenant beaucoup plus laid et lent, le tout au nom de 11 octets

readLine()!!.toLowerCase().split(" ").map{fun
c(c:Char)=Regex("([aeiou]{2,})").findAll(it).fold(0){a,b->a+b.value.count{it==c}}.let{if(it>4)4 else it}
(('A'..'I')+('K'..'Z'))[c('a')*5+c('o')]}.forEach(::print)

Enregistrez-le dans un fichier (ex. BabyTalk.kts) Pour l'exécuter en tant que script. Ou, le code ci-dessus peut être ajouté fun main(z:Array<String>)=et compilé normalement pour un coût de 26 octets supplémentaires.

Essayez-le en ligne!

Dentelé:

readLine()!!
    .toLowerCase()
    .split(" ")
    .map {
        fun c(c: Char) =
            Regex("([aeiou]{2,})")
                .findAll(it)
                .fold(0) {
                    a, b ->
                    a + b.value.count { it == c }
                }
                .let { if (it > 4) 4 else it }
        (('A'..'I') + ('K'..'Z'))[c('a') * 5 + c('o')]
    }
    .forEach(::print)

PHP, 124129121120125 octets

for(;$s=$argv[++$i];print chr((8<$O+=5*$A)+$O+65))for($k=$A=$O=0;$c=_&$s[$k++];$p=$c)$$c+=$$c<4&!trim($p.$s[$k]&__,AEIOU)[1];

Prend l'entrée des arguments de ligne de commande. Courez avec -nrou essayez-le en ligne .

panne

for(;$s=$argv[++$i];            # loop $s through arguments
    print chr((8<$O+=5*$A)+$O+65)   # 3. map A and O counts to letter, print
)
    for($k=$A=$O=0;                 # 1. reset A and O counters
        $c=$s[$k++]&_;              # 2. loop $c through characters:
        $p=$c)                          # 2. remember current character as previous
        $$c+=                           # 1. increment counter for $c, if ...
            $$c<4&                          # it is < 4 and ...
            !trim($p.$s[$k]&__,AEIOU)[1];   # ... previous or next char is vowel

J , 109 octets

echo{&(u:97+i.26)(+8<[)5#.4<.'AO'+/@e."1 0/~(;@#~1<#@>)@(</.~0+/\@,}.~:&(e.&'AEOUI')}:);._1' ',toupper 1!:1]3

Essayez-le en ligne!