아기가 입을 열면 횡설수설을하는 것이 아닙니다. 그들은 실제로 고도로 발전된 성인용 암호로 말하고 있습니다 ...

베이비 토크 암호

아기가 말을 할 때, gogooa gagooook aagaaoooy 하나의 공백으로 구분 된 각 섹션은 문자를 나타냅니다 (위의 예는 3자를 나타냄).

섹션을 해독하려면 포함 된 As 및 Os의 수를 계산해야합니다. 그러나, 우리는 다른 모음에 인접한 것들만 계산합니다. 예를 들어, 'gag'의 A는 계산되지 않지만 'gaog'의 A와 O는 모두 계산됩니다.

위의 예를 세면 다음과 같습니다.

Section    | Num Os | Num As

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

그런 다음이 값을 사용하여 입력을 Polybius 정사각형의 일반 텍스트로 변환합니다. 이것은 'J'를 생략하고 영어 알파벳을 5x5로 표현한 것입니다.

  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의 수를 열로 사용하고 As의 수를 행으로 사용하여 각 섹션이 나타내는 문자를 찾습니다.

Section    | Num Os | Num As | Character

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

아기가 그냥 "HEY"라고 말한 것 같습니다.

참고 :
-문자를 나타내는 섹션에 4 개 이상의 As 또는 Os가있는 경우 4가 테이블의 최대 값이므로 엑스트라를 무시하십시오. -이 작업에서 Y는 모음이 아니며 A, E, I, O 및 U 만 있습니다.

도전

당신의 임무는 하나의 입력, 단어를 사용하여 일반 텍스트로 인쇄 하는 전체 프로그램 을 만드는 것입니다.

• 프로그램은 대문자, 소문자 및이 둘을 혼합하여 입력 할 수 있어야합니다.
• 입력 값에는 ASCII 알파벳 문자 (AZ 및 az) 만 포함되며, 공백은 아기 단어를 구분합니다.
• 출력 텍스트는 언제든지 가능합니다.
• 입력을 받아 STDIN일반 텍스트를에 인쇄 해야합니다 STDOUT. 사용하는 언어에 해당 언어가 없으면 가장 가까운 언어를 사용하십시오.
• 이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 승리하지만 모든 솔루션을 환영합니다.

테스트 사례

'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 바이트

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

온라인으로 사용해보십시오!

단계 설명

1. 단어를 형성하기 위해 공백으로 분할
2. 단어에서 konsonants를 공백으로 바꾸십시오
3. 모음을 형성하기 위해 공백으로 단어를 나눕니다.
4. 길이가 2보다 짧은 모음 그룹 제거
5. 카운트의 최소값 (a)과 4를 얻습니다.
6. 카운트 최소값 (o) 4
7. 카운트 추가
8. 알파벳 색인에서 문자를 얻습니다 ( "j"제외).

펄, 82 바이트

에 +1 포함 -a

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

이것은 최근에 충분한 perl 버전을 가정 -a합니다 -n. 펄이 너무 오래된 경우 명시적인 -n옵션 을 추가해야합니다 .

또한 아기가 다음과 같은 숫자로 시작하는 일반적인 ASCII 문자열을 말할 수 없다고 가정합니다. 1 this will not work

brainfuck, 656 바이트

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

이것은 두 시간을 죽이는 아주 좋은 방법이었습니다.

8 비트 랩핑 셀을 사용하는 brainfuck 인터프리터가 필요합니다 ,. stdin이 비어있을 때 사용하면 셀 0에서 왼쪽으로 이동하여 0을 리턴합니다 . 내 경험상 가장 일반적인 설정입니다.

이 프로그램은 Y를 모음으로 간주하지 않지만 OP가 원하면 쉽게 고칠 수 있습니다.

이 글을 작성하는 것은 어려운 일처럼 보이지만 언어에 익숙하다면 코드에 놀랍거나 새로운 것이 없습니다. 표준 brainfuck 전술 : 입력을 읽으십시오. 그러나 각 바이트 사이에 빈 셀 몇 개를 남겨두고 빈 셀을 사용하여 입력에 대한 데이터를 저장하고 저장된 데이터를 사용하여 변환 방법을 결정하고 끝에 무언가를 뱉어 내십시오. . 이 경우 입력을 가져 와서 모두 대문자로 설정하고 어떤 셀이 모음인지 파악하고 , 모음 옆에 있는 셀을 결정하기 위해 사용 후 해당 정보를 버리고 모음 옆에없는 모든 것을 일부로 설정하십시오 결코 관련되지 않을 가치가 있으므로 나중에 방해가되지 않으며 기본적으로 완료됩니다. 거기에서 As와 Os 를 세고 곱하면됩니다.As를 5로 지정하고 s의 수를 추가하고 OJ와 출력을 피하기 위해 8보다 큰 임의의 경우. 한 번에 전체 입력을 취하는 것이 아니라 한 번에 한 단어 씩 처리하기로 선택했기 때문에 stdin을 읽는 코드 부분을 0 또는 32에서 중단하도록 설정해야했지만 너무 큰 문제는 아닙니다. (조건부에서 뺄셈을 32만큼 줄 바꿈하면 값이 이미 0 인 경우 발생하지 않으며 나중에 놓친 지침 <이나 >명령 을 수정하십시오 ).

