Ihre Aufgabe ist es, ein Programm zu schreiben, das alle fünf Buchstaben eine lesbare Liste von Wörtern mit der folgenden Struktur ausgibt:

Konsonant - Vokal - Konsonant - Vokal - Konsonant

Die Ausgabe sollte alphabetisch mit einem Wort pro Zeile sortiert und keine Wörter zweimal wiederholt werden. Es kann Klein- oder Großbuchstaben sein, aber nicht gemischt. Die Liste könnte also so beginnen und enden:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Vokale sind a - e - i - o - u - y , die anderen 20 Buchstaben des englischen Alphabets sind Konsonanten.
Wörter müssen keine echten Wörterbuchwörter sein.
Kürzester Code gewinnt.

Hinweis: Vor ein paar Jahren bin ich auf ein Programm auf einer Universitätswebsite gestoßen, das genau das getan hat. Es stellte sich heraus, dass mein Vor- und Nachname der cvcvc-Einschränkung entsprach, und ich hatte mich selbst gegoogelt.

Mathematica, 72 65 61 Bytes

Print@@@Tuples@{a=##/(b=#5#9#15#21#25#)&@@Alphabet[],b,a,b,a}

Zum Testen empfehle ich das Ersetzen Print@@@durch ""<>#&/@. Mathematica zeigt dann eine abgeschnittene Form mit den ersten und letzten Wörtern an, anstatt für immer 288.000 Zeilen zu drucken.

Erläuterung

Ich habe endlich eine Verwendung zum Teilen von Strings gefunden. :)

Ich war fasziniert von der Möglichkeit, Zeichenfolgen für eine Weile hinzuzufügen oder zu multiplizieren, aber die tatsächlichen Anwendungsfälle sind ziemlich begrenzt. Der Hauptpunkt ist, dass etwas wie "foo"+"bar"oder "foo"*"bar"(und folglich die Kurzform "foo""bar") in Mathematica vollständig gültig ist. Es weiß jedoch nicht wirklich, was es mit den Zeichenfolgen in arithmetischen Ausdrücken tun soll, sodass diese Dinge nicht bewertet werden. Mathematica nicht gelten im Allgemeinen jedoch anwendbar Vereinfachungen. Insbesondere werden die Zeichenfolgen in kanonischer Reihenfolge sortiert (was in Mathematica ziemlich durcheinander ist, wenn Sie mit dem Sortieren von Zeichenfolgen beginnen, die Buchstaben mit verschiedenen Groß- und Kleinschreibung, Ziffern und Nichtbuchstaben enthalten), was häufig ein Dealbreaker ist, aber hier keine Rolle spielt . Darüber hinaus "abc""abc"soll vereinfacht werden"abc"^2(Das ist ein Problem, wenn Sie Zeichenfolgen wiederholt haben, aber das haben wir auch nicht), und so etwas "abc"/"abc"wird tatsächlich abgebrochen (was wir sogar nutzen werden).

Also, was versuchen wir hier zu golfen? Wir brauchen eine Liste von Vokalen und eine Liste von Konsonanten, damit wir sie füttern können Tuples, um alle möglichen Kombinationen zu generieren. Mein erster Ansatz war die naive Lösung:

Characters@{a="bcdfghjklmnpqrstvwxz",b="aeiouy",a,b,a}

Diese hartcodierte Liste von Konsonanten tut ein bisschen weh. Mathematica hat eine Alphabeteingebaute Funktion, mit der ich es vermeiden könnte, wenn ich die Vokale auf kostengünstige Weise entfernen könnte. Hier wird es allerdings schwierig. Das Entfernen von Elementen ist am einfachsten, dauert Complementjedoch länger, wenn Sie eine der folgenden Optionen verwenden:

{a=Complement[Alphabet[],b=Characters@"aeiouy"],b,a,b,a}
{a=Complement[x=Alphabet[],b=x[[{1,5,9,15,21,25}]]],b,a,b,a}

(Beachten Sie, dass wir uns nicht mehr Charactersauf das Ganze beziehen müssen, da Alphabet[]es eine Liste von Buchstaben gibt, keine Zeichenfolge.)

