Rimas de vogais: Maçãs e Bananas

Há uma música infantil tradicional que repete o mesmo texto repetidamente, apenas a cada vez que cada vogal é substituída por uma vogal aleatória, mas constante na estrofe atual.

Desafio

O objetivo é propor o código mais curto que executa essa transformação em um texto de entrada.

Regras

1. Você deve imprimir a rima quantas vezes houver vogais distintas.
2. Cada impressão deve ser separada com uma quebra de linha (combinação específica da plataforma \ne \ré aceita).
3. Para iteração i, substitua cada vogal pela ith vogal distinta no texto original.
4. O texto de entrada é uma sequência de caracteres ASCII imprimíveis (intervalo [32, 126].
5. A entrada não conterá quebras de linha incorporadas.
6. Somente caracteres de vogais devem ser afetados, outros devem ser exibidos exatamente como entrada.
7. Somente os caracteres das vogais contam: as vogais nasais, embora pareçam vogais (como no francês "Tintin" ), não devem ser tratadas como uma única vogal.
8. O caso é importante para a saída, mas é posicional (a substituição de uma vogal maiúscula é feita pela vogal de substituição maiúscula)
9. As vogais em maiúsculas não são distintas de suas contrapartes em minúsculas (ou seja, a<=> A)
10. As vogais consecutivas são sempre consideradas separadamente (isto é, Boatproduz ambos Boote Baat)
11. Como a carta yrepresenta uma vogal ou consoante soun (como estamos falando em inglês), é permitido manipulá-la como vogal ou consoante, no entanto, as respostas devem declarar explicitamente se tratam ycomo vogal ou não.

Exemplos:

Olá Mundo

Hello world!

dá:

Helle werld!
Hollo world!

Trecho do texto original em francês (traduzido), ytratado como vogal:

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

dá:

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

Observe o comportamento da vogal maiúscula inicial: case é mantido em seu índice (regras 8 e 9).

Exemplo de vogal

Entrada que não contém nenhuma vogal, como:

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

não deve produzir saída ou uma única quebra de linha.

Entrada de vogal única

A entrada que contém uma única vogal é emitida como está.

Dad sat at a car and saw a fat bat.

dá:

Dad sat at a car and saw a fat bat.

Este é o código-golfe , o menor número de códigos do número de vitórias (nada além da glória eterna do PPCG)!

Retina , 45 bytes

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

Experimente online! Não conta ycomo vogal. Explicação:

K`A\EI\OU

Substitui o texto pela string literal A\EI\OU.

L$`\\?(.)

Corresponde a cada letra opcionalmente precedida por uma barra invertida.

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

Gera uma linha de código Retina para cada letra.

~(

Avalia o código gerado (mostrado abaixo) usando a entrada original. Isso .faz com que o código não produza o buffer (final). Isso /<vowel>/i&faz com que o restante da linha seja executado apenas se a entrada contiver a vogal fornecida (sem distinção entre maiúsculas e minúsculas). O *faz com que o resultado da linha seja ignorado, para que a próxima vogal pode ser testada. O \faz com que o resultado a ser impressa em sua própria linha antes de ser ignorado. O T`Vv`AAAAAatranslitera letras maiúsculas Vpara se AAAAAtodas as letras minúsculas vpara a. \Aé uma fuga que se refere ao ASCII 07 (BEL), mas E, Oe osão classes de caracteres internas que precisam ser escapadas para fornecer seus valores literais (e não é uma classe de personagem, mas felizmente também não é uma fuga.)

./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}

Experimente online!

Uma abordagem rápida e ingênua. Y não é considerado uma vogal.

bash, 96 bytes

Duas soluções de igual comprimento:

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

Experimente online!

Aceita entrada como argumento de linha de comando e gera saída para STDOUT.

05AB1E (herdado) , 19 bytes

(Indiretamente) economizou um byte graças a Kevin (imprimir diretamente dentro do loop em vez de ingressar, apenas funciona na versão herdada).

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

Experimente online!

Usando a reescrita do Elixir, 20 bytes

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

Experimente online! (semy ) | Experimente online! (com y, žMsendo substituído por žO- o mesmo se aplica à versão herdada)

Como 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

Trata ycomo uma vogal. Alterar ambas as ocorrências \yda \vtratá-la como uma consoante.

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

Tente

Explicação

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 Graças a Erik, o Outgolfer

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

Para tratar ycomo vogal, substitua cs por ys.

Experimente online!

Quão?

Ø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

Vermelho , 229 bytes

Tomando ypor uma não vogal

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

Experimente online!

Um pouco mais legível:

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

Experimente online!

• y não é considerado uma vogal

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

Experimente Online!

Não trata $y$ como vogal.

-7 bytes graças a @ Mr.Xcoder

JavaScript (Node.js) , 99 bytes

Trata $y$ como consoante.

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

Experimente online!

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 graças a @ joH1 .

Sem ycomo vogal para salvar bytes.

Experimente online.

Explicação:

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)

Experimente online!

Trata ycomo uma consoante.

Perl 6 , 64 bytes

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

Experimente online!

Java (OpenJDK 8) , 184 bytes

y é uma vogal

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

Experimente online!