Когда дети открывают рот, они не просто изрыгают тарабарщину. Они на самом деле говорят в очень продвинутом, защищенном от взрослых шифре ...

Шифр Baby-Talk

Когда ребенок говорит, он может выглядеть примерно так: gogooa gagooook aagaaoooy каждый разделенный пробелами раздел представляет символ (поэтому в приведенном выше примере представлены 3 символа).

Чтобы расшифровать раздел, мы должны посчитать количество As и Os, которые в нем содержатся. Тем не менее, мы считаем только те, которые соседствуют с другой гласной. Например, A в 'gag' не будет учитываться, но A и O в 'gaog' будут учитываться.

Подсчет приведенного выше примера будет выглядеть так:

Section    | Num Os | Num As

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

Затем мы используем эти значения для преобразования ввода в открытый текст на квадрате Полибия. Это представление английского алфавита в 5х5, в котором пропущен символ «J» (обратите внимание, что в режиме «baby-talk» к таблице применяются правила подсчета 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

Что говорит нам о том, что ребенок просто говорил "ЭЙ".

Примечания :
- Если раздел, представляющий символ, имеет более 4 символов «As» или «Os», игнорируйте дополнительные, потому что 4 является максимальным значением в таблице. - Для этой задачи Y не является гласным - только A, E, I, O и U.

Соревнование

Ваша задача состоит в том, чтобы создать полную программу, которая принимает один ввод, слово, говорящее по-детски, и печатает его в виде открытого текста.

• Ваша программа должна быть способна принимать ввод как в верхнем, так и в нижнем регистре, а также в обоих сочетаниях.
• Входные данные будут содержать только буквы алфавита ASCII (AZ и az) с одиночными пробелами для разделения слов ребенка.
• Выводить текст можно в любом случае.
• Вы должны принять данные STDINи напечатать открытый текст STDOUT. Если на вашем языке их нет, используйте ближайший аналог.
• Это код-гольф , поэтому выигрывает самый короткий код в байтах - но любое решение приветствуется.

Тестовые случаи

'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. получить минимальное количество (а) и 4, умножить на 5
6. получить минимальное количество (о) и 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 байт

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

Это был довольно хороший способ убить пару часов.

Требуется интерпретатор brainfuck, который использует 8-битные обертывающие ячейки, позволяет перейти влево от ячейки 0 и возвращает 0, если ,используется, когда stdin пуст. По моему опыту, это самые распространенные настройки.

Эта программа не считает Y гласным, но если OP хочет этого, это легко исправить.

Кажется, что написать это было бы непростой задачей, но если вы немного знакомы с языком, в коде нет ничего удивительного или нового. Стандартная тактика мозгового перетока: прочитайте ввод, но убедитесь, что вы оставляете пару пустых ячеек между каждым байтом, используйте эти пустые ячейки для хранения данных о вводе, используйте данные, которые вы сохранили, чтобы решить, как преобразовать его и выплевывать что-либо в конце , В данном случае это был ввод данных, установка его в верхний регистр, выяснение того, какие ячейки являются гласными, выбрасывание этой информации после ее использования, чтобы определить, какие ячейки находятся рядом с гласными, установить все, что не рядом с гласной, для некоторых значение, которое никогда не будет иметь значения, поэтому они не мешают позже, и вы в основном сделали. Оттуда вы просто должны сосчитать ваши Aи Oс, умножить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». Если оставшееся количество совпадений (иначе, число «а») больше 4, то мы заботимся о 4 «а», а если больше 4, мы заботимся о 4 «а». Затем он вытаскивает соответствующую матрицу из матрицы и печатает ее, затем переходит к следующему детскому слову.

Brainfuck, 283 байта

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

отформатирован:

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

Это работает с или без завершающего перевода строки во входных данных.

Попробуйте онлайн.

Каждый символ обрабатывается модом 32 (с потоком управления таким, что код, реализующий операцию мода, встречается в программе только один раз). Это позволяет не учитывать регистр, а также объединять символ пробела и EOF в один регистр. Завершающий перевод строки обрабатывается так же, какJ , что не влияет на вывод.

Эскиз макета памяти:

0 x C c y a A b B

где c- вводимый символ, C- это 32-й символ char, 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);}}}

-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, считает 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

Обратите внимание, что эта версия принимает ввод как аргумент функции вместо стандартного ввода, потому scanчто не работает на R-скрипте. Кроме того, добавлена ​​новая строка, чтобы было легче читать.

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, 124 129 121 120 125 байт

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

Попробуйте онлайн!