Lassen Sie uns also diese Rechenaufgabe versuchen. Wenn wir das gesamte Alphabet als Produkt aus Buchstaben anstelle einer Liste darstellen, können wir aufgrund der Abbruchregel Buchstaben durch einfache Aufteilung entfernen. Das spart eine Menge Bytes, weil wir nicht brauchen Complement. Außerdem "a""e""i""o""u""y"ist eigentlich ein Byte kürzer als Characters@"aeiouy". Also machen wir das mit:

a=##/(b="a""e""i""o""u""y")&@@Alphabet[]

Wo wir das Speichern der Konsonant und Vokal - Produkte in aund bdargestellt. Dies funktioniert, indem eine Funktion geschrieben wird, die alle Argumente mit ##dem Produkt der Vokale multipliziert und durch dieses dividiert. Diese Funktion wird auf die Alphabet-Liste angewendet , bei der jeder Buchstabe als separates Argument übergeben wird.

So weit so gut, aber jetzt haben wir

{a=##/(b="a""e""i""o""u""y")&@@Alphabet[],b,a,b,a}

als Argument dafür Tuples, und diese Dinge sind immer noch Produkte, keine Listen. Normalerweise ist der kürzeste Weg, dies zu beheben, List@@@der, die Produkte wieder in Listen umzuwandeln. Leider ist das Hinzufügen dieser 7 Bytes länger als der naive Ansatz.

Es stellt sich jedoch heraus, dass Tuplesdie Köpfe der inneren Listen überhaupt nicht wichtig sind. Wenn Sie tun

Tuples[{f[1, 2], f[3, 4]}]

(Ja, für eine undefinierte f.) Sie erhalten:

{{1, 3}, {1, 4}, {2, 3}, {2, 4}}

So als hättest du Liststatt f. So können wir diese Produkte direkt weitergeben Tuplesund trotzdem das richtige Ergebnis erzielen. Dies spart 5 Bytes gegenüber dem naiven Ansatz mit zwei fest codierten Zeichenfolgen.

Jetzt "a""e""i""o""u""y"ist das noch ziemlich nervig. Aber warte, wir können auch hier ein paar Bytes sparen! Die Argumente unserer Funktion sind die einzelnen Buchstaben. Wenn wir also nur die richtigen Argumente auswählen, können wir diese anstelle der String-Literale wiederverwenden, die für drei von ihnen kürzer sind. Wir wollen Argumente #(kurz für #1) #5, #9, #15, #21und #25. Wenn wir #am Ende setzen, müssen wir auch keine hinzufügen *, um sie zu multiplizieren, da (regex) #\d+ein vollständiges Token ist, an das keine Nicht-Ziffern angehängt werden können. Daher #5#9#15#21#25#sparen wir am Ende weitere 4 Bytes.

Perl, 47 Bytes

#!perl -l
/((^|[aeiouy])[^aeiouy]){3}/&&print for a..1x5

Zähle den Shebang als einen.

Probieren Sie es online!

Python 3 - 110 Bytes

a,b="bcdfghjklmnpqrstvwxz","aeiouy";print(*(c+d+e+f+g for c in a for d in b for e in a for f in b for g in a))

Unkomplizierter Looping-Spaß :)

Ruby, 72 71 52 Bytes

puts (?z..?z*5).grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/

Vielen Dank an Value Ink für die Grundidee, die das auf 60 Bytes reduziert hat.

05AB1E , 18 16 Bytes

05AB1E verwendet die CP-1252- Codierung.

žP3ãžO3ãâ€øJ€¨ê»

Erläuterung

žP3ã                # push all combinations of 3 consonants
    žO3ã            # push all combinations of 3 vowels
        â           # cartesian product
         €ø         # zip each pair of [ccc,vvv] (c=consonant,v=vowel)
           J        # join to list of strings ['cvcvcv','cvcvcv' ...]
            ۬      # remove last vowel from each
              ê     # sort and remove duplicates
              »     # join on newlines

Zu Testzwecken empfehle ich, durch žPein paar Konsonanten und žOein paar Vokale zu ersetzen .

