Kiedy dzieci otwierają usta, nie tylko wypluwają bełkot. Mówią w bardzo zaawansowanym, odpornym na dorosłych szyfrach ...

Szyfr Baby-talk

Gdy dziecko mówi, może wyglądać gogooa gagooook aagaaoooy mniej więcej tak: Każda sekcja oddzielona pojedynczymi spacjami reprezentuje postać (więc powyższy przykład reprezentuje 3 znaki).

Aby odszyfrować sekcję, musimy policzyć liczbę zawartych w niej As i Os. Liczymy jednak tylko te, które sąsiadują z inną samogłoską. Na przykład A w „kneblowaniu” nie będzie się liczyło, ale zarówno A, jak i O w „gaogu” byłyby ważne.

Liczenie powyższego przykładu wyglądałoby następująco:

Section    | Num Os | Num As

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

Następnie używamy tych wartości do konwersji danych wejściowych na tekst jawny na kwadracie Polybius. Jest to reprezentacja alfabetu angielskiego w formacie 5x5, z pominięciem „J” (pamiętaj, że w rozmowach dla dzieci obowiązują zasady liczenia 0)

  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

Wykorzystując liczbę Os jako kolumnę i liczbę As jako wiersz, znajdujemy znak, który reprezentuje każda sekcja:

Section    | Num Os | Num As | Character

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

Co mówi nam, że dziecko mówiło „HEJ”.

Uwagi :
- Jeśli sekcja reprezentująca postać ma więcej niż 4 As lub Os, zignoruj ​​dodatki, ponieważ 4 to maksymalna wartość na stole. - W tym zadaniu Y nie jest samogłoską - tylko A, E, I, O i U.

Wyzwanie

Twoim zadaniem jest stworzenie pełnego programu, który pobiera jedno wejście, słowo w języku niemowlęcym i drukuje je w postaci zwykłego tekstu.

• Twój program musi mieć możliwość wprowadzania danych wielkimi i małymi literami oraz ich kombinacji.
• Dane wejściowe będą zawierać tylko litery alfabetu ASCII (AZ i az), z pojedynczymi spacjami, aby oddzielić słowa dziecka.
• Tekst wyjściowy może być w każdym przypadku.
• Powinieneś wziąć dane wejściowe STDINi wydrukować tekst jawny STDOUT. Jeśli twój język ich nie ma, użyj najbliższego odpowiednika.
• To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach - ale każde rozwiązanie jest mile widziane.

Przypadki testowe

'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 bajtów

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

Wypróbuj online!

Objaśnienie w krokach

1. podzielone na spacje, aby utworzyć słowa
2. zamień konsonanty słowami na spacje
3. dziel słowa na spacje, aby utworzyć grupy samogłosek
4. usuń grupy samogłosek o długości mniejszej niż 2
5. uzyskaj min. liczby (a) i 4, pomnóż przez 5
6. uzyskaj min. liczby (o) i 4
7. dodaj liczby
8. uzyskaj literę o tym indeksie alfabetu (z wyjątkiem „j”)

Perl, 82 bajty

Obejmuje +1 dla -a

Podaj dane wejściowe 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

Zakłada się, że jest to dość aktualna wersja perla, jeśli to -asugeruje -n. Jeśli twój perl jest za stary, musisz dodać wyraźną -nopcję.

Zakłada również, że dzieci nie mogą powiedzieć ogólnych ciągów ASCII, które zaczynają się od cyfr takich jak 1 this will not work

pieprzenie mózgu, 656 bajtów

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

To był całkiem dobry sposób na zabicie kilku godzin.

Wymaga interpretera pieprzenia mózgu, który wykorzystuje 8-bitowe zawijanie komórek, pozwala przejść w lewo od komórki 0 i zwraca 0, jeśli ,jest używany, gdy standardowe wejście jest puste. Z mojego doświadczenia są to najczęstsze ustawienia.

Ten program nie uważa Y za samogłoskę, ale jeśli OP tego chce, jest to łatwa poprawka.

Wygląda na to, że napisanie tego byłoby zniechęcającym zadaniem, ale jeśli znasz język, w kodzie nie ma nic zaskakującego ani nowego. Standardowa taktyka: „odczytaj dane wejściowe”, ale pamiętaj, aby zostawić kilka pustych komórek między bajtami, użyj tych pustych komórek do przechowywania danych o danych wejściowych, wykorzystaj zapisane dane, aby zdecydować, jak je przekształcić i wypluć coś na końcu . W tym przypadku uzyskano dane wejściowe, ustawiono je na wielkie litery, ustalono, które komórki są samogłoskami, wyrzucono tę informację po użyciu jej do ustalenia, które komórki znajdują się obok samogłosek, ustawiono wszystko, co nie jest obok samogłoski wartość, która nigdy nie będzie istotna, więc nie przeszkadzają później, a ty w zasadzie skończyłeś. Stamtąd po prostu trzeba liczyć As i Os, należy pomnożyćAs przez 5 i dodaj liczbę Os, specjalny przypadek powyżej 8, aby uniknąć J i wyjścia. Zdecydowałem się poradzić sobie z tym jednym słowem na raz, zamiast brać cały wkład naraz, więc musiałem ustawić część kodu, która odczytuje stdin, by przerwać na 0 lub 32, ale to nie jest zbyt duży problem (po prostu odejmij odejmowanie o 32 w warunkowe, aby nie zdarzyło się, jeśli wartość wynosi już 0, a następnie popraw dowolne <lub >instrukcje, które przegapiłeś później).

