Bebekler ağızlarını açtığında, sadece saçma sapan yaymazlar. Aslında son derece gelişmiş, yetişkinlere uygun bir şifre ile konuşuyorlar ...

Bebek-Konuşma Şifresi

Bir bebek konuştuğunda şöyle görünebilir: gogooa gagooook aagaaoooy Her bir boşlukla ayrılmış bölüm bir karakteri temsil eder (bu nedenle yukarıdaki örnek 3 karakteri temsil eder).

Bir bölümü deşifre etmek için içerdiği As ve Os sayısını saymalıyız. Ancak, sadece başka bir sesli harf bitişik olanları sayarız. Örneğin, 'gag'daki' A sayılmaz, ancak 'gaog'daki' hem A hem de O sayılır.

Yukarıdaki örneği saymak şöyle olacaktır:

Section    | Num Os | Num As

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

Daha sonra bu değerleri girişi bir Polybius karesinde düz metne dönüştürmek için kullanırız. Bu, 'J' işaretini bırakmayan İngilizce alfabenin 5x5'lik bir temsilidir (lütfen, bebek konuşmasında 0 sayım kurallarının masaya uygulandığını unutmayın):

  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

Os sayısını sütun olarak ve satırdaki As sayısını kullanarak her bölümün hangi karakteri temsil ettiğini bulduk:

Section    | Num Os | Num As | Character

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

Hangi bize bebeğin sadece "HEY" dediğini söylüyor

Notlar :
- Bir karakteri temsil eden bölüm 4 As veya Os'tan büyükse, ekstraları dikkate almayın, çünkü 4 tablodaki maksimum değerdir. - Bu görev için, Y ünlü değil - sadece A, E, I, O ve U.

Meydan okuma

Göreviniz bir oluşturmaktır tam bir girdi, bebek konuşmak bir kelime alır programı ve düz metin olarak yazdırır.

• Programınız büyük harf, küçük harf ve her ikisinin bir karışımı olarak girdi alabilmelidir.
• Girdi yalnızca ASCII alfabesinde geçerli olan harfleri (AZ ve az) içerecek, bebek sözcüklerini ayırmak için tek boşluk bırakacaktır.
• Çıktı metni her durumda olabilir.
• Girdiyi almalı STDINve düz metin yazdırmalısınız STDOUT. Dilinizde bu yoksa, en yakın eşdeğeri kullanın.
• Bu kod golf , yani bayttaki en kısa kod kazanır - ancak herhangi bir çözüm memnuniyetle karşılanmaktadır.

Test Kılıfları

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

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

Çevrimiçi deneyin!

Adımlarla açıklama

1. kelimeleri oluşturmak için boşluklara bölmek
2. Kelimelerin yanına kelimelerle boşlukları koymak
3. ünlülerin gruplarını oluşturmak için kelimeleri boşluklara ayırma
4. 2'den kısa uzunluktaki ünlü grupları kaldırın.
5. sayımın (a) ve 4 olması, 5 ile çarpılması
6. sayımın (o) ve 4 olması
7. sayım ekle
8. Alfabenin bu dizinindeki harfi al ("j" hariç)

Perl, 82 bayt

İçin +1 içerir -a

STDIN'e giriş verin:

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

Bu, -aima ettiği yerde yeterince yeni bir perl sürümünü varsayar -n. Perl'iniz çok eskiyse, açık bir -nseçenek eklemeniz gerekir .

Ayrıca, bebeklerin rakam gibi başlayan genel ASCII karakter dizilerini söyleyemediğini varsayar. 1 this will not work

brainfuck, 656 bayt

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

Bu birkaç saat öldürmenin güzel bir yoluydu.

8 bitlik sarma hücreleri kullanan beyin saptırıcı bir tercüman gerektirir, hücre 0'dan sola gitmenize izin verir ve ,stdin boş olduğunda kullanılırsa 0 döndürür . Benim tecrübeme göre, bunlar en yaygın ayarlardır.

Bu program Y'yi sesli olarak düşünmez, ancak eğer OP bunu yapmak isterse kolay bir düzeltmedir.

Bunu yazmak göz korkutucu bir iş olacak gibi gözüküyor, ancak dili iyi bildiğiniz takdirde kodda şaşırtıcı veya yeni bir şey yok. Standart beyin fırtınası taktikleri: Girdiyi okuyun, ancak her bayt arasında birkaç boş hücre bıraktığınızdan, girişle ilgili verileri depolamak için bu boş hücreleri kullanın, sakladığınız verileri nasıl dönüştüreceğinize ve sonunda bir şeyleri tüküreceğinize emin olun . Bu durumda girdiyi aldı, hepsini büyük harfe ayarlayın, hangi hücrelerin ünlü olduğunu anlayın, hangi hücrelerin ünlülerin yanında olduğunu belirlemek için kullandıktan sonra bu bilgiyi atın, bazılarının yanında olmayan her şeyi ayarlayın. Asla alakalı olmayacak değer bu yüzden daha sonra bir şekilde olmazlar ve temelde işiniz biter. Oradan sadece As ve Os saymanız gerekir , çarpınAs'yi 5'e kadar ekleyin ve Os sayısını, J'yi ve çıktısını önlemek için 8'in üzerindeki herhangi bir özel durumu ekleyin . Tüm girişi bir kerede almak yerine, bir kerede bu tek kelimeyle başlamayı seçmiştim, bu yüzden 0 ya da 32'de kırmak için stdin okuyan kodun bir kısmını ayarlamak zorunda kaldım, ama bu çok büyük bir problem değil (değer daha sonra, zaten herhangi için doğru 0 ise o olmaz bu yüzden sadece koşullu içinde 32 tarafından çıkarma sarmak <veya >daha sonra cevapsız talimatlar).