Beispiel mit 5 Konsonanten und 3 Vokalen

Python 2 , 120 102 94 Bytes

from itertools import*
lambda:map(''.join,product(*(('AEIOUY','BCDFGHJKLMNPQRSTVWXZ')*3)[1:]))

Probieren Sie es online!

Pure Bash, 74

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval echo $c$v$c$v$c

Einfache Klammererweiterung.

Probieren Sie es online aus .

Wenn jeder Artikel in einer eigenen Zeile stehen muss, haben wir:

Pure Bash, 84

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval printf '%s\\n' $c$v$c$v$c

PHP, 88 86 84 80 Bytes

hübsches Zeichenketteninkrement :)
6 Bytes, die von @Christoph gespeichert wurden

for($s=$v=aeiouy;++$s<zyzza;preg_match("#[^$v]([$v][^$v]){2}#",$s)&&print"$s
");

Durchläuft alle Zeichenfolgen von babababis zyzyzund prüft, ob sie mit dem Muster übereinstimmen. Laufen Sie mit -nr.

MATL , 21 Bytes

11Y2'y'h2Y2X~6Myyy&Z*

Probieren Sie es online! (aber die Ausgabe wird abgeschnitten).

11Y2   % Push 'aeiou' (predefined literal)
'y'    % Push 'y'
h      % Concatenate: gives 'aeiouy'
2Y2    % Push 'abcdefghijklmnopqrstuvwxyz' (predefined literal)
X~     % Set symmetric difference: gives 'bcdfghjklmnpqrstvwxz'
6M     % Push 'aeiouy' again
yyy    % Duplicate the second-top element three times onto the top. The stack now
       % contains 'bcdfghjklmnpqrstvwxz', 'aeiouy', 'bcdfghjklmnpqrstvwxz',
       % 'aeiouy', 'bcdfghjklmnpqrstvwxz'
&Z*    % Cartesian product of all arrays present in the stack. Implicity display

Python, 92 Bytes

f=lambda i=-4,s='':i*[s]or sum([f(i+1,s+c)for c in i%2*'AEIOUY'or'BCDFGHJKLMNPQRSTVWXZ'],[])

Kann nicht itertoolsgewinnen lassen. Iterativ ist in Python 2 1 Byte länger.

W='',
for s in(['AEIOUY','BCDFGHJKLMNPQRSTVWXZ']*3)[1:]:W=[w+c for w in W for c in s]
print W

Haskell, 54 51 Bytes

l="bcdfghjklmnpqrstvwxz":"aeiouy":l
mapM(l!!)[0..4]

mapM func listBildet alle Wörter, indem die möglichen Zeichen für den Index i aus der von zurückgegebenen Liste genommen werden func (list!!i).

Edit: @xnor hat 2 Bytes zum Speichern gefunden und als ich seine Lösung ansah, habe ich eine andere gefunden.

Brachylog , 18 Bytes

@W:@Dg:2jcb:eac@w\

Probieren Sie es online!

Erläuterung

@W:@D                 The list ["aeiouy", "bcdfghjklmnpqrstvwxz"]
     g:2jcb           The list ["bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz"]
           :ea        Take one character of each string
              c       Concatenate into a single string
               @w     Write to STDOUT followed by a newline
                 \    Backtrack: try other characters of the string

JavaScript (ES6), 91 bis 90 Byte

f=(s='',i=4)=>{for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')i?f(s+c,i-1):console.log(s+c)}

Bearbeitungen

• ETHproductions: -1 Byte durch Entfernen einer fremden Gruppe um den ternären Operator in der forAnweisung

Erläuterung

Dies definiert eine 5-tiefe rekursive Funktion, die anhand der Parität der Aufruftiefe bestimmt, ob Vokale oder Konsonanten durchlaufen werden sollen. Bei jeder Iteration wird geprüft, ob eine Rekursion oder ein Ausdruck erforderlich ist, indem die Anzahl der verbleibenden Rekursionen überprüft und der Buchstabe der aktuellen Iteration bis zum Ende der 5-Zeichen-Zeichenfolge verkettet wird, die derzeit mit der Tiefe zuerst erstellt wird.

Alternative 89-Byte-Lösung mit ISO8859-1-Codierung:

f=(s='',i=4)=>{for(c of i%2?'aeiouy':btoa`mÇ_äi骻-¿s`)i?f(s+c,i-1):console.log(s+c)}

Alternative 96-Byte-Lösung, die die gesamte Ausgabe als einzelne Zeichenfolge zurückgibt:

f=(s='',i=4,o='')=>eval("for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')o+=i?f(s+c,i-1):s+c+`\n`")

Laufen Sie auf eigenes Risiko. Verwenden Sie f()für die 91-Byte-Lösung einfach und für die 97-Byte-Alternative console.log(f()).

C 201 199 186 184 183 169 163 Bytes

Mach es ein bisschen anders als mit der vorherigen grundlegenden Zählmethode:

f(){for(char*c="bcdfghjklmnpqrstvwxz",*v="aeiouy",i[5]={0},*s[]={c,v,c,v,c},j=0;j<5;puts("")){for(j=5;j--;putchar(s[j][i[j]]));for(;j++<5&&!s[j][++i[j]];i[j]=0);}}

Ungolfed:

f() {
    for(char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[5]={0}, *s[]={c,v,c,v,c}, j=0; j<5; puts("")) {
        for (j=5; j--; putchar(s[j][i[j]])) ;
        for (; j++ < 5 && !s[j][++i[j]]; i[j]=0) ;
    }
}

Und etwas konventioneller geschrieben:

f() {
    char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[]={0,0,0,0,0}, *s[]={c,v,c,v,c}, j=0;
    while (j>=0) {
        for (j=0; j<5; j++) putchar(s[j][i[j]]); // output the word
        while (--j>=0 && !s[j][++i[j]]) i[j]=0; // increment the counters
        puts("");
    }
}

Grundsätzlich sind i die Zähler und s das String-Array, das alle Zeichen enthält, über die wir für jeden Zähler iterieren sollten. Der Trick ist die innere while- Schleife: Sie dient zum Inkrementieren der Zähler, beginnend mit dem ganz rechten. Wenn wir sehen, dass das nächste anzuzeigende Zeichen das Endzeichen null ist, starten wir den Zähler erneut auf null und der "Übertrag" wird an den nächsten Zähler weitergegeben.

Danke Cristoph!

Perl, 71 Bytes

map{push@{1+/[aeiouy]/},$_}a..z;$"=",";say for glob"{@1}{@2}"x2 ."{@1}"

Probieren Sie es online!

Erläuterung

Ich werde später weitere Erklärungen hinzufügen.

map{push@{1+/[aeiouy]/},$_}a..z;Erstellt zwei Arrays: @1Enthält die Konsonanten und @2enthält die Vokale.
globBeim Aufruf mit Argumenten wie werden {a,b}{c,d}alle Permutationen der Elemente in geschweiften Klammern zurückgegeben.

Befunge, 95 Bytes

::45*%\45*/:6%\6/:45*%\45*/:6%\6/1g,2g,1g,2g,1g,55+,1+:"}0":**-!#@_
bcdfghjklmnpqrstvwxz
aeiouy

Probieren Sie es online! Beachten Sie jedoch, dass die Ausgabe abgeschnitten wird.

Dies ist nur eine Schleife über den Bereich von 0 bis 287999, die den Index als gemischte Zahl 20-6-20-6-20 ausgibt, wobei die "Ziffern" der Zahl aus den Tabellen in den letzten beiden Zeilen abgerufen werden.

Perl 6 , 70 Bytes

$_=<a e i o u y>;my \c=[grep .none,"a".."z"];.say for [X~] c,$_,c,$_,c

Erklärung des interessanten Teils:

.say for [X~] c, $_, c, $_, c

              c, $_, c, $_, c  # list of five lists
         [X ]                  # lazily generate their Cartesian product
           ~                   # and string-concatenate each result
.say for                       # iterate to print each result

Der Code davor erzeugt nur die Liste der Vokale ( $_) und die Liste der Konsonanten ( c), was leider sehr ausführlich ist.

Python 2 , 120 - 117 Bytes

Danke an @WheatWizard für den Tabs-Tipp.

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
for a in x:
 for e in x:
	for b in y:
		for c in y:
			for d in y:print b+a+c+e+d

Probieren Sie es online!

Ich bin mir nicht sicher, ob man damit viel Golf spielen kann. Try it online schneidet bei 128 KB ab, zeigt aber genug, um eine Idee zu geben. Ein lokaler Lauf mit Debug-Code zum Zählen der Wörter ergab insgesamt 288000. Läuft in etwa 45 Sekunden, wenn jemand testen möchte.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

Nicht konforme und daher nicht konkurrierende Version (druckt verschachtelte Arrays anstelle des angegebenen Formats aus) für 110 Bytes:

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
print[[[[c+a+d+b+e for e in y]for d in y]for c in y]for b in x]for a in x]

Perl 6, 53 Bytes

/<-[aeiouy]>**3%<[aeiouy]>/&&.say for [...] <a z>Xx 5

Es dauert etwas, bis die Ausgabe erfolgt. Sehr ineffizient. Macht den Job.

xeger , 49 bytes

([bcdfghj-np-tvwxz][aeiouy]){2}[bcdfghj-np-tvwxz]

Bei einem regulären Ausdruck generiert xeger einfach alle übereinstimmenden Zeichenfolgen. Um den Browser nicht zu beenden, werden alle 1000 Ausgaben angehalten, und Sie müssen auf klicken, um fortzufahren. Er wird jedoch irgendwann dort ankommen.

Hier ist eine 23-Byte-Version mit einem Fehler ^behoben:

([:c^y][:v:y]){2}[:c^y]

Dies sind die Zeichenklassen "Alle ASCII-Kleinbuchstaben-Konsonanten" [:c]mit yAusnahme ^yund "Alle ASCII-Kleinbuchstaben-Vokale" [:v:]mit yHinzufügung.

JavaScript (Firefox 30-57), 82 Byte

f=(i=5)=>i?[for(s of f(i-1))for(c of i%2?'bcdfghjklmnpqrstvwxz':'aeiouy')s+c]:['']

Gibt ein Array von Zeichenfolgen zurück. Sehr schnelle Version für 102 101 (1 Byte dank @ETHproductions) Bytes:

_=>[for(i of c='bcdfghjklmnpqrstvwxz')for(j of v='aeiouy')for(k of c)for(l of v)for(m of c)i+j+k+l+m]

CJam , 32 31 29 28 Bytes

2 Byte dank Martin Ender und 1 Byte dank kaine gespeichert

"aeiouy"_'{,97>^\1$1$1$N]:m*

Probieren Sie es online! (Beachten Sie, dass der Ausgang bei TIO abgeschnitten wird.)

Erläuterung

"aeiouy"_ e# Push the six vowels and duplicate
'{,97>    e# Push the whole alphabet
^         e# Symmetric set difference of the alphabet with the vowels, yields the consonants only
\         e# Swap top two elements
1$1$1$    e# Copy the second-from-the-top string to the top three times
          e# This results in the array being consonants-vowels-consonants-vowels-consonants
N         e# Add a newline character to the end of the list
]         e# End an array. Puts everything done so far in an array
          e# since there was no explicit start of the array.