Nie wiem, jak bardzo będzie pomocna, ponieważ napisałem ją głównie po to, aby moje myśli były proste, a nie prawdziwe wyjaśnienie, ale oto kod z moimi komentarzami i jego oryginalnymi wcięciami:

+[[>>>,[>++++[<-------->-]]<]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 bajtów

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

Zastępuje każde słowo (i następną spację) odpowiednią literą.

s.split` `.map().join`` ma 3 bajty dłużej:

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 bajtów

+1 bajt dla flagi -n. Białe znaki nie są częścią kodu i służą wyłącznie do odczytu.

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

Kod dzieli dane wejściowe na spacje i konwertuje każde słowo dziecka na małe litery przed kontynuowaniem. Wyrażenie regularne znajduje wszystkie samogłoski a lub o, po których następuje kolejna samogłoska lub poprzedza je samogłoska, i sortuje je, a na początku, o na końcu, a następnie znajduje indeks pierwszego „o”. Jeśli pozostała liczba dopasowań (czyli liczba „a”) jest większa niż 4, wówczas dbamy o 4 a, a jeśli jest więcej niż 4 o, dbamy o 4 o. Następnie wyciąga odpowiednią literę z matrycy i drukuje ją, a następnie przechodzi do następnego słowa dla dziecka.

Brainfuck, 283 bajtów

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

Sformatowany:

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

Działa to z końcowym znakiem nowej linii lub bez niego.

Wypróbuj online.

Każdy znak jest przetwarzany mod 32 (z przepływem sterowania takim, że kod implementujący działanie mod występuje tylko raz w programie). Umożliwia to niewrażliwość na wielkość liter, a także spakowanie znaku spacji i EOF w jeden przypadek. Końcowy znak nowej linii jest traktowany tak samo, jak J, co nie wpływa na wynik.

Szkic układu pamięci:

0 x C c y a A b B

gdzie cjest znakiem wejściowym, Cjest char mod 32, xjest to, czy jest to samogłoska, yczy to, czy poprzedni znak był samogłoską, Ai Bsą to odpowiednio liczby poprawnych (obok samogłosek) ai oznaków aoraz bsą ich odpowiednimi buforami, które zostać skopiowane lub wyczyszczone w zależności od tego, czy istnieje sąsiadująca samogłoska.

Po osiągnięciu spacji lub EOF odbywa się żonglerka w celu zmniejszenia liczby większych niż 4 i pominięcia litery J, a następnie drukowany jest dekodowany znak.

PHP, 163 bajty

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

Bardziej czytelna wersja:

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

Testy:

$ 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 bajtów

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 bajtów dzięki @Joba .
-1 bajt konwertujący z Javy 7 na 8 i 14 16 dodatkowych bajtów zapisanych przez zmianę części do wydruku.

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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

Używa wyrażenia regularnego, aby znaleźć cały ciąg samogłosek większych niż 2, liczy As i Os z maksimum 4, a następnie drukuje.

APL, 60

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

Zauważ, że ⎕IO ← 0 i ⎕ML ← 3

Przykład:

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

Działa w Dyalog 15.0 , ponieważ jest to wersja, w której 819⌶ wprowadzono do małych ciągów znaków.

Pyth, 64 bajty

Prawdopodobnie można dalej grać w golfa. Wypróbuj tutaj!

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

R, 261 bajtów

Myślę, że spędziłem zdecydowanie za dużo czasu, żeby to zadziałać i uważam, że jest to niepotrzebnie skomplikowane rozwiązanie, chociaż działa. Pobiera dane wejściowe ze standardowego wejścia, ważne jest, aby ciąg był ujęty w cudzysłów.

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

Zastosowanie czterech zagnieżdżonych applyrodzin można teoretycznie ograniczyć do zaledwie dwóch, wykorzystując mapplyzamiast tego. Ale ponieważ nakłady na mapplynie będą tej samej długości, krótszy jest poddawany recyklingowi, co komplikuje rzeczy i nie mogłem znaleźć działającego rozwiązania.

Jeśli ktoś jest zainteresowany, dodam później niewyjaśnione wyjaśnienie.

Wypróbuj wszystkie przypadki testowe na skrzypcach R.

Należy pamiętać, że ta wersja pobiera dane wejściowe jako argument funkcji zamiast stdin, ponieważ scannie działa na skrzypcach R. Ponadto dodano nowy wiersz, aby ułatwić czytanie.

Python 3, 262 bajty

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)

Mniej golfa (komentarze to zmienne w skróconym kodzie):

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)

Wypróbuj online!

Kotlin , 221 209 bajtów

Teraz o wiele bardziej brzydkie i wolne, wszystko w imieniu 11 bajtów

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)

Zapisz go w pliku (np. BabyTalk.kts), Aby uruchomić jako skrypt. Lub powyższy kod można uzupełnić fun main(z:Array<String>)=i skompilować normalnie za koszt o 26 bajtów więcej.

Wypróbuj online!

Zębaty:

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 bajtów

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

Pobiera dane wejściowe z argumentów wiersza poleceń. Uruchom -nrlub wypróbuj online .

awaria

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 bajtów

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

Wypróbuj online!