Wenn Babys den Mund öffnen, spucken sie nicht nur Kauderwelsch aus. Sie sprechen tatsächlich in einer hochentwickelten, für Erwachsene geeigneten Chiffre ...

Die Baby-Talk-Chiffre

Wenn ein Baby spricht, könnte es ungefähr so ​​aussehen: gogooa gagooook aagaaoooy Jeder durch ein Leerzeichen getrennte Abschnitt steht für ein Zeichen (das obige Beispiel steht also für 3 Zeichen).

Um einen Abschnitt zu entschlüsseln, müssen wir die Anzahl der darin enthaltenen As und Os zählen. Wir zählen jedoch nur diejenigen, die an einen anderen Vokal angrenzen. Zum Beispiel würde das A in "gag" nicht zählen, aber sowohl das A als auch das O in "gaog" würden zählen.

Das obige Beispiel zu zählen würde so aussehen:

Section    | Num Os | Num As

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

Diese Werte verwenden wir dann, um die Eingabe auf einem Polybius-Quadrat in Klartext umzuwandeln. Dies ist eine 5x5-Darstellung des englischen Alphabets ohne 'J'.

  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

Unter Verwendung der Anzahl der Os als Spalte und der Anzahl der As als Zeile finden wir, welches Zeichen jeder Abschnitt darstellt:

Section    | Num Os | Num As | Character

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

Was uns sagt, dass das Baby nur "HEY" sagte.

Hinweise :
- Wenn ein Abschnitt, der ein Zeichen darstellt, mehr als 4 As oder Os hat, ignorieren Sie die Extras, da 4 der Maximalwert in der Tabelle ist. - Für diese Aufgabe ist Y kein Vokal - nur A, E, I, O und U.

Die Herausforderung

Ihre Aufgabe ist es, ein vollständiges Programm zu erstellen , das eine Eingabe, ein Wort im Baby-Sprechen, und es im Klartext druckt.

• Ihr Programm muss in der Lage sein, Eingaben in Groß- und Kleinbuchstaben sowie eine Mischung aus beiden zu verarbeiten.
• Die Eingabe enthält nur ASCII-Alphabetbuchstaben (AZ und az) mit einzelnen Leerzeichen zur Trennung der Babywörter.
• Der Ausgabetext kann in jedem Fall sein.
• Sie sollten die Eingabe übernehmen STDINund den Klartext darauf drucken STDOUT. Wenn Ihre Sprache diese nicht hat, verwenden Sie das nächstgelegene Äquivalent.
• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes - aber jede Lösung ist willkommen.

Testfälle

'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 Bytes

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

Probieren Sie es online!

Erklärung in Schritten

1. Auf Leerzeichen aufteilen, um Wörter zu bilden
2. Ersetzen Sie Konsonanten in Worten durch Leerzeichen
3. Teile Wörter auf Leerzeichen, um Gruppen von Vokalen zu bilden
4. Vokalgruppen mit einer Länge von weniger als 2 entfernen
5. min von count (a) und 4 erhalten, mit 5 multiplizieren
6. Erhalte min of count (o) und 4
7. Zählungen hinzufügen
8. Erhalte Buchstaben an diesem Index des Alphabets (ohne "j")

Perl, 82 Bytes

Beinhaltet +1 für -a

Geben Sie Input auf 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

Dies setzt voraus , eine neu genug Perl - Version , wo -aimpliziert -n. Wenn Ihr Perl zu alt ist, müssen Sie eine explizite -nOption hinzufügen .

Es wird auch davon ausgegangen, dass Babys keine allgemeinen ASCII-Zeichenfolgen sagen können, die mit Ziffern wie beginnen 1 this will not work

Brainfuck, 656 Bytes

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

Dies war ein ziemlich guter Weg, um ein paar Stunden zu töten.