:m*       e# Reduce the array using Cartesian products

Gestapelt, nicht konkurrierend, 51 Bytes

(consonants:@c vowels:@v c v c)multicartprod$outmap

Ziemlich einfach. Probieren Sie es hier aus!

Perl, 63 59 54 Bytes

$a="aeiouy";$b="[^$a][$a]"x2;for("a"x5.."z"x5){say if/$b[^$a]/}

$a="aeiouy";$b="[^$a][$a]"x2;/$b[^$a]/&&say for"a"x5.."z"x5

$a=aeiouy;$b="[^$a][$a]"x2;/$b[^$a]/&&say for a.."z"x5

Probieren Sie mal Perl Golf.
EDIT: Sieht so aus, als hätte ich noch viel zu lernen ... :)

Scala, 87-86 Bytes

val a="aeiouy"
val b='a'to'z'diff a
for(c<-b;d<-a;e<-b;f<-a;g<-b)println(""+c+d+e+f+g)

R 143 132 Bytes

q=letters;v=c(1,5,9,15,21,25);x=list(q[-v],q[v],q[-v],q[v],q[-v]);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(sapply(x,length))))

q=letters;v=c(1,5,9,15,21,25);x=list(a<-q[-v],b<-q[v],a,b,a);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(lengths(x))))

