[Question]
  [
Your task is to write a program that will output a readable list of every five letter words with the structure:
**consonant - vowel - consonant - vowel - consonant**
The output should be sorted alphabetically with one word per line and no words repeated twice. It can be lowercase or uppercase but not mixed. So the list could start and end like this:
```
babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 
```
Vowels are **a**-**e**-**i**-**o**-**u**-**y**, the other 20 English-alphabet letters are consonants.  
Words don't have to be actual dictionary words.  
Shortest code wins.
*Note: A few years ago I stumbled upon a program on a university website that did exactly that. Turns out my first and last name fit the c-v-c-v-c constraint, and i'd been googling myself.* 
  
[Answer]
## Mathematica, ~~72~~ ~~65~~ 61 bytes
```
Print@@@Tuples@{a=##/(b=#5#9#15#21#25#)&@@Alphabet[],b,a,b,a}
```
For testing, I recommend replacing `Print@@@` with `""<>#&/@`. Mathematica will then display a truncated form showing the first few and last few words, instead of taking forever to print 288,000 lines.
### Explanation
I finally found a use for dividing strings. :)
I've been intrigued by the possibility of adding or multiplying strings for a while, but the actual use cases are fairly limited. The main point is that something like `"foo"+"bar"` or `"foo"*"bar"` (and consequently, the short form `"foo""bar"`) is completely valid in Mathematica. However, it doesn't really know what to do with the strings in arithmetic expressions, so these things remain unevaluated. Mathematica *does* apply generally applicable simplifications though. In particular, the strings will be sorted into canonical order (which is fairly messed up in Mathematica, once you start sorting strings containing letters of various cases, digits and non-letters), which is often a dealbreaker, but doesn't matter here. Furthermore, `"abc""abc"` will be simplified to `"abc"^2` (which is a problem when you have repeated strings, but we don't have that either), and something like `"abc"/"abc"` will actually cancel (which we'll be even making use of).
So what are we trying to golf here. We need a list of vowels and a list of consonants, so we can feed them to `Tuples` to generate all possible combinations. My first approach was the naive solution:
```
Characters@{a="bcdfghjklmnpqrstvwxz",b="aeiouy",a,b,a}
```
That hardcoded list of consonants does hurt a bit. Mathematica does have an `Alphabet` built-in which would allow me to avoid it, if I were able to remove the vowels in a cheap way. This is where it gets tricky though. The simplest way to remove elements is `Complement`, but that ends up being longer, using one of the following options:
```
{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}
```
(Note that we don't need to apply `Characters` to the whole thing any more, because `Alphabet[]` gives a list of letters, not a string.)
So let's try that arithmetic business. If we represent the entire alphabet as a product of letters instead of a list, then we can remove letters by simple division, due to the cancelling rule. That saves a lot of bytes because we won't need `Complement`. Furthermore, `"a""e""i""o""u""y"` is actually a byte shorter than `Characters@"aeiouy"`. So we do this with:
```
a=##/(b="a""e""i""o""u""y")&@@Alphabet[]
```
Where we're storing the consonant and vowel products in `a` and `b`, respectively. This works by writing a function which multiplies all its arguments with `##` and divides them by the product of vowels. This function is *applied* to the alphabet list, which passes each letter in as a separate argument.
So far so good, but now we have 
```
{a=##/(b="a""e""i""o""u""y")&@@Alphabet[],b,a,b,a}
```
as the argument to `Tuples`, and those things are still products, not lists. Normally, the shortest way to fix that is putting a `List@@@` at the front, which turns the products into lists again. Unfortunately, adding those 7 bytes makes it longer than the naive approach. 
However, it turns out that `Tuples` doesn't care about the heads of the inner lists at all. If you do
```
Tuples[{f[1, 2], f[3, 4]}]
```
(Yes, for an undefined `f`.) You'll get:
```
{{1, 3}, {1, 4}, {2, 3}, {2, 4}}
```
Just as if you had used a `List` instead of `f`. So we can actually pass those products straight to `Tuples` and still get the right result. This saves 5 bytes over the naive approach using two hardcoded strings.
Now the `"a""e""i""o""u""y"` is still fairly annoying. But wait, we can save a few bytes here as well! The arguments of our function are the individual letters. So if we just pick out the right arguments, we can reuse those instead of the string literals, which is shorter for three of them. We want arguments `#` (short for `#1`), `#5`, `#9`, `#15`, `#21` and `#25`. If we put `#` at the end, then we also don't need to add any `*` to multiply them together, because (regex) `#\d+` is a complete token that can't have any non-digit appended to it. Hence we end up with `#5#9#15#21#25#`, saving another 4 bytes.
[Answer]
# Perl, 47 bytes
```
#!perl -l
/((^|[aeiouy])[^aeiouy]){3}/&&print for a..1x5
```
Counting the shebang as one.
[Try it online!](https://tio.run/nexus/perl#@6@voRFXE52YmplfWhmrGR0HY1Ub1@qrqRUUZeaVKKTlFykk6ukZVpj@//9fNwcA "Perl – TIO Nexus")
[Answer]
# 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))
```
Straightforward looping fun :)
[Answer]
## Ruby, ~~72 71~~ 52 bytes
```
puts (?z..?z*5).grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/
```
Thanks to Value Ink for the basic idea, which brought that down to 60 bytes.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~18~~ 16 bytes
**05AB1E** uses [CP-1252](http://www.cp1252.com) encoding.
```
žP3ãžO3ãâ€øJ€¨ê»
```
**Explanation**
```
ž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
```
For testing purposes I recommend replacing `žP` with a few consonants and `žO` with a few vowels.
[Example using 5 consonants and 3 vowels](https://tio.run/nexus/05ab1e#@6@UlJySlq5kfHixUmJqJog@vOhR05rDO7yA5KEVh1cd2v3/PwA)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~120~~ ~~102~~ 94 bytes
```
from itertools import*
lambda:map(''.join,product(*(('AEIOUY','BCDFGHJKLMNPQRSTVWXZ')*3)[1:]))
```
[Try it online!](https://tio.run/nexus/python2#PcrJCoMwFEDRvV/xECSJSKF0J7iodrSDHexMF2mjkKJ5kqT4@ZZ20eXl3K7UWIO0hbaIlQFZN6it75RRxeuH4GHNG0pI74VSBY1G8X5a6lNKhuN5driQgMTJaDKdpYvlar3Z7vb58XS@EuYP2K0f3hnr2qikzGm0VBbcHC2voEUtDITgCderCkXbvyeoLJfKQDpMsvi7GNej5FcEpIKWdR8 "Python 2 – TIO Nexus")
[Answer]
# 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
```
Straightforward brace expansion.
[Try it online](https://tio.run/nexus/bash#JcM7DoAgEEDB3lNQUL7sDTgMIorGiIWuH8LZsXCSaeqKJzKTOXlqF1zpCQyMTCTKIrJVyi5yVJSLm7d2Uf1qYkjZ2GD139oH).
---
If each item must be on its own line, then we have:
# 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
```
[Answer]
# PHP, ~~88~~ ~~86~~  ~~84~~ 80 bytes
pretty string increment :)  
6 bytes saved by @Christoph
```
for($s=$v=aeiouy;++$s<zyzza;preg_match("#[^$v]([$v][^$v]){2}#",$s)&&print"$s
");
```
loops through all strings from `bababa` to `zyzyz` and tests if they match the pattern. Run with `-nr`.
[Answer]
## Haskell, ~~54~~ 51 bytes
```
l="bcdfghjklmnpqrstvwxz":"aeiouy":l
mapM(l!!)[0..4]
```
`mapM func list` builds all words by taking the possible characters for index i from the list returned by `func (list!!i)`.
Edit: @xnor found 2 bytes to save and looking at his solution, I found another one.
[Answer]
# [Python 2](https://docs.python.org/2/), 85 bytes
```
W='BCDFGHJKLMNPQRSTVWXZ'
for s in['AEIOUY',W]*2:W=[w+c for w in W for c in s]
print W
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9xW3cnZxc3dw8vbx9cvIDAoOCQsPCJKnSstv0ihWCEzL1rd0dXTPzRSXSc8VsvIKtw2ulw7WQEkWw6UVQgHM5NBzOJYroKizLwShfD//wE "Python 2 – Try It Online")
I'm back six years later with a golf. The string `W` of consonants can also be used as the result of the first loop which gives all first-letter options. The fact that it's a string rather than a list is harmless because we just need to iterate over it. We can then write the other four letter sets cleanly as `['AEIOUY',W]*2`.
# [Python](https://docs.python.org/3.8/), 92 bytes
```
f=lambda i=-4,s='':i*[s]or sum([f(i+1,s+c)for c in i%2*'AEIOUY'or'BCDFGHJKLMNPQRSTVWXZ'],[])
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P802JzE3KSVRIdNW10Sn2FZd3SpTK7o4Nr9Iobg0VyM6TSNT21CnWDtZMw0olKyQmaeQqWqkpe7o6ukfGqmeX6Tu5Ozi5u7h5e3j6xcQGBQcEhYeEaUeqxMdq/m/oCgzr0QjTUNT8z8A "Python 3.8 (pre-release) – Try It Online")
Can't let `itertools` win out. Iterative is 1 byte longer in Python 2.
```
W='',
for s in(['AEIOUY','BCDFGHJKLMNPQRSTVWXZ']*3)[1:]:W=[w+c for w in W for c in s]
print W
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 21 bytes
```
11Y2'y'h2Y2X~6Myyy&Z*
```
[Try it online!](https://tio.run/nexus/matl#@29oGGmkXqmeYRRpFFFn5ltZWakWpfX/PwA "MATL – TIO Nexus") (but output is truncated).
```
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
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 18 bytes
```
@W:@Dg:2jcb:eac@w\
```
[Try it online!](https://tio.run/nexus/brachylog#@@8QbuXgkm5llJWcZJWamOxQHvP/PwA "Brachylog – TIO Nexus")
### Explanation
```
@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
```
[Answer]
# JavaScript (ES6), ~~91~~ 90 bytes
```
f=(s='',i=4)=>{for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')i?f(s+c,i-1):console.log(s+c)}
```
### Edits
* ETHproductions: -1 byte by removing extraneous group around ternary operator in `for` statement
### Explanation
This defines a 5-deep recursive function that uses the parity of its depth of call to determine whether to iterate vowels or consonants. On each iteration, it checks to see whether to recurse or print by checking the amount of recursions left, and concatenates the letter of its current iteration to the end of the 5 character string that is currently being built depth-first.
Alternative 89 byte solution assuming ISO8859-1 encoding:
```
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 solution that returns entire output as single string:
```
f=(s='',i=4,o='')=>eval("for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')o+=i?f(s+c,i-1):s+c+`\n`")
```
**Run at your own risk.** For the 91 byte solution, just use `f()` and for the 97 byte alternative, use `console.log(f())`.
[Answer]
## C, ~~201~~ ~~199~~ ~~186~~ ~~184~~ ~~183~~ ~~169~~ 163 bytes
Doing it a bit differently than with the previous basic counting method:
```
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) ;
    }
}
```
And written in a bit more conventional way:
```
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("");
    }
}
```
Basically, *i* are the counters, and *s* the array of strings containing all the chars over which we should iterate, for each counter. The trick is the inner *while* loop: it is used to increment the counters, starting from the rightmost one. If we see that the next character we should display is the ending null char, we restart the counter to zero and the "carry" will be propagated to the next counter.
Thanks Cristoph!
[Answer]
# Befunge, 95 bytes
```
::45*%\45*/:6%\6/:45*%\45*/:6%\6/1g,2g,1g,2g,1g,55+,1+:"}0":**-!#@_
bcdfghjklmnpqrstvwxz
aeiouy
```
[Try it online!](http://befunge.tryitonline.net/#code=Ojo0NSolXDQ1Ki86NiVcNi86NDUqJVw0NSovOjYlXDYvMWcsMmcsMWcsMmcsMWcsNTUrLDErOiJ9MCI6KiotISNAXwpiY2RmZ2hqa2xtbnBxcnN0dnd4egphZWlvdXk&input=), although note that the output will be truncated.
This is just a loop over the range 0 to 287999, outputting the index as a mixed based number 20-6-20-6-20, with the "digits" of the number retrieved from the tables on the last two lines.
[Answer]
# [Perl 6](http://perl6.org/), 70 bytes
```
$_=<a e i o u y>;my \c=[grep .none,"a".."z"];.say for [X~] c,$_,c,$_,c
```
Explanation of the interesting part:
```
.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
```
The code before that just generates the list of vowels (`$_`) and the list of consonants (`c`), which is regrettably verbose.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~120~~ 117 bytes
Thanks to @WheatWizard for the tabs tip.
```
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
```
[Try it online!](https://tio.run/nexus/python2#PcdLFkAgFADQMat4swavFTjHYvohn5BQNh/FcWc3ehpqwpSe90Ao4UI2bdcP42SW1W7uOP1Fyma2wEAb8FUJKepLkcJTwpM88S9Xvl2sNg44MhSoUMZ4Aw "Python 2 – TIO Nexus")
Not sure that this can be golfed much. Try it online truncates at 128KB but shows enough to give an idea. A local run with debug code to count the words gave a total of 288000. Runs in about 45 seconds if anyone wants to test.
```
zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000
```
Non-compliant and therefore non-competing version (prints out nested arrays instead of the specified format) for 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]
```
[Answer]
# Perl 6, 53 Bytes
```
/<-[aeiouy]>**3%<[aeiouy]>/&&.say for [...] <a z>Xx 5
```
Takes a little time to have any output. Very inefficient. Does the job.
[Answer]
## JavaScript (Firefox 30-57), 82 bytes
```
f=(i=5)=>i?[for(s of f(i-1))for(c of i%2?'bcdfghjklmnpqrstvwxz':'aeiouy')s+c]:['']
```
Returns an array of strings. Very fast version for ~~102~~ 101 (1 byte thanks to @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]
```
[Answer]
# Perl, 71 bytes
```
map{push@{1+/[aeiouy]/},$_}a..z;$"=",";say for glob"{@1}{@2}"x2 ."{@1}"
```
[Try it online!](https://tio.run/nexus/perl#Ky1OVTDVMzA0sP6fm1hQXVBanOFQbaitH52YmplfWhmrX6ujEl@bqKdXZa2iZKuko2RdnFipkJZfpJCek5@kVO1gWFvtYFSrVGGkoAfmKf3/DwA "Perl – TIO Nexus")
**Explanation**
*I'll add more explanations later.*
`map{push@{1+/[aeiouy]/},$_}a..z;` creates two arrays: `@1` contains the consonants, and `@2` contains the vowels.  
`glob` when call with arguments like `{a,b}{c,d}` returns all permutations of the elements in the braces.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~32~~ ~~31~~ ~~29~~ 28 bytes
*Saved 2 bytes thanks to Martin Ender and 1 byte thanks to kaine*
```
"aeiouy"_'{,97>^\1$1$1$N]:m*
```
[Try it online!](https://tio.run/nexus/cjam#fVFLS8QwEL7nVwyrIMhW8CR6EGTxKqIefTDbTE0gTUom3W7xx9dJu3W7F1sKbfq9Zr5hhWRD26@@gM7guWUDyRCw3cMudOQY0GvQbeNsiYnUxc/69uYe5FrCOxMcAbrG4JaS@oT5EtBrX9eUoi2BKYG2VUWRfEkQqpE7s6CzaVKbjNfQW3Kax6MyeA4efWII3vXq/cShwwZSkKcLQI5qEpy6Ps/3AbIJTT8NRiKliyqGupDvItNY0vlvURgRo5CJJG@2JlawtHozliESt06SWD8NECP2sKWsccxZTFMU/52op6X2g9aA4Klz1svEBiOWieKci6SHw8qc5aQ@ltxH@Yl@inIlvUg62lHsk8mpdBBBDlBhzKFn4OlobHMpIh@lT2Twsst9rt0m2RDG9FfYaKLu6ssj@YV0O7EP62g5G2@ERmzFsIlBEImH4Rc "CJam – TIO Nexus") (Note that the output gets cut off on TIO)
**Explanation**
```
"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
```
[Answer]
# Stacked, noncompeting, 51 bytes
```
(consonants:@c vowels:@v c v c)multicartprod$outmap
```
Pretty simple. [Try it here!](https://conorobrien-foxx.github.io/stacked/stacked.html)
[Answer]
## 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)
```
[Answer]
# 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))))
```
This is my first go at code golf so I'd welcome any suggestions to chop it down further. So far it's all pretty standard R; the only possibly tricky thing here is that paste0 recycles its arguments to the length of the longest one.
Edit: used assignment trick from rturnbull, replaced `sapply(x,length)` with `lengths`.
[Answer]
# R, ~~111~~ 98 bytes
Added `y` as a vowel, and golfed off 13 bytes, thanks to @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="")
```
We use `expand.grid` to generate all possible combinations of `V` and `C` in a matrix, which we define from the preset variable `letters` (the alphabet). We reverse the combinations (as the default is for the first variable to rotate the fastest) to ensure alphabetical order. Then we iterate through each row of the matrix, printing each letter to stdout. We use the `fill` argument to `cat` to ensure that each word begins on a new line.
[Answer]
## 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")))))
```
Not that exciting...
[Answer]
## Ruby, ~~65~~ 61 bytes
Completely different approach:
```
(b=[*?a..?z]-a="aeiouy".chars).product(a,b,a,b){|x|puts x*""}
```
New things I learned today: the **Array#product** function
[Answer]
## 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]);
}
```
There must be some way to shorten this definitely.
## Explanation
* Stored the integer values of a,e,i,o,u,y in a numerical array,
* Stored all alphabets in array, if it was a vowel, replaced it with a consonant, so there were duplicate consonant values in the array,
* Removed duplicate consonant values,
* Printed all combinations c-v-c-v-c.
[Answer]
# Pyth, ~~25~~ 23 bytes
```
s.n*F[K-GJ"aeiouy"JKJKb
```
In pseudocode:
```
'                       ' G, b = "abcdefghijklmnopqrstuvwxyz", "\n"
'         J"aeiouy"     ' J = "aeiouy"
'      K-GJ             ' K = "bcdfghjklmnpqrstvwxz"
's.n                    ' "".join( flatten(
'   *F                  '   reduce(cartesian_product,
'     [K           JKJKb'     [K,J,K,J,K,b]
'                       ' # b makes it so that every word ends with \n so that
'                       ' # flattening and concatenating automatically deals with
'                       ' # newlines
```
[Try it online!](http://pyth.herokuapp.com/?code=s.n%2aF%5BK-GJ%22aeiouy%22JKJKb&debug=0)
[Answer]
# 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
```
Trying Perl golf for a change.  
EDIT: [Looks like](https://codegolf.stackexchange.com/a/106574/14880) I've still got much to learn... :)
]