Cuando los bebés abren la boca, no solo vomitan galimatías. En realidad, están hablando en un cifrado altamente avanzado a prueba de adultos ...

The Baby-talk Cipher

Cuando un bebé habla, podría verse algo así. gogooa gagooook aagaaoooy Cada sección separada por un solo espacio representa un carácter (por lo que el ejemplo anterior representa 3 caracteres).

Para descifrar una sección, debemos contar el número de As y Os que contiene. Sin embargo, solo contamos los que están adyacentes a otra vocal. Por ejemplo, la A en 'gag' no contaría, pero tanto la A como la O en 'gaog' sí lo harían.

Contar el ejemplo anterior se vería así:

Section    | Num Os | Num As

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

Luego usamos estos valores para convertir la entrada en texto sin formato en un cuadrado de Polybius. Esta es una representación de 5x5 del alfabeto inglés, omitiendo 'J' (tenga en cuenta que, en baby-talk, las reglas de conteo de 0 se aplican a la tabla):

  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 el número de Os como columna y el número de As como fila, encontramos qué carácter representa cada sección:

Section    | Num Os | Num As | Character

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

Lo que nos dice que el bebé solo decía "HEY".

Notas :
- Si una sección que representa un personaje tiene más de 4 As u Os, ignore los extras, porque 4 es el valor máximo en la tabla. - Para esta tarea, Y no es una vocal, solo A, E, I, O y U.

El reto

Su tarea es crear un programa completo que tome una entrada, una palabra en baby-speak e imprima en texto sin formato.

• Su programa debe poder tomar entradas en mayúsculas, minúsculas y una combinación de ambas.
• La entrada solo contendrá letras del alfabeto ASCII (AZ y az), con espacios individuales para separar las palabras del bebé.
• El texto de salida puede ser en cualquier caso.
• Debe tomar la entrada STDINe imprimir el texto sin formato en STDOUT. Si su idioma no tiene estos, use el equivalente más cercano.
• Este es el código de golf , por lo que gana el código más corto en bytes, pero cualquier solución es bienvenida.

Casos de prueba

'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-è?

Pruébalo en línea!

Explicación en pasos

1. dividir en espacios para formar palabras
2. reemplazar konsonantes en palabras con espacios
3. dividir palabras en espacios para formar grupos de vocales
4. eliminar grupos vocales con una longitud inferior a 2
5. obtener min de cuenta (a) y 4, multiplicar por 5
6. obtener min de cuenta (o) y 4
7. agregar recuentos
8. obtener letra en ese índice del alfabeto (excluyendo "j")

Perl, 82 bytes

Incluye +1 para -a

Dar entrada en 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

Esto supone una versión perl lo suficientemente reciente donde -aimplica -n. Si su perl es demasiado viejo, deberá agregar una -nopción explícita .

También supone que los bebés no pueden decir cadenas ASCII generales que comienzan con dígitos como 1 this will not work

brainfuck, 656 bytes

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

Esta fue una muy buena manera de matar un par de horas.

Requiere un intérprete de brainfuck que usa celdas de ajuste de 8 bits, le permite ir a la izquierda desde la celda 0 y devuelve 0 si ,se usa cuando stdin está vacío. En mi experiencia, estas son las configuraciones más comunes.

Este programa no considera a Y una vocal, pero si OP lo quiere, es una solución fácil.

Parece que escribir esto sería una tarea desalentadora, pero si está familiarizado con el lenguaje no hay nada sorprendente o nuevo en el código. Tácticas estándar de brainfuck: lea la entrada pero asegúrese de dejar un par de celdas vacías entre cada byte, use esas celdas vacías para almacenar datos sobre la entrada, use los datos que almacenó para decidir cómo transformarla y escupir algo al final . En este caso, fue obtener la entrada, configurarlo todo en mayúsculas, averiguar qué celdas son vocales, desechar esa información después de usarla para determinar qué celdas están al lado de las vocales, configurar todo lo que no está al lado de una vocal para algunos valor que nunca será relevante para que no se interpongan más tarde, y básicamente ya terminaste. A partir de ahí solo tienes que contar tus Asy Os, multiplicarAs por 5 y agregue el número de Os, caso especial cualquier cosa por encima de 8 para evitar J y salida Elegí manejar esta palabra a la vez, en lugar de tomar toda la entrada de una vez, por lo que tuve que configurar la parte del código que lee stdin para romper en 0 o 32, pero eso no es un problema demasiado grande (solo envuelva la resta por 32 en un condicional para que no suceda si el valor ya es 0, luego corrija las instrucciones <o las >que perdió más adelante).