Dies ist mein erster Versuch, Code Golf zu spielen. Ich würde mich über Vorschläge freuen, ihn weiter zu reduzieren. Bisher ist das alles ziemlich normal R; Das einzig mögliche Problem dabei ist, dass paste0 seine Argumente auf die Länge des längsten zurückführt.

Edit: Verwendeter Zuordnungstrick von rturnbull, ersetzt sapply(x,length)durch lengths.

R 111 98 Bytes

Hinzugefügt yals Vokal und golfed aus 13 Bytes, dank @Patrick B.

l=letters
v=c(1,5,9,15,21,25)
apply(expand.grid(C<-l[-v],V<-l[v],C,V,C)[,5:1],1,cat,fill=T,sep="")

Wir expand.gridgenerieren alle möglichen Kombinationen von Vund Cin einer Matrix, die wir aus der voreingestellten Variablen letters(dem Alphabet) definieren. Wir kehren die Kombinationen um (standardmäßig dreht sich die erste Variable am schnellsten), um die alphabetische Reihenfolge sicherzustellen. Dann durchlaufen wir jede Zeile der Matrix und drucken jeden Buchstaben auf stdout. Mit diesem fillArgument catstellen wir sicher, dass jedes Wort in einer neuen Zeile beginnt.

Clojure, 101 Bytes

