Quando os bebês abrem a boca, eles não estão apenas cuspindo bobagens. Eles estão realmente falando em uma cifra altamente avançada e à prova de adultos ...

A Cifra de Conversa de Bebê

Quando um bebê fala, pode parecer algo como gogooa gagooook aagaaoooy Cada seção separada por espaço único representa um caractere (portanto, o exemplo acima representa 3 caracteres).

Para decifrar uma seção, devemos contar o número de As e Os que ela contém. No entanto, contamos apenas aqueles que são adjacentes a outra vogal. Por exemplo, o A em 'gag' não conta, mas tanto o A quanto O em 'gaog' contam.

Contar o exemplo acima ficaria assim:

Section    | Num Os | Num As

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

Em seguida, usamos esses valores para converter a entrada em texto sem formatação em um quadrado Polybius. Esta é uma representação 5x5 do alfabeto inglês, omitindo 'J' (observe que, na conversa sobre bebês, as regras de contagem de 0 se aplicam à tabela):

  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

Usando o número de Os como a coluna e o número de As como a linha, encontramos qual caractere cada seção representa:

Section    | Num Os | Num As | Character

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

O que nos diz que o bebê estava apenas dizendo "HEY".

Notas :
- Se uma seção que representa um caractere tiver mais de 4 As ou Os, ignore os extras, porque 4 é o valor máximo na tabela. - Para esta tarefa, Y não é uma vogal - apenas A, E, I, O e U.

O desafio

Sua tarefa é criar um programa completo que receba uma entrada, uma palavra no idioma do bebê, e a imprima em texto sem formatação.

• Seu programa deve poder receber entradas em maiúsculas, minúsculas e uma mistura de ambas.
• A entrada conterá apenas letras do alfabeto ASCII (AZ e az), com espaços únicos para separar as palavras do bebê.
• O texto de saída pode estar em qualquer caso.
• Você deve pegar a entrada STDINe imprimir o texto sem formatação STDOUT. Se o seu idioma não possuir, use o equivalente mais próximo.
• Isso é código-golfe , então o código mais curto em bytes vence - mas qualquer solução é bem-vinda.

Casos de teste

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

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

Experimente online!

Explicação nas etapas

1. dividir em espaços para formar palavras
2. substituir consoantes em palavras por espaços
3. dividir palavras em espaços para formar grupos de vogais
4. remova grupos de vogais com um comprimento menor que 2
5. obtenha min da contagem (a) e 4, multiplique por 5
6. obter min da contagem (o) e 4
7. adicionar contagens
8. obter letra no índice do alfabeto (excluindo "j")

Perl, 82 bytes

Inclui +1 para -a

Dê entrada no 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

Isso pressupõe uma versão perl recente o suficiente, onde -aimplica -n. Se o seu perl for muito antigo, você precisará adicionar uma -nopção explícita .

Também pressupõe que os bebês não podem dizer seqüências ASCII gerais que começam com dígitos como 1 this will not work

brainfuck, 656 bytes

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

Era uma maneira muito boa de matar algumas horas.

Requer um intérprete cerebral que usa células de quebra automática de 8 bits, permite que você vá para a esquerda da célula 0 e retorna 0 se , for usado quando stdin estiver vazio. Na minha experiência, essas são as configurações mais comuns.

Este programa não considera Y uma vogal, mas se o OP o desejar, será uma solução fácil.

Parece que escrever isso seria uma tarefa assustadora, mas se você tiver alguma familiaridade com o idioma, não há nada de surpreendente ou novo no código. Táticas padrão para o cérebro: leia a entrada, mas certifique-se de deixar algumas células vazias entre cada byte, use essas células vazias para armazenar dados sobre a entrada, use os dados armazenados para decidir como transformá-la e cuspir algo no final . Nesse caso, foi a entrada, coloque tudo em maiúsculas, descubra quais células são vogais, jogue essas informações fora depois de usá-las para determinar quais células estão próximas às vogais, defina tudo o que não estiver próximo a uma vogal um valor que nunca será relevante, de modo que não atrapalhe mais tarde, e você está basicamente pronto. De lá você só tem que contar suas As e Os, multipliqueA 5 por 5 e adicionar o número deOs, caso especial acima de 8 para evitar J e saída. Eu escolhi lidar com essa palavra de cada vez, em vez de pegar toda a entrada de uma só vez, então tive que configurar a parte do código que lê stdin para quebrar em 0 ou 32, mas isso não é um problema muito grande (só embrulhar a subtração de 32 em uma condicional por isso não aconteceria se o valor já é 0, então correta para qualquer <ou> instruções que perdeu mais tarde).

