Ketika bayi membuka mulut mereka, mereka tidak hanya memuntahkan omong kosong. Mereka benar-benar berbicara dengan sandi yang sangat canggih, bukti dewasa ...

The Baby-talk Cipher

Ketika seorang bayi berbicara, itu bisa terlihat seperti gogooa gagooook aagaaoooy Setiap bagian yang dipisahkan satu ruang mewakili karakter (jadi contoh di atas mewakili 3 karakter).

Untuk menguraikan suatu bagian, kita harus menghitung jumlah As dan Os yang dikandungnya. Namun, kami hanya menghitung yang berdekatan dengan vokal lainnya. Misalnya, A di 'gag' tidak akan dihitung, tetapi A dan O di 'gaog' akan dihitung.

Menghitung contoh di atas akan terlihat seperti ini:

Section    | Num Os | Num As

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

Kami kemudian menggunakan nilai-nilai ini untuk mengubah input menjadi plaintext pada kotak Polybius. Ini adalah representasi 5x5 dari alfabet bahasa Inggris, menghilangkan 'J' (harap dicatat bahwa, dalam baby-talk, aturan penghitungan 0 berlaku untuk tabel):

  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

Dengan menggunakan jumlah O sebagai kolom, dan jumlah As sebagai baris, kami menemukan karakter yang mewakili setiap bagian:

Section    | Num Os | Num As | Character

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

Yang memberitahu kita bahwa bayi itu baru saja mengatakan "HEY".

Catatan :
- Jika bagian yang mewakili karakter memiliki lebih dari 4 As atau Os, abaikan ekstra, karena 4 adalah nilai maksimum pada tabel. - Untuk tugas ini, Y bukan vokal - hanya A, E, I, O dan U.

Tantangan

Tugas Anda adalah membuat program lengkap yang mengambil satu input, sebuah kata dalam bahasa bayi, dan mencetaknya dalam plaintext.

• Program Anda harus dapat mengambil input dalam huruf besar, huruf kecil, dan campuran keduanya.
• Input hanya akan berisi huruf alfabet ASCII (AZ dan az), dengan spasi tunggal untuk memisahkan kata-kata bayi.
• Teks keluaran bisa dalam hal apa pun.
• Anda harus mengambil input dari STDINdan mencetak plaintext STDOUT. Jika bahasa Anda tidak memiliki ini, gunakan yang setara terdekat.
• Ini adalah kode-golf , jadi kode terpendek dalam byte menang - tetapi semua solusi diterima.

Uji Kasus

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

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

Cobalah online!

Penjelasan dalam langkah-langkah

1. berpisah pada spasi untuk membentuk kata-kata
2. ganti konsonan dalam kata-kata dengan spasi
3. pisahkan kata pada spasi untuk membentuk grup vokal
4. hapus grup vokal dengan panjang lebih pendek dari 2
5. dapatkan min of count (a) dan 4, kalikan dengan 5
6. dapatkan min of count (o) dan 4
7. tambahkan jumlah
8. dapatkan huruf di indeks alfabet itu (tidak termasuk "j")

Perl, 82 byte

Termasuk +1 untuk -a

Berikan masukan pada 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

Ini mengasumsikan versi perl cukup baru di mana -amenyiratkan -n. Jika perl Anda terlalu tua, Anda perlu menambahkan -nopsi eksplisit .

Ini juga mengasumsikan bayi tidak bisa mengatakan string ASCII umum yang dimulai dengan angka seperti 1 this will not work

brainfuck, 656 byte

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

Ini adalah cara yang cukup bagus untuk membunuh beberapa jam.

Membutuhkan juru bahasa brainfuck yang menggunakan sel pembungkus 8-bit, memungkinkan Anda untuk belok kiri dari sel 0 dan mengembalikan 0 jika ,digunakan ketika stdin kosong. Dalam pengalaman saya, ini adalah pengaturan yang paling umum.

Program ini tidak menganggap Y sebagai vokal, tetapi jika OP menginginkannya, ini adalah perbaikan yang mudah.

Sepertinya menulis ini akan menjadi tugas yang menakutkan tetapi jika Anda memiliki keakraban dengan bahasa tidak ada yang mengejutkan atau baru dalam kode. Taktik brainfuck standar: Baca input tetapi pastikan Anda meninggalkan beberapa sel kosong di antara setiap byte, gunakan sel-sel kosong itu untuk menyimpan data tentang input, gunakan data yang Anda simpan untuk memutuskan cara mentransformasikannya dan mengeluarkan sesuatu di akhir . Dalam hal ini mendapatkan input, mengatur semuanya menjadi huruf besar, mencari tahu sel mana yang vokal, membuang informasi itu setelah menggunakannya untuk menentukan sel mana yang di sebelah vokal, atur semua yang tidak di sebelah vokal ke beberapa nilai yang tidak akan pernah relevan sehingga mereka tidak menghalangi nanti, dan Anda pada dasarnya sudah selesai. Dari sana Anda hanya perlu menghitung Anda Adan O, gandakanAs dengan 5 dan tambahkan Os, kasus khusus apa pun di atas 8 untuk menghindari J dan output. Saya memang memilih untuk menangani kata ini satu per satu, daripada mengambil seluruh input sekaligus, jadi saya harus mengatur bagian dari kode yang bertuliskan stdin untuk dipecahkan pada 0 atau 32, tetapi itu bukan masalah yang terlalu besar (cukup bungkus pengurangan dengan 32 dalam kondisi sehingga tidak terjadi jika nilainya sudah 0, lalu koreksi untuk setiap <atau >instruksi yang Anda lewatkan kemudian).

