当婴儿张开嘴时，他们不仅在吐胡言乱语。他们实际上是在使用高度先进的，可证明成人身份的密码...

婴儿说话密码

婴儿说话时，看起来像是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正方形上的纯文本。这是英文字母的5x5表示形式，省略了“ J”（请注意，在婴儿交谈中，表中使用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

使用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. 用空格替换单词中的konsonant
3. 在空间上分割单词以形成元音组
4. 删除长度小于2的元音组
5. 得到count（a）和4的最小值，乘以5
6. 得到最小的count（o）和4
7. 加计数
8. 以该字母的索引获取字母（不包括“ j”）

Perl，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。如果您的perl太旧，则需要添加一个显式-n选项。

它还假设婴儿不能说以数字开头的通用ASCII字符串，例如 1 this will not work

疯子，656字节

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

这是消磨几个小时的好方法。

需要使用8位包装单元格的Brainfuck解释器，允许您从单元格0左移，如果,在stdin为空时使用，则返回0 。以我的经验，这些是最常见的设置。

这个程序不认为Y是元音，但是如果OP想要它，这很容易解决。

编写此代码似乎是一项艰巨的任务，但是如果您对这种语言有一定的了解，那么代码中就不会感到惊讶或新颖。标准的头脑操策略：读取输入，但确保在每个字节之间留出几个空单元格，使用这些空单元格存储有关输入的数据，使用存储的数据来决定如何转换它并在最后吐出一些东西。在这种情况下，它是获取输入，将其全部为大写字母，数字出哪些细胞是元音，抛出该信息用它来确定哪些细胞是客场后旁边的元音，集一切，是不是旁边有一个元音一些永远不会相关的价值，因此以后再也不会出现这种情况，您基本上已经完成。从那里，您只需要计算As和Os，就可以相乘As乘以5并加上Os 的数量，特殊情况是8之上的任何值，以避免J和输出。我确实选择一次处理一个单词，而不是一次处理整个输入，因此我不得不设置代码部分读取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
]

JavaScript（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字节

+1个字节用于-n标志。空格不是代码的一部分，仅出于可读性提供。

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”的数目）大于4，则我们关心4个a，如果大于4 o，则关心4 o。然后，它将适当的字母从矩阵中拉出并打印，然后移至下一个婴儿单词。

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是炭MOD 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);}}}

-6个字节，感谢@Joba。
-1字节从Java 7转换为8，并通过更改打印部分节省了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

Python 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的元音串，以最大为4的As和Os计数，然后打印。

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小提琴上尝试所有测试用例

请注意，此版本将输入作为函数参数而不是从stdin输入，因为scan它不适用于R-fiddle。此外，添加了换行符以使其更易于阅读。

Python 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

在线尝试！