Não sei como será útil, porque escrevi principalmente para manter meus pensamentos retos, e não como uma explicação real, mas aqui está o código com meus comentários e seu recuo original:

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

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

Substitui cada palavra (e o espaço a seguir) pela sua letra correspondente.

s.split` `.map().join`` tem mais 3 bytes:

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 bytes

+1 byte para o sinalizador -n. O espaço em branco não faz parte do código e é fornecido apenas para facilitar a leitura.

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

O código divide a entrada por espaços e converte cada palavra do bebê em letras minúsculas antes de continuar. O regex encontra todas as vogais a ou o que são seguidas por outra vogal ou são precedidas por uma vogal e as classifica, a's no início, o's no final e, em seguida, encontra o índice do primeiro 'o'. Se o número restante de correspondências (ou seja, o número de 'a') for maior que 4, então nos preocupamos com 4 a e, se houver mais de 4 o, importamos com 4 o. Em seguida, ele puxa a letra apropriada para fora da matriz e a imprime, depois passa para a próxima palavra do bebê.

Brainfuck, 283 bytes

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

Formatado:

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

Isso funciona com ou sem uma nova linha à direita na entrada.

Experimente online.

Cada caractere é processado mod 32 (com fluxo de controle, de modo que o código que implementa a operação mod ocorra apenas uma vez no programa). Isso permite a distinção entre maiúsculas e minúsculas, além de recolher o caractere de espaço e o EOF em um único caso. Uma nova linha à direita é tratada da mesma forma Jque, que não afeta a saída.

Esboço do layout da memória:

0 x C c y a A b B

onde cé o caractere de entrada, Cé o char mod 32, xse é uma vogal, yse o char anterior era uma vogal Ae Bsão as contagens válidas (ao lado das vogais) ae ochars, respectivamente, aeb são seus respectivos buffers que ser copiado ou limpo, dependendo da existência de uma vogal adjacente.

Quando um espaço ou EOF é atingido, é feito algum malabarismo para reduzir contagens maiores que 4 e para ignorar a letra Je, em seguida, o caractere decodificado é impresso.

PHP, 163 bytes

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

Versão mais legível:

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

Testes:

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

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 bytes graças a @Joba .
Conversão de -1 byte do Java 7 para 8 e 14 16 bytes adicionais salvos pela alteração da peça de impressão.

Explicação:

Experimente aqui.

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 bytes

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

Usa regex para encontrar toda a sequência de vogais maior que 2, conta As e Os com no máximo 4 e depois imprime.

APL, 60

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

Observe que ⎕IO ← 0 e ⎕ML ← 3

Exemplo:

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

Funciona no Dyalog 15.0 , já que é a versão na qual o 819⌶ foi introduzido para minúscula uma string.

Pitão, 64 bytes

Provavelmente pode ser jogado ainda mais. Experimente aqui!

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

R, 261 bytes

Acho que gastei muito tempo apenas para fazer isso funcionar e acredito que essa é uma solução desnecessariamente complicada, embora funcione. Recebe a entrada de stdin, é importante que a string esteja entre aspas.

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

O uso de quatro applyfamílias aninhadas poderia, teoricamente, ser reduzido para apenas dois usando-o mapply. Mas porque entradas paramapply não terão o mesmo comprimento, a menor será reciclada, o que complica as coisas e eu não consegui descobrir uma solução funcional.

Se alguém estiver interessado, adicionarei uma explicação não destruída mais tarde.

Experimente todos os casos de teste no R-fiddle

Observe que esta versão recebe entrada como argumento de função em vez de stdin porque scannão funciona no R-fiddle. Além disso, adicionou uma nova linha para facilitar a leitura.

Python 3, 262 bytes

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)

Menos golfe (os comentários são as variáveis ​​no código abreviado):

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)

Experimente online!

Kotlin , 221 209 bytes

Agora muito mais feio e lento, tudo em nome de 11 bytes

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)

Salve-o em um arquivo (ex. BabyTalk.kts) Para executar como um script. Ou, o código acima pode ser anexado fun main(z:Array<String>)=e compilado normalmente por um custo de mais 26 bytes.

Experimente online!

Recuado:

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 bytes

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

Recebe entrada dos argumentos da linha de comando. Corra com -nrou experimente online .

demolir

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 bytes

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

Experimente online!