나는 실제 설명이 아닌 내 생각을 똑바로 유지하기 위해 주로 썼기 때문에 그것이 얼마나 도움이 될지 모르겠지만, 여기 내 의견과 원래 들여 쓰기가있는 코드가 있습니다.

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

자바 스크립트 (ES6), 145 바이트

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

각 단어 (및 다음 공백)를 해당 문자로 바꿉니다.

s.split` `.map().join`` 3 바이트 더 깁니다 :

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 바이트

-n 플래그의 경우 +1 바이트 공백은 코드의 일부가 아니며 읽기 쉽도록 제공됩니다.

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

이 코드는 입력을 공백으로 나누고 진행하기 전에 각 단어를 소문자로 변환합니다. 정규 표현식은 다른 모음이 뒤에 오거나 모음이 앞에 오는 모든 a 또는 o 모음을 찾아서 시작 부분에 a, 끝 부분에 o를 정렬 한 다음 첫 번째 'o'의 색인을 찾습니다. 일치하는 나머지 수 (일명 'a 's)가 4보다 크면 약 4a를 신경 쓰고 4o를 초과하면 약 4o를 돌립니다. 그런 다음 적절한 글자를 행렬에서 꺼내서 인쇄 한 다음 다음 단어로 옮깁니다.

Brainfuck, 283 바이트

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

형식화 :

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

이것은 입력에서 후행 줄 바꿈과 함께 또는없이 작동합니다.

온라인으로 사용해보십시오.

각 문자는 mod 32로 처리됩니다 (mod 작업을 구현하는 코드가 프로그램에서 한 번만 발생하도록 제어 흐름으로). 이를 통해 대소 문자를 구분하지 않고 공백 문자와 EOF를 단일 케이스로 축소 할 수 있습니다. 후행 줄 바꿈은과 동일하게 취급 J되며 출력에는 영향을 미치지 않습니다.

메모리 레이아웃 스케치 :

0 x C c y a A b B

여기서 c입력 문자이고, C숯 개조 32, x그것이 모음인지하고, y이전 문자가 모음이었다 여부 A및 B(다음 모음에) 유효의 개수이다 a및 o문자는 각각와 a와 b각 버퍼 것을 인접한 모음이 있는지 여부에 따라 복사하거나 지 웁니다.

공백이나 EOF에 도달하면 4보다 큰 카운트를 줄이고 문자를 건너 뛰기 위해 저글링을 수행 J한 다음 디코딩 된 문자가 인쇄됩니다.

PHP, 163 바이트

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

더 읽기 쉬운 버전 :

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

테스트 :

$ 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

자바 8, 272 266 251 249 바이트

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 덕분에 -6 바이트 .
Java 7에서 8로 -1 바이트 변환 및 인쇄 파트를 변경하여 14 16 바이트 추가 저장.

설명:

여기에서 시도하십시오.

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

파이썬 3 163 162 157 146 바이트

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보다 큰 모음을 모두 찾은 다음 As와 Os를 최대 4로 계산 한 다음 인쇄합니다.

APL, 60

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

⎕IO ← 0 및 ⎕ML ← 3

예:

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

Dyalog 15.0 에서 작동 합니다. 819⌶이 문자열을 소문자로 도입 한 버전이기 때문입니다.

Pyth, 64 바이트

아마 더 골프를 칠 수 있습니다. 여기에서보십시오!

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

R, 261 바이트

나는이 일을하기 위해 너무 많은 시간을 보냈다고 생각하지만 불필요하게 복잡한 해결책이라고 생각합니다. stdin에서 입력을 받으면 문자열을 따옴표로 묶어야합니다.

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

대신에 네 개의 중첩 apply패밀리를 사용하면 이론적으로 두 개만 줄일 수 있습니다 mapply. 그러나 입력 mapply길이가 같지 않기 때문에 더 짧은 입력이 재활용되어 문제가 복잡하여 작동하는 솔루션을 찾을 수 없었습니다.

관심있는 사람이 있다면 나중에 언 골프 설명을 추가하겠습니다.

R-fiddle에서 모든 테스트 사례를 시도하십시오.

이 버전은 scanR 바이올린에서 작동하지 않으므로 stdin 대신 함수 인수로 입력을받습니다 . 또한 쉽게 읽을 수 있도록 줄 바꿈을 추가했습니다.

파이썬 3, 262 바이트

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)

덜 골프 (댓글은 단축 코드의 변수입니다) :

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)

온라인으로 사용해보십시오!

코 틀린 , 221 209 바이트

이제 11 바이트 라는 이름으로 훨씬 더 추악하고 느립니다.

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.kts스크립트로 실행하려면 파일 (예 :)에 저장하십시오 . 또는 위의 코드 앞에 fun main(z:Array<String>)=26 바이트를 추가하여 추가 하고 정상적으로 컴파일 할 수 있습니다 .

온라인으로 사용해보십시오!

들여 쓰기 :

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 바이트

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

명령 행 인수에서 입력을받습니다. 온라인으로 실행 -nr하거나 사용해보십시오 .

고장

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 바이트

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

온라인으로 사용해보십시오!