No sé cuán útil será porque lo escribí principalmente para mantener mis pensamientos rectos en lugar de como una explicación real, pero aquí está el código con mis comentarios y su sangría 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)))

Reemplaza cada palabra (y el siguiente espacio) con su letra correspondiente.

s.split` `.map().join`` es 3 bytes más largo:

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 la bandera -n. El espacio en blanco no es parte del código y solo se proporciona para facilitar la lectura.

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

El código divide la entrada por espacios y convierte cada palabra del bebé en minúsculas antes de continuar. La expresión regular encuentra todas las vocales ao o que son seguidas por otra vocal, o están precedidas por una vocal, y las ordena, a al principio, o al final, luego encuentra el índice de la primera 'o'. Si el número restante de coincidencias (también conocido como el número de 'a') es mayor que 4, entonces nos importan aproximadamente 4 a's, y si hay más de 4 o's, nos importan aproximadamente 4 o's. Luego saca la letra apropiada de la matriz y la imprime, luego pasa a la siguiente palabra de bebé.

Brainfuck, 283 bytes

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

Formateado:

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

Esto funciona con o sin una nueva línea final en la entrada.

Pruébalo en línea.

Cada carácter se procesa en el mod 32 (con un flujo de control tal que el código que implementa la operación de mod solo ocurre una vez en el programa). Esto permite la insensibilidad de mayúsculas y minúsculas, así como el colapso del carácter de espacio y EOF en un solo caso. Una nueva línea final se trata igual que J, lo que no afecta a la salida.

Bosquejo del diseño de la memoria:

0 x C c y a A b B

donde cestá el carácter de entrada, Ces el mod de caracteres 32, xes si es una vocal, yes si el carácter anterior era una vocal Ay Bson los recuentos de caracteres válidos (junto a las vocales) ay ocaracteres respectivamente, ay bson sus respectivos buffers que ser copiado o borrado dependiendo de si hay una vocal adyacente.

Cuando se alcanza un espacio o EOF, se hacen algunos malabarismos para reducir los recuentos superiores a 4 y omitir la letra J, y luego se imprime el carácter decodificado.

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

Versión más legible:

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

Pruebas:

$ 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 gracias a @Joba .
-1 byte de conversión de Java 7 a 8, y 14 16 bytes adicionales guardados al cambiar la parte de impresión.

Explicación:

Pruébalo aquí

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

Pitón 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)))

Utiliza expresiones regulares para encontrar todas las cadenas de vocales mayores de 2, cuenta As y Os con un máximo de 4, y luego imprime.

APL, 60

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

Tenga en cuenta que ⎕IO ← 0 y ⎕ML ← 3

Ejemplo:

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

Funciona en Dyalog 15.0 , ya que es la versión en la que se introdujo 819⌶ para poner en minúscula una cadena.

Pyth, 64 bytes

Probablemente se pueda jugar más al golf. Pruébalo aquí!

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

R, 261 bytes

Creo que pasé demasiado tiempo para que esto funcione y creo que es una solución innecesariamente complicada, aunque funciona. Toma información de stdin, es importante que la cadena esté entre comillas.

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

El uso de cuatro applyfamilias anidadas podría reducirse teóricamente a solo dos haciendo uso de ellas mapply. Pero porque las entradas amapply no serán de la misma longitud, la más corta se recicla, lo que complica las cosas y no pude encontrar una solución que funcione.

Si alguien está interesado, agregaré una explicación sin fundamento más adelante.

Pruebe todos los casos de prueba en R-fiddle

Tenga en cuenta que esta versión toma la entrada como un argumento de función en lugar de stdin porque scanno funciona en R-fiddle. Además, se agregó una nueva línea para que sea más fácil de leer.

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 golfizado (los comentarios son las variables en el código acortado):

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)

Pruébalo en línea!

Kotlin , 221 209 bytes

Ahora mucho más feo y lento, todo en nombre 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)

Guárdelo en un archivo (ej. BabyTalk.kts) Para ejecutarlo como un script. O bien, el código anterior se puede anteponer confun main(z:Array<String>)= y compilarse normalmente por un costo de 26 bytes más.

Pruébalo en línea!

Sangrado:

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

Toma información de los argumentos de la línea de comandos. Ejecutar -nro probarlo en línea .

Descompostura

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

Pruébalo en línea!