(print(apply str(for[V["aeiouy"]C["bcdfghjklmnpqrstvwxz"]a C b V c C d V e C](str a b c d e "\n")))))

Nicht so aufregend ...

Ruby, 65 61 Bytes

Ganz anderer Ansatz:

(b=[*?a..?z]-a="aeiouy".chars).product(a,b,a,b){|x|puts x*""}

Neue Dinge habe ich gelernt , heute: das Array # Produkt - Funktion

C 361 Bytes

f(){i,j,k,l,m;v[6]={97,101,105,111,117,121};c[25];s=26;for(i=0;i<26;i++)c[i]=97+i;for(i=0;i<26;i++){for(j=0;j<6;j++)if(c[i]==v[j])c[i]+=1;}for(i=0;i<s;i++)for(j=i+1;j<s;){ if(c[i]==c[j]){for(k=j;k<s-1;++k)c[k]=c[k+1];--s;}else ++j;}for(i=0;i<s;i++)for(j=0;j<6;j++)for(k=0;k<s;k++)for(l=0;l<6;l++)for(m=0;m<s;m++)printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);}

Ungolfed-Version:

void f()
{   
int i,j, k,l,m;
int s=26;
int v[6]={97,101,105,111,117,121};
int c[s];

for(i=0;i<s;i++)
 c[i]=97+i;
for(i=0;i<s;i++)
{     
  for(j=0;j<6;j++)
    if(c[i]==v[j])
      c[i]+=1;
     }
for(i=0;i<s;i++)
 for(j=i+1;j<s;)
 { if(c[i]==c[j])
  {
    for(k=j;k<s-1;++k)
      c[k]=c[k+1];
      --s;  
  }else
   ++j;  
  }
for(i=0;i<s;i++)
  for(j=0;j<6;j++)
       for(k=0;k<s;k++)
        for(l=0;l<6;l++)
         for(m=0;m<s;m++)       
      printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);
}

Es muss einen Weg geben, dies definitiv zu verkürzen.

Erläuterung

• Speichern der ganzzahligen Werte von a, e, i, o, u, y in einem numerischen Array
• Wenn es sich bei allen Alphabeten im Array um einen Vokal handelte, wurde dieser durch einen Konsonanten ersetzt, sodass doppelte Konsonantenwerte im Array vorhanden waren.
• Doppelte Konsonantenwerte entfernt,
• Gedruckt alle kombinationen cvcvc.