Saya tidak tahu bagaimana itu akan membantu karena saya menulisnya sebagian besar untuk menjaga pikiran saya tetap lurus daripada sebagai penjelasan yang nyata, tapi inilah kode dengan komentar saya dan lekukan aslinya:

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

Ganti setiap kata (dan spasi berikut) dengan huruf yang sesuai.

s.split` `.map().join`` lebih panjang 3 byte:

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 byte

+1 byte untuk flag -n. Spasi bukan bagian dari kode dan hanya disediakan untuk keterbacaan.

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

Kode membagi input dengan spasi dan mengubah setiap kata bayi menjadi huruf kecil sebelum melanjutkan. Regex menemukan semua a atau o vokal yang diikuti oleh vokal lain, atau didahului oleh vokal, dan mengurutkannya, a di awal, o di akhir, kemudian menemukan indeks 'o' pertama. Jika jumlah pertandingan yang tersisa (alias, jumlah 'a) lebih besar dari 4, maka kita peduli tentang 4 a, dan jika ada lebih dari 4 o, kita peduli tentang 4 o. Kemudian ia mengeluarkan huruf yang sesuai dari matriks dan mencetaknya, lalu pindah ke kata bayi berikutnya.

Brainfuck, 283 byte

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

Diformat:

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

Ini berfungsi dengan atau tanpa baris baru di input.

Cobalah online.

Setiap karakter diproses mod 32 (dengan aliran kontrol sedemikian rupa sehingga kode yang mengimplementasikan operasi mod hanya terjadi satu kali dalam program). Ini memungkinkan ketidaksensitifan huruf besar / kecil, serta meruntuhkan karakter spasi dan EOF menjadi satu huruf besar. Baris baru tambahan diperlakukan sama dengan J, yang tidak mempengaruhi output.

Sketsa tata letak memori:

0 x C c y a A b B

di mana ckarakter input, Cadalah char mod 32, xadalah apakah itu vokal, yapakah char sebelumnya adalah vokal, Adan Bmerupakan jumlah yang valid (di sebelah vokal) adan okarakter masing-masing, dan adan bmasing-masing buffer yang disalin atau dihapus tergantung pada apakah ada vokal yang berdekatan.

Ketika ruang atau EOF tercapai, beberapa juggling dilakukan untuk mengurangi jumlah yang lebih besar dari 4 dan untuk melewati huruf J, dan kemudian karakter yang diterjemahkan diterjemahkan.

PHP, 163 byte

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

Versi yang lebih mudah dibaca:

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

Tes:

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

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 byte terima kasih kepada @Joba .
-1 byte mengkonversi dari Java 7 ke 8, dan 14 16 byte tambahan disimpan dengan mengubah bagian cetak.

Penjelasan:

Coba di sini.

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 byte

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

Gunakan regex untuk menemukan semua string vokal yang lebih besar dari 2, hitung As dan Os dengan maksimum 4, lalu cetak.

APL, 60

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

Perhatikan bahwa ⎕IO ← 0 dan ⎕ML ← 3

Contoh:

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

Berfungsi di Dyalog 15.0 , karena ini adalah versi di mana 819⌶ diperkenalkan untuk huruf kecil string.

Pyth, 64 byte

Mungkin bisa bermain golf lebih lanjut. Coba di sini!

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

R, 261 byte

Saya pikir saya menghabiskan terlalu banyak waktu hanya untuk mendapatkan ini berfungsi dan saya percaya ini adalah solusi rumit yang tidak perlu, meskipun itu bekerja. Mengambil input dari stdin, penting bahwa string diapit dengan tanda kutip.

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

Penggunaan empat-bersarang- applykeluarga secara teoritis dapat dikurangi menjadi hanya dua dengan memanfaatkan mapplysebagai gantinya. Tetapi karena input mapplytidak akan memiliki panjang yang sama, input yang lebih pendek didaur ulang yang memperumit banyak hal dan saya tidak dapat menemukan solusi yang berfungsi.

Jika ada yang tertarik, saya akan menambahkan penjelasan yang ungolfed nanti.

Coba semua test case pada R-fiddle

Harap dicatat bahwa versi ini mengambil input sebagai argumen fungsi alih-alih dari stdin karena scantidak berfungsi pada R-fiddle. Selanjutnya, ditambahkan baris baru untuk membuatnya lebih mudah dibaca.

Python 3, 262 byte

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)

Kurang Golf (Komentar adalah variabel dalam kode singkat):

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)

Cobalah online!

Kotlin , 221 209 byte

Sekarang jauh lebih jelek dan lambat, semuanya atas nama 11 byte

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)

Simpan ke file (mis. BabyTalk.kts) Untuk dijalankan sebagai skrip. Atau, kode di atas dapat diawali denganfun main(z:Array<String>)= dan dikompilasi secara normal dengan biaya 26 byte lebih.

Cobalah online!

Bertakuk:

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 byte

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

Mengambil input dari argumen baris perintah. Jalankan dengan -nratau coba online .

kerusakan

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 byte

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

Cobalah online!