Erfordert einen Brainfuck-Interpreter, der 8-Bit-Umbruchzellen verwendet, es Ihnen ermöglicht, von Zelle 0 nach links zu gehen und 0 zurückzugeben, wenn er verwendet ,wird, wenn stdin leer ist. Nach meiner Erfahrung sind dies die häufigsten Einstellungen.

Dieses Programm betrachtet Y nicht als Vokal, aber wenn OP dies wünscht, ist dies eine einfache Lösung.

Es scheint, als wäre das Schreiben eine entmutigende Aufgabe, aber wenn Sie mit der Sprache vertraut sind, enthält der Code nichts Überraschendes oder Neues. Standard-Brainfuck-Taktik: Lesen Sie die Eingabe, achten Sie jedoch darauf, dass zwischen den einzelnen Bytes ein paar leere Zellen stehen. Speichern Sie Daten zur Eingabe in diesen leeren Zellen. Entscheiden Sie anhand der gespeicherten Daten, wie sie transformiert werden sollen, und spucken Sie am Ende etwas aus . In diesem Fall war es die Eingabe, setzen Sie alles auf Großbuchstaben, finden Sie heraus, welche Zellen Vokale sind, werfen Sie diese Informationen weg, nachdem Sie sie verwendet haben, um festzustellen, welche Zellen sich neben Vokalen befinden, und setzen Sie alles, was sich nicht neben einem Vokal befindet, auf einige Wert, der nie relevant sein wird, sodass er später nicht mehr im Weg steht und Sie im Grunde genommen fertig sind. Von dort aus musst du nur dein As und Os zählen, multiplizierenAs durch 5 und addieren Sie die Anzahl von Os, Sonderfall etwas über 8, um J und Ausgabe zu vermeiden. Ich habe mich dafür entschieden, immer nur ein Wort zu behandeln, anstatt die gesamte Eingabe auf einmal zu verarbeiten. Deshalb musste ich den Teil des Codes, der stdin liest, so einrichten, dass er bei 0 oder 32 abbricht, aber das ist kein allzu großes Problem (Binde die Subtraktion einfach mit 32 in eine Bedingung ein, damit es nicht passiert, wenn der Wert bereits 0 ist, und korrigiere dann alle <oder >Anweisungen, die du später verpasst hast).

Ich weiß nicht, wie hilfreich es sein wird, weil ich es hauptsächlich geschrieben habe, um meine Gedanken zu klären und nicht als echte Erklärung, aber hier ist der Code mit meinen Kommentaren und dem ursprünglichen Einzug:

