Rima vocalica: mele e banane

Esiste una canzone tradizionale per bambini che ripete ripetutamente lo stesso testo, solo ogni volta che ogni vocale viene sostituita con una vocale casuale, ma costante nella stanza corrente.

Sfida

L'obiettivo è proporre il codice più breve che esegue tale trasformazione su un testo di input.

Regole

1. Devi stampare la rima tante volte quante sono le vocali distinte in essa.
2. Ogni stampa deve essere separata con un'interruzione di riga (combinazione specifica di piattaforma \ned \rè accettata).
3. Per l'iterazione i, sostituisci ogni vocale con la ivocale distinta nel testo originale.
4. Il testo di input è una sequenza di caratteri ASCII stampabili (intervallo [32, 126].
5. L'input non conterrà interruzioni di riga incorporate.
6. Solo i caratteri vocali devono essere influenzati, altri devono essere emessi esattamente come input.
7. Contano solo i caratteri vocali: le vocali nasali, sebbene suonino come vocali (come nel francese "Tintin" ), non devono essere gestite come una singola vocale.
8. Il caso è importante per l'output, ma è posizionale (la sostituzione di una vocale maiuscola viene eseguita con la vocale di sostituzione maiuscola)
9. Le vocali maiuscole non sono distinte dalla loro controparte minuscola (cioè a<=> A)
10. Le vocali consecutive sono sempre considerate separatamente (es. BoatRese sia Boote che Baat)
11. Poiché la lettera yrappresenta una vocale o una consonante soun (mentre parliamo inglese), è consentita la gestione come vocale o consonante, tuttavia le risposte devono indicare esplicitamente se gestiscono yo meno una vocale.

Esempi:

Ciao mondo

Hello world!

dà:

Helle werld!
Hollo world!

Estratto dal testo originale francese (tradotto), con yuna vocale gestita:

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

Nota il comportamento sulla principale vocale maiuscola: case viene mantenuto nel suo indice (regole 8 e 9).

Esempio di voto

Input che non contiene alcuna vocale, come:

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

non deve produrre alcun output o un'interruzione di riga singola.

Ingresso a vocale singola

L'input contenente una singola vocale viene emesso così com'è.

Dad sat at a car and saw a fat bat.

dà:

Dad sat at a car and saw a fat bat.

Questo è code-golf , quindi vince meno codice bytecount (nient'altro che gloria eterna PPCG)!

Retina , 45 byte

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

Provalo online! Non conta ycome una vocale. Spiegazione:

K`A\EI\OU

Sostituisce il testo con la stringa letterale A\EI\OU.

L$`\\?(.)

Corrisponde a ciascuna lettera facoltativamente preceduta da una barra rovesciata.

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

Emette una riga di codice Retina per ogni lettera.

~(

Valuta il codice generato (mostrato sotto) usando l'input originale. Ciò .causa il codice per non generare il buffer (finale). Ciò /<vowel>/i&fa funzionare il resto della linea solo se l'input contiene la vocale data (senza distinzione tra maiuscole e minuscole). Il *risultato ignora il risultato della linea, in modo che la vocale successiva possa essere testata. Ciò \causa la stampa del risultato sulla propria riga prima che venga ignorato. Il T`Vv`AAAAAatraduttore trascrive i Vgufi maiuscoli a se AAAAAtutti i vgufi minuscoli a a. \Aè una fuga che si riferisce a ASCII 07 (BEL), ma E, Oe osono incorporati nelle classi di caratteri che deve essere sfuggito a dare il loro valori letterali (e non è una classe di personaggi, ma fortunatamente non è nemmeno una via di 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

Rubino , 78 byte

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

Provalo online!

Un approccio rapido e ingenuo. Y non è considerata una vocale.

bash, 96 byte

Due soluzioni di uguale lunghezza:

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

Provalo online!

Prende input come argomento della riga di comando e li invia a STDOUT.

05AB1E (legacy) , 19 byte

(Indirettamente) salvato un byte grazie a Kevin (stampa direttamente all'interno del loop anziché unirsi, funziona solo nella versione precedente).

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

Provalo online!

Utilizzando la riscrittura elisir, 20 byte

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

Provalo online! (senzay) | Provalo online! (cony,žMessendo sostituito dažO- lo stesso vale per la versione legacy)

Come funziona

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 byte

Tratta ycome una vocale. Cambia entrambe le occorrenze di \yper \vtrattarlo come una consonante.

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

Provalo

Spiegazione

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 byte

-2 Grazie a Erik the Outgolfer

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

Per trattare ycome una vocale sostituire entrambe le cs con ys.

Provalo online!

Come?

Ø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

Rosso , 229 byte

Prendendo yper una non vocale

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

Provalo online!

Leggermente più leggibile:

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 byte

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

Provalo online!

• y non è considerata una vocale

Python, 129 119 112 byte

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

Provalo online!

$y$

-7 byte grazie a @ Mr.Xcoder

JavaScript (Node.js) , 99 byte

$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

Provalo online!

Commentate

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 byte

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 byte grazie a @ joH1 .

Senza ycome vocale per salvare byte.

Provalo online.

Spiegazione:

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 byte

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)

Provalo online!

Tratta ycome consonante.

Perl 6 , 64 byte

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

Provalo online!

Java (OpenJDK 8) , 184 byte

y è una vocale

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

Provalo online!