Ne kadar yararlı olacağını bilmiyorum çünkü çoğunlukla düşüncelerimi gerçek bir açıklama yapmak yerine düz tutmak için yazdım, ancak yorumlarımın ve orijinal girintilerinin bulunduğu kod:

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

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

Her sözcüğü (ve sonraki boşluğu) karşılık gelen harfiyle değiştirir.

s.split` `.map().join`` 3 bayt daha uzun:

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 bayt

-N bayrağı için +1 bayt. Boşluk kodun bir parçası değildir ve yalnızca okunabilirlik için sağlanmıştır.

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, girişi boşluklara böler ve devam etmeden önce her bir bebek kelimesini küçük harfe dönüştürür. Regex, başka bir sesli harf tarafından takip edilen veya bir sesli harf tarafından önceden yazılmış tüm sesli harfleri bulur ve bunları sıralar, başlangıçtaki a'ların sonunda o, ilk 'o' indeksini bulur. Kalan eşleşme sayısı (aka, 'a'nın sayısı) 4'ten büyükse, o zaman 4a'ları önemsiyoruz ve 4o'dan fazla olması durumunda, 4'leri önemsiyoruz. Sonra uygun harfi matristen dışarı çeker ve yazdırır, ardından bir sonraki bebek kelimesine geçer.

Brainfuck, 283 bayt

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

biçimlendirilmiş:

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

Bu, girişte izleyen bir yeni satır olsun veya olmasın çalışır.

Çevrimiçi deneyin.

Her karakter mod 32 ile işlenir (kontrol akışı ile mod işlemini gerçekleştiren kod programda yalnızca bir kez gerçekleşir). Bu, boşluk karakterini ve EOF'yi tek bir kutuda daraltmanın yanı sıra büyük / küçük harf duyarlılığını da sağlar. Sondaki yeni satır Jçıktıyı etkilemeyenle aynı şekilde ele alınır .

Bellek düzeninin taslağı:

0 x C c y a A b B

burada cgiriş karakteri olan Ckarakter mod 32'dir, xbir sesli olup olmadığıdır, yönceki karakter bir sesli olarak, olup olmadığı Ave B(bir sonraki sesli için) geçerlidir sayıları olan ave okarakter ve sırasıyla ave bilgili tamponlar olduğu bitişik bir ünlü olup olmadığına bağlı olarak kopyalanır veya silinir.

Bir boşluğa veya EOF'ye ulaşıldığında, 4'ten büyük sayıları azaltmak ve harfi atlamak için bazı hokkabazlık yapılır Jve kodu çözülen karakter yazdırılır.

PHP, 163 bayt

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

Daha okunabilir sürüm:

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

Testler:

$ 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 bayt

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

-Joba sayesinde -6 bayt .
Java 7'den 8'e dönüştürme -1 bayt ve yazdırma kısmını değiştirerek kaydedilen 14 16 ek bayt.

Açıklama:

Burada dene.

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 bayt

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

2'den büyük olan tüm ünlü harfleri bulmak için regex kullanır, As ve Os sayıları en fazla 4 olur ve ardından yazdırılır.

APL, 60

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

←IO ← 0 ve ⎕ML ← 3 olduğuna dikkat edin.

Örnek:

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

Dyalog 15.0'da çalışır , çünkü 819⌶'un bir küçük harften küçük harflerle tanıtılmıştır.

Pyth, 64 bayt

Muhtemelen daha fazla golf oynayabilir. Burada dene!

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

R, 261 bayt

Sanırım bu işe yaraması için çok zaman harcadım ve işe yaramasına rağmen gereksiz yere karmaşık bir çözüm olduğuna inanıyorum. Stdin'den girdi alır, dizginin tırnak içine alınması önemlidir.

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

Dört yuvalanmış applyailenin kullanımı, mapplybunun yerine teorik olarak sadece ikiye indirgenebilir . Ancak girdiler içinmapply aynı uzunlukta olmayacağından, kısa olanı geri dönüştürülür ve bu da işleri karmaşıklaştırır ve çalışan bir çözüm bulamadım.

Eğer ilgilenen varsa, daha sonra açıklanamayan bir açıklama ekleyeceğim.

R-fiddle'daki tüm test vakalarını dene

Lütfen, bu sürümün scanR-fiddle'da çalışmadığı için stdin yerine fonksiyon argümanı olarak girdi aldığını unutmayın . Ayrıca, okumayı kolaylaştırmak için yeni bir satır ekledi.

Python 3, 262 bayt

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)

Daha Az Golf (Yorumlar, kısaltılmış koddaki değişkenlerdir):

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)

Çevrimiçi deneyin!

Kotlin , 221 209 bayt

Şimdi çok daha çirkin ve yavaş, hepsi 11 bayt adına

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)

BabyTalk.ktsKomut dosyası olarak çalıştırmak için bir dosyaya (örn. ) Kaydedin . Veya yukarıdaki kod ile hazırlanabilir.fun main(z:Array<String>)= 26 baytlık bir ücret karşılığında normal olarak hazırlanabilir ve derlenebilir.

Çevrimiçi deneyin!

Girintili'ye:

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 bayt

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

Komut satırı argümanlarından girdi alır. Çevrimiçi olarak çalıştırın -nrveya deneyin .

Yıkmak

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 bayt

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

Çevrimiçi deneyin!