+[[>>>,[>++++[<-------->-]]<]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 Byte

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

Ersetzt jedes Wort (und das folgende Leerzeichen) durch den entsprechenden Buchstaben.

s.split` `.map().join`` ist 3 Bytes länger:

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 Bytes

+1 Byte für -n Flag. Whitespace ist nicht Teil des Codes und dient nur der Lesbarkeit.

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

Der Code teilt die Eingabe durch Leerzeichen auf und konvertiert jedes Babywort in Kleinbuchstaben, bevor er fortfährt. Der Regex findet alle a- oder o-Vokale, auf die ein anderer Vokal folgt oder denen ein Vokal vorausgeht, und sortiert sie, a am Anfang, o am Ende, und findet dann den Index des ersten 'o'. Wenn die verbleibende Anzahl von Übereinstimmungen (auch bekannt als die Anzahl von 'a's) größer als 4 ist, kümmern wir uns um 4 a's, und wenn es mehr als 4 o's gibt, kümmern wir uns um 4 o's. Dann zieht es den entsprechenden Buchstaben aus der Matrix, druckt ihn aus und geht dann zum nächsten Babywort über.

Brainfuck, 283 Bytes

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

Formatiert:

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

Dies funktioniert mit oder ohne abschließende Newline in der Eingabe.

Probieren Sie es online aus.

Jedes Zeichen wird mod 32 verarbeitet (wobei der Steuerungsfluss so ist, dass der Code, der die Mod-Operation implementiert, nur einmal im Programm vorkommt). Dies ermöglicht die Unterscheidung zwischen Groß- und Kleinschreibung sowie das Zusammenfassen des Leerzeichens und der EOF in einer einzelnen Groß- und Kleinschreibung. Eine abschließende Newline wird wie folgt behandelt J, was sich nicht auf die Ausgabe auswirkt.

Skizze des Speicherlayouts:

0 x C c y a A b B

Wo cist das Eingabezeichen, Cist der Zeichen- Mod 32, xist, ob es ein Vokal ist, yist, ob das vorherige Zeichen ein Vokal war, Aund Bsind die Zählungen von gültigen (neben Vokalen) abzw. oZeichen und aund bsind ihre jeweiligen Puffer, die kopiert oder gelöscht werden, je nachdem, ob ein benachbarter Vokal vorhanden ist.

Wenn ein Leerzeichen oder ein EOF erreicht ist, wird ein Jongliervorgang ausgeführt, um Jdie Anzahl der Zeichen über 4 zu verringern und den Buchstaben zu überspringen. Anschließend wird das dekodierte Zeichen gedruckt.

PHP, 163 Bytes

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

Mehr lesbare Version:

<?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 Bytes

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 Bytes dank @Joba .
-1 Byte Konvertierung von Java 7 nach 8 und 14 16 zusätzliche Bytes, die durch Ändern des Druckteils eingespart werden.

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

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

Verwendet Regex, um alle Zeichenfolgen von Vokalen zu finden, die größer als 2 sind, zählt As und Os mit maximal 4 und druckt dann.

APL, 60

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

Beachten Sie, dass ⎕IO ← 0 und ⎕ML ← 3

Beispiel:

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

Funktioniert in Dyalog 15.0 , da es sich um die Version handelt, in der 819⌶ eingeführt wurde, um Zeichenfolgen in Kleinbuchstaben zu schreiben.

Pyth, 64 Bytes

Kann wohl weiter golfen werden. Probieren Sie es hier aus!

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

R, 261 Bytes

Ich glaube, ich habe viel zu viel Zeit aufgewendet, um dies zum Laufen zu bringen, und ich glaube, dass dies eine unnötig komplizierte Lösung ist, obwohl sie funktioniert. Nimmt Eingaben von stdin entgegen, ist es wichtig, dass die Zeichenfolge in Anführungszeichen eingeschlossen ist.

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="")

Die Verwendung von vier verschachtelten applyFamilien könnte theoretisch auf nur zwei reduziert werden, indem mapplystattdessen verwendet wird. Sondern weil Eingänge zumapply nicht die gleiche Länge haben, wird die kürzere recycelt, was die Sache kompliziert macht und ich konnte keine funktionierende Lösung finden.

Wenn irgendjemand interessiert ist, werde ich später eine Erklärung hinzufügen.

Probieren Sie alle Testfälle auf R-Geige

Bitte beachten Sie, dass diese Version die Eingabe als Funktionsargument von stdin übernimmt, da scandies bei R-Fiddle nicht funktioniert. Außerdem wurde eine neue Zeile hinzugefügt, um das Lesen zu erleichtern.

Python 3, 262 Bytes

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)

Weniger Golf (Die Kommentare sind die Variablen im verkürzten Code):

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)

Probieren Sie es online!

Kotlin , 221 209 Bytes

Jetzt viel hässlicher und langsamer, alles im Namen von 11 Bytes

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)

Speichern Sie es in einer Datei (z. BabyTalk.ktsB.), um es als Skript auszuführen. Der obige Code kann auch vorangestellt fun main(z:Array<String>)=und normal für weitere 26 Byte kompiliert werden.

Probieren Sie es online!

Eingerückt:

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, 124 129 121 120 125 Bytes

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

Übernimmt Eingaben von Befehlszeilenargumenten. Laufen Sie mit -nroder versuchen Sie es online .

Nervenzusammenbruch

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 Bytes

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

Probieren Sie es online!