Rima de las vocales: manzanas y plátanos

Hay una canción tradicional para niños que repite el mismo texto una y otra vez, solo que cada vocal se reemplaza con una vocal aleatoria, pero constante a través de la estrofa actual.

Desafío

El objetivo es proponer el código más corto que realice dicha transformación en un texto de entrada.

Reglas

1. Debes imprimir la rima tantas veces como haya vocales distintas.
2. Cada impresión debe separarse con un salto de línea ( se acepta una combinación de plataforma específica de \ny \r).
3. Para la iteración i, reemplace cada vocal con la ith vocal distinta en el texto original.
4. El texto de entrada es una secuencia de caracteres ASCII imprimibles (rango [32, 126].
5. La entrada no contendrá saltos de línea incrustados.
6. Solo los caracteres vocales deben verse afectados, otros deben ser emitidos exactamente como entrada.
7. Solo los caracteres de las vocales cuentan: las vocales nasales, aunque suenen como vocales (como en francés "Tintín" ), no deben manejarse como una sola vocal.
8. El caso es importante para la salida, pero es posicional (la sustitución de una vocal en mayúscula se realiza con la vocal de reemplazo en mayúscula)
9. Las vocales en mayúsculas no son distintas de su contraparte en minúsculas (es decir, a<=> A)
10. Las vocales consecutivas siempre se consideran por separado (es decir, Boatproduce ambos Booty Baat)
11. Dado que la letra yrepresenta una vocal o un sonido de consonante (como estamos hablando en inglés), se permite manejarla como vocal o consonante, sin embargo, las respuestas deben indicar explícitamente si se manejan ycomo vocal o no.

Ejemplos:

Hola Mundo

Hello world!

da:

Helle werld!
Hollo world!

Extracto del texto original en francés (traducido), ymanejado como vocal:

An elephant that was rambling all gently in the woods...

da:

An alaphant that was ramblang all gantla an tha waads...
En elephent thet wes rembleng ell gentle en the weeds...
In iliphint thit wis rimbling ill gintli in thi wiids...
Yn ylyphynt thyt wys rymblyng yll gyntly yn thy wyyds...
On olophont thot wos romblong oll gontlo on tho woods...

Tenga en cuenta el comportamiento de la vocal mayúscula principal: el caso se mantiene en su índice (reglas 8 y 9).

Ejemplo sin vocales

Entrada que no contiene ninguna vocal, como:

lgn@hst:~$ rm -rf ./* ~ /

no debe producir salida o un solo salto de línea.

Entrada de vocal simple

La entrada que contiene una sola vocal se emite como está.

Dad sat at a car and saw a fat bat.

da:

Dad sat at a car and saw a fat bat.

Este es el código de golf , ¡por lo que gana menos código bytecount (nada más que la eterna gloria PPCG)!

Retina , 45 bytes

~(K`A\EI\OU
L$`\\?(.)
./$1/i&$*\T`Vv`5*$&$L$&

Pruébalo en línea! No cuenta ycomo vocal. Explicación:

K`A\EI\OU

Reemplaza el texto con la cadena literal A\EI\OU.

L$`\\?(.)

Coincide con cada letra opcionalmente precedida por una barra invertida.

./$1/i&$*\T`Vv`5*$&$L$&

Emite una línea de código Retina para cada letra.

~(

Evalúa el código generado (que se muestra a continuación) utilizando la entrada original. Esto .hace que el código no genere el búfer (final). Esto /<vowel>/i&hace que el resto de la línea se ejecute solo si la entrada contiene la vocal dada (sin distinción entre mayúsculas y minúsculas). Esto *hace que se ignore el resultado de la línea, de modo que se pueda probar la siguiente vocal. Esto \hace que el resultado se imprima en su propia línea antes de que se ignore. El T`Vv`AAAAAatranslitera los Vbúhos en mayúscula a AAAAAsy todos los vbúhos en minúscula a a. \Aes un escape que se refiere a ASCII 07 (BEL), pero E, Oy oestán incorporados en las clases de personaje que necesita ser escapado a dar a sus valores literales (e no es una clase de personaje, pero afortunadamente tampoco es un escape).

./A/i&*\T`Vv`AAAAAa
./E/i&*\T`Vv`\E\E\E\E\E\e
./I/i&*\T`Vv`IIIIIi
./O/i&*\T`Vv`\O\O\O\O\O\o
./U/i&*\T`Vv`UUUUUu

Ruby , 78 bytes

->s{s.downcase.scan(/[aeiou]/).uniq.map{|v|s.tr"AEIOUaeiou",v.upcase*5+v}*?\n}

Pruébalo en línea!

Un enfoque rápido e ingenuo. Y no se considera una vocal.

bash, 96 bytes

Dos soluciones de igual longitud:

v=aeiouAEIOU;for x in `grep -o [$v]<<<$1|sed 's/./\L&&&&&\U&/'|awk !a[\\$0]++`;{ tr $v $x<<<$1;}
v=aeiouAEIOU;for x in `tr -cd $v<<<$1|sed 's/./\L&&&&&\U&\n/g'|awk !a[\\$0]++`;{ tr $v $x<<<$1;}

Pruébalo en línea!

Toma la entrada como un argumento de línea de comando y las salidas a STDOUT.

05AB1E (legado) , 19 bytes

(Indirectamente) guardó un byte gracias a Kevin (imprimir directamente dentro del bucle en lugar de unirse, solo funciona en la versión heredada).

lžMÃÙεžMDu«s5×Du«‡=

Pruébalo en línea!

Usando la reescritura de Elixir, 20 bytes

lžMÃÙεžMDu«s5×Du«‡}»

Pruébalo en línea! (siny) | Pruébalo en línea! (cony,žM siendo reemplazado poržO - lo mismo aplica para la versión heredada)

Cómo funciona

lžMÃÙεžMDu«s5×Du«‡}»     Full program. Example: "Hello"
l                        Convert the input to lowercase. "Hello" –> "hello"
 žMÃ                     Keep only lowercase vowels. "hello" –> "eo"
    Ù                    Remove duplicates. "eo" –> "eo"
     ε            }      For each of the characters (example with "e"):
      žMDu«              Yield "aeiouAEIOU"
           s5×           Swap, and repeat the current char 5 times. "e" –> "eeeee"
              Du«        Duplicate, uppercase and merge. "eeeee" –> "eeeeeEEEE"
                 ‡       Transliteration. For each item in B, replace it in A with
                         the corresponding item in C.
                   »     Join on newlines.

Japt v2.0a0 -R, 24 22 bytes

Se trata ycomo una vocal. Cambie ambas ocurrencias de \yto \vpara tratarlo como una consonante.

v f\y â £r\y_Xc^H*ZøZu

Intentalo

Explicación

v                          :Lowercase
   \y                      :RegEx /[aeiouy]/gi (\v is /[aeiou]/gi)
  f                        :Get all matches as an array
      â                    :Deduplicate
        £                  :Map each X
         r\y               :  Replace all matches of the RegEx above in the input
             _             :  Pass matches through a function as Z
              Xc^          :    XOR the character code of X with
                 H*        :     32 multiplied by
                   Zø      :     Does Z contain
                     Zu    :      Uppercase Z
                           :Implicitly join with newlines and output

Gelatina ,  23 20 18  17 bytes

-2 Gracias a Erik the Outgolfer

ØcŒHZx5fƇðØc,yð€Y

Para tratar ycomo vocal, reemplace ambas cs con ys.

Pruébalo en línea!

¿Cómo?

ØcŒHZx5fƇðØc,yð€Y - Link: list of characters, S
Øc                - vowels -> "AEIOUaeiou"
  ŒH              - split in half -> ["AEIOU", "aeiou"]
    Z             - transpose -> ["Aa", "Ee", "Ii", "Oo", "Uu"]
     x5           - times 5 -> ["AAAAAaaaaa", "EEEEEeeeee", "IIIIIiiiii", "OOOOOooooo", "UUUUUuuuuu"]
        Ƈ         - filter keep if:
       f          -   filter keep only -> those of X which have required vowels
                  -                       ...i.e. if S = "blah" then ["AAAAAaaaaa"]
         ð    ð€  - dyadic chain for €ach:
          Øc      -   vowels -> "AEIOUaeiou"
            ,     -   pair       e.g. ["AEIOUaeiou","AAAAAaaaaa"]
             y    -   translate  e.g. swap A for A, E for A, ...
                Y - join with newlines

Rojo , 229 bytes

Tomar ypor una no vocal

func[s][v: charset"aoeiu"w: charset"AOEIU"p: copy""parse s[any[[copy c[v | w](if not find p c[append p c lowercase c
parse s[any[[copy n to[v | w | end]](prin n)opt[v(prin c)|[w(prin uppercase copy c)]| skip]]]print""])]| skip]]]

Pruébalo en línea!

Ligeramente más legible:

f: func [ s ] [
    v: charset "aoeiu"
    w: charset "AOEIU"
    p: copy ""
    parse s[ 
        any [
            [ copy c [ v | w ]
                ( if not find p c [ 
                    append p c
                    lowercase c
                    parse s [
                        any [
                            [ copy n to [ v | w | end ] ]
                                 ( prin n )
                            opt [ v ( prin c )
                                | [ w ( prin uppercase copy c ) ]
                                | skip
                                ]
                            ] 
                        ]
                    print ""
                ] )
            ]
            | skip
        ]
    ]
]

R , 138 , 129 bytes

function(x,U=utf8ToInt,a=U(V<-'aeiouAEIOU'))for(i in (which(a%in%U(x))-1)%%5)cat(chartr(V,intToUtf8(rep(a[i+c(1,6)],e=5)),x),'
')

Pruébalo en línea!

• y no se considera una vocal

Python, 129 119 112 bytes

import re
f=lambda s:'\n'.join(r('[AEIOU]',v.upper(),r('[aeiou]',v,s))for v in'aeiou'if v in s.lower());r=re.sub

Pruébalo en línea!

$y$

-7 bytes gracias a @ Mr.Xcoder

JavaScript (Node.js) , 99 bytes

$y$

s=>(g=F=>Buffer(s).map(c=>2130466>>c&c>64?F(c):c)+`
`)(v=>g[v&=31]||(g[v]=S+=g(c=>c&96|v)),S='')&&S

Pruébalo en línea!

Comentado

s => (                   // s = input string
  g = F =>               // g = helper function taking a callback function F
    Buffer(s)            // turn s into a Buffer
    .map(c =>            // for each ASCII code c in s:
      2130466            //   2130466 is a vowel bitmask: 1000001000001000100010
                         //                               u     o     i   e   a
      >> c               //   the ECMAScript specification enforces that the shiftCount is
                         //   the result of masking out all but the least significant 5 bits
      & c > 64           //   also make sure to ignore non-letter characters
      ?                  //   if a vowel is identified:
        F(c)             //     invoke F with c
      :                  //   else:
        c                //     just yield c
    ) + `\n`             // end of map(); coerce back to a string and append a newline
  )(v =>                 // invoke g with a callback that takes v:
    g[v &= 31] || (      //   unless this vowel has already been encountered:
      g[v] =             //     mark it as encountered
      S +=               //     and append to the output string S
      g(                 //     the result of another call to g:
        c => c & 96 | v  //       where vowels are replaced with v, using the original case
      )                  //     end of inner call to g
    ),                   //
    S = ''               //   start with S = ''
  ) && S                 // end of outer call to g; return S

Java 10, 196 188 bytes

s->{var d=new int[99];for(var c:s.toUpperCase().replaceAll("[^AEIOU]","").toCharArray())if(d[c]++<1)System.out.println(s.replaceAll("[AEIOU]",c+"").replaceAll("[aeiou]",(char)(c+32)+""));}

-8 bytes gracias a @ joH1 .

Sin ycomo vocal para guardar bytes.

Pruébalo en línea.

Explicación:

s->{                       // Method with String parameter and no return-type
  var d=new int[99];       //  Integer-array indicating which vowels we've already output
  for(var c:s.toUpperCase()//  Convert the input to uppercase
            .replaceAll("[^AEIOU]","")
                           //  Remove all non-vowels
            .toCharArray())//  Convert it to a character array)
                           //  And loop over those vowel-characters
    if(d[c]++              //   Increase the vowel-count by 1
             <1)           //   And if it was 0 this iteration:
      System.out.println(  //    Print with trailing newline:
        s                  //     The input,
         .replaceAll("[AEIOU]",c+"")
                           //     with every uppercase vowel replace with the current vowel
         .replaceAll("[aeiou]",(char)(c+32)+""));}
                           //     and every lowercase vowel replaced as well

Python 2 , 112 bytes

s=input()
V='aeiouAEIOU'
for v in V:
 if v in s.lower():print''.join([c,[v.upper(),v][c>'Z']][c in V]for c in s)

Pruébalo en línea!

Se trata ycomo una consonante.

Perl 6 , 64 bytes

{m:g:i/<[aeiou]>/».lc.unique».&{$^v;say S:g:ii[<[aeiou]>]=$v}}

Pruébalo en línea!

Java (OpenJDK 8) , 184 bytes

y es una vocal

s->s.chars().mapToObj(c->""+(char)(c>96?c:c+32)).filter("aeiouy"::contains).distinct().forEach(c->System.out.println(s.replaceAll("[aeiouy]",c).replaceAll("[AEIOUY]",c.toUpperCase())))

Pruébalo en línea!