Vokale Reim: Äpfel und Bananen

Es gibt ein traditionelles Kinderlied, das denselben Text immer wieder wiederholt, nur jedes Mal, wenn jeder Vokal durch einen zufälligen Vokal ersetzt wird, aber über die aktuelle Strophe konstant.

Herausforderung

Das Ziel besteht darin, den kürzesten Code vorzuschlagen, der eine solche Transformation für einen Eingabetext ausführt.

Regeln

1. Sie müssen den Reim so oft drucken, wie verschiedene Vokale darin sind.
2. Jeder Ausdruck muss durch einen Zeilenumbruch getrennt werden (plattformspezifische Kombination von \nund \rwird akzeptiert).
3. iErsetzen Sie für die Iteration jeden Vokal durch den jeweils anderen iVokal im Originaltext.
4. Der Eingabetext ist eine Folge druckbarer ASCII - Zeichen (Bereich [32, 126].
5. Die Eingabe enthält keine eingebetteten Zeilenumbrüche.
6. Es dürfen nur Vokale betroffen sein, andere müssen genau als Eingabe ausgegeben werden.
7. Es zählen nur Vokalzeichen: Nasenvokale, die wie Vokale klingen (wie im französischen "Tim" ), dürfen nicht als ein einziger Vokal behandelt werden.
8. Groß- / Kleinschreibung ist für die Ausgabe von Bedeutung, ist jedoch positionsabhängig (das Ersetzen eines Großbuchstabenvokals erfolgt durch den Großbuchstabenersatzvokal)
9. Vokale in Großbuchstaben unterscheiden sich nicht von denen in Kleinbuchstaben (dh a<=> A)
10. Aufeinanderfolgende Vokale werden immer separat betrachtet (dh Boatergibt beides Bootund Baat)
11. Da der Buchstabe yentweder einen Vokal oder einen Konsonantensound darstellt (wir sprechen Englisch), ist es zulässig, ihn als Vokal oder Konsonanten zu behandeln. In den Antworten muss jedoch ausdrücklich angegeben werden, ob sie yals Vokal behandelt werden oder nicht.

Beispiele:

Hallo Welt

Hello world!

gibt:

Helle werld!
Hollo world!

Auszug aus dem französischen Originaltext (übersetzt) ​​mit yVokalhandhabung:

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

gibt:

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

Beachten Sie das Verhalten bei Vokalen in Großbuchstaben: Die Groß- und Kleinschreibung wird an ihrem Index festgehalten (Regeln 8 und 9).

Vokalloses Beispiel

Eingabe, die keinen Vokal enthält, wie:

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

darf keine Ausgabe oder einen einzelnen Zeilenumbruch erzeugen.

Einzelvokaleingabe

Eingaben, die einen einzelnen Vokal enthalten, werden unverändert ausgegeben.

Dad sat at a car and saw a fat bat.

gibt:

Dad sat at a car and saw a fat bat.

Dies ist Code-Golf , so dass nur wenige Bytecount-Codes gewinnen (nichts als ewiger PPCG-Ruhm)!

Netzhaut , 45 Bytes

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

Probieren Sie es online! Zählt nicht yals Vokal. Erläuterung:

K`A\EI\OU

Ersetzt den Text durch die Literalzeichenfolge A\EI\OU.

L$`\\?(.)

Stimmt mit jedem Buchstaben überein, dem optional ein Backslash vorangestellt ist.

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

Gibt für jeden Buchstaben eine Zeile Retina-Code aus.

~(

Wertet den generierten Code (siehe unten) unter Verwendung der ursprünglichen Eingabe aus. Dies .bewirkt, dass der Code den (endgültigen) Puffer nicht ausgibt. Dies /<vowel>/i&bewirkt, dass der Rest der Zeile nur ausgeführt wird, wenn die Eingabe den angegebenen Vokal enthält (ohne Berücksichtigung der Groß- / Kleinschreibung). Das *bewirkt , dass das Ergebnis der Zeile ignoriert werden, so dass die nächsten Vokal getestet werden kann. Das \bewirkt , dass das Ergebnis in einer eigenen Zeile gedruckt werden , bevor sie ignoriert. Das T`Vv`AAAAAaTransliterate Großbuchstaben VOwels zu AAAAAs und alle Kleinbuchstaben vOwels zu a. \Aist eine Flucht, die ASCII 07 (BEL) bezeichnet, aber E, Ound osind Zeichenklassen in integrierten , die ihre Literalwerte geben werden entkam muss (e ist keine Charakterklasse, aber zum Glück auch keine Flucht.)

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

Probieren Sie es online!

Eine schnelle und naive Herangehensweise. Y wird nicht als Vokal betrachtet.

Bash, 96 Bytes

Zwei gleichlange Lösungen:

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

Probieren Sie es online!

Nimmt Eingaben als Befehlszeilenargument und gibt sie an STDOUT aus.

05AB1E (Legacy) , 19 Byte

(Indirekt) hat dank Kevin ein Byte gespart (Drucken direkt in der Schleife, anstatt beizutreten, nur in der älteren Version).

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

Probieren Sie es online!

Verwenden Sie den Elixir-Rewrite (20 Byte)

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

Probieren Sie es online! (ohney) | Probieren Sie es online! (mity,žMersetzt durchžO- gilt auch für die Legacy-Version)

Wie es funktioniert

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

Behandelt ywie ein Vokal. Ändern Sie beide Vorkommen von \ybis \v, um es als Konsonanten zu behandeln.

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

Versuch es

Erläuterung

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

Jelly ,  23 20 18  17 Bytes

-2 Danke an Erik den Outgolfer

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

yAls Vokal zu behandeln, ersetzen Sie beide cs durch ys.

Probieren Sie es online!

Wie?

Ø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

Rot , 229 Bytes

Nehmen yfür einen Nichtvokal

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

Probieren Sie es online!

Etwas besser lesbar:

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

Probieren Sie es online!

• y wird nicht als Vokal betrachtet

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

Probieren Sie es online!

$y$

-7 Bytes dank @ 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

Probieren Sie es online!

Kommentiert

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 dank @ joH1 .

Ohne yals Vokal Bytes zu sparen.

Probieren Sie es online aus.

Erläuterung:

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)

Probieren Sie es online!

Behandelt yals Konsonant.

Perl 6 , 64 Bytes

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

Probieren Sie es online!

Java (OpenJDK 8) , 184 Byte

y ist ein Vokal

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

Probieren Sie es online!