赤ちゃんが口を開くとき、彼らはただちらほらを吐いているだけではありません。彼らは実際、非常に先進的で大人に耐える暗号で話しています...

ベビートーク暗号

赤ちゃんが話すとき、それは、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またはOがある場合、4はテーブルの最大値であるため、余分な文字を無視します。-このタスクでは、Yは母音ではなく、A、E、I、O、Uのみです。

チャレンジ

あなたの仕事は、1つの入力、赤ちゃんの言葉での単語を取り、それを平文で印刷する完全なプログラムを作成することです。

• プログラムは、大文字、小文字、および両方の組み合わせで入力を取得できる必要があります。
• 入力には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. 単語の子音をスペースに置き換える
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

brainfuck、656バイト

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

これは数時間を殺すのにとても良い方法でした。

8ビットのラッピングセルを使用するBrainfuckインタープリターが必要です。stdin ,が空のときに使用すると、セル0から左に移動し、0を返します。私の経験では、これらは最も一般的な設定です。

このプログラムはYを母音と見なしませんが、OPがYを母音にしたい場合は簡単に修正できます。

これを書くのは大変な作業のように思えますが、言語にある程度精通していれば、コードに驚くべきことや新しいことはありません。標準的な頭脳の戦術：入力を読み取りますが、各バイトの間にいくつかの空のセルを残し、それらの空のセルを使用して入力に関するデータを保存し、保存したデータを使用して変換方法を決定し、最後に何かを吐き出します。この場合、入力を取得し、すべてを大文字に設定し、どのセルが母音であるかを把握し、それを使用してどのセルが母音の隣にあるかを判断した後、その情報を捨て、母音の隣にないすべてをいくつかに設定します決して関連しない値なので、後で邪魔にならず、基本的には完了です。そこからAsとOs を数える必要があります。AOJと出力を回避するために、5でsを追加し、s の数を追加します。入力全体を一度に取得するのではなく、この単語を一度に処理することを選択したため、標準入力を読み取るコードの一部を0または32で中断するように設定する必要がありましたが、それはそれほど大きな問題ではありません（値がすでに0である場合に発生しないように、減算を条件で32でラップするだけで、後でミスした命令<や>命令を修正します）。

本当の説明としてではなく、主に自分の考えを維持するために書いたので、どれほど役立つかわかりませんが、コメントと元のインデントを含むコードは次のとおりです。

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

-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」の数）が4より大きい場合、4 aが重要であり、4 oを超える場合、4 oが重要です。次に、適切な文字をマトリックスから引き出して印刷し、次のベビーワードに移動します。

Brainfuck、283バイト

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

フォーマット済み：

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

これは、入力の末尾の改行の有無にかかわらず機能します。

オンラインでお試しください。

各文字はmod 32で処理されます（mod操作を実装するコードがプログラム内で1回だけ発生するような制御フローを使用）。これにより、大文字と小文字を区別せず、スペース文字とEOFを1つのケースにまとめることができます。末尾の改行はと同じよう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

Javaの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バイト。
-1バイトをJava 7から8に変換し、print-partを変更することで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より大きい母音のすべての文字列を検索し、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

文字列を小文字にするために819⌶が導入されたバージョンであるため、Dyalog 15.0で動作します。

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

4つのネストされたapply-familyの使用は、mapply代わりに使用することにより、理論的には2つだけに減らすことができます。しかし、への入力mapplyは同じ長さではないため、短い方の入力はリサイクルされ、物事を複雑にし、実用的なソリューションを見つけることができませんでした。

誰もが興味を持っている場合は、後で説明を追加します。

R-fiddleですべてのテストケースを試す

scanR-fiddle では機能しないため、このバージョンはstdinからではなく関数引数として入力を受け取ることに注意してください。さらに、読みやすくするために改行を追加しました。

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)

オンラインでお試しください！

Kotlin、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

オンラインでお試しください！