[Question]
  [
The challenge is simple:
## generate a word.
Specifications:
* Word must be pronounceable.
	+ This is defined as "alternating between a consonant and a vowel."
	+ A consonant is one of the following letters: `bcdfghjklmnpqrstvwxz`
	+ A vowel is one of the following letters: `aeiouy`
* Word must be randomly generated.
* Words must be able to contain every consonant and vowel. (You can't just use `bcdf` for consonants and `aei` for vowels.)
* Word must contain 10 letters.
* Shortest code (in character count) wins.
  
[Answer]
# COBOL, 255
So I'm learning COBOL at the moment. Used this question as some practice. Tried to golf it.
It's 255 without the leading whitespace, and 286 bytes with.
For what it's worth, this runs in Microfocus COBOL for VS2012, and I have no idea if it will run anywhere else.
```
       1 l pic 99 1 s pic x(26) value'aeiouybcdfghjklmnpqrstvwxz' 1 r
       pic 99 1 v pic 9 1 q pic 99. accept q perform test after varying
       l from 1 by 1 until l>9 compute v=function mod(l,2) compute r=1+
       function random(q*l)*5+v*15+v*5 display s(r:1)end-perform exit
```
[Answer]
### GolfScript, 32 characters
```
['aeiouy'.123,97>^]5*{.,rand=}%+
```
Run it [online](http://golfscript.apphb.com/?c=WydhZWlvdXknLjEyMyw5Nz5eXTUqey4scmFuZD19JSs%3D&run=true).
[Answer]
## Python, 81
```
from random import*
print''.join(map(choice,["bcdfghjklmnpqrstvwxz","aeiouy"]*5))
```
Good luck pronouncing them.
[Answer]
# Ruby: 56 characters
```
([v=%w(a e i o u y),[*?a..?z]-v]*5).map{|a|$><<a.sample}
```
Example outputs:
* itopytojog
* umapujojim
* ipagodusas
* yfoqinifyw
* ebylipodiz
[Answer]
## APL (34)
```
,⍉↑(V[5?6])((⎕A~V←'AEIOUY')[5?20])
```
[Answer]
# JavaScript, 74
```
for(a=b=[];a++-5;)b+="bcdfghjklmnpqrstvwxz"[c=new Date*a%20]+"aeiouy"[c%6]
```
Does not generate all combinations, but I think that all consonants and vowel appear.
**JavaScript, 79**
```
for(a=b=[];a--+5;)b+="bcdfghjklmnpqrstvwxz"[c=Math.random()*20^0]+"aeiouy"[c%6]
```
More "random" version.
[Answer]
# Ruby: ~~70~~ 66 characters
```
10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}
```
Sample run:
```
bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
izogoreroz
bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
onewijolen
bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
amilyfilil
```
[Answer]
## R: 105 characters
```
a=c(1,5,9,15,21,25)
l=letters
s=sample
cat(apply(cbind(s(l[-a],5),s(l[a],5)),1,paste,collapse=""),sep="")
```
[Answer]
## J (51)
```
,|:>(<"1[5?6 20){&.>'aeiouy';'bcdfghjklmnpqrstvwxz'
```
[Answer]
# **Processing, 100 99 93 87**
```
int i=10;while(i-->0)"aeiouybcdfghjklmnpqrstvwxz".charAt((int)random(i%2*6,6+i%2*i*2));
```
Upon closer inspection of the question, I see it doesn't require any output. I've adjusted this accordingly.
[Answer]
# Unix tools: 73 bytes
And not guaranteed running time :)
```
</dev/urandom grep -ao '[aeiouy][bcdfghjklmnpqrstvwxz]'|head -5|paste -sd ''
```
Only problem is that the generated string will start with a "vowel" every time.
(edit: changed `' '` to `''` in the args of paste)
(another edit: removed -P from grep options, thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork))
[Answer]
## PHP 79 bytes
```
<?for($c=bcdfghjklmnpqrstvwxz,$v=aeiouy;5>$i++;)echo$c[rand()%20],$v[rand()%6];
```
Fairly concise.
[Answer]
**Objective-C, 129** 
```
main(){int i=10;while(i-->0)printf("%c",[(i%2==0)?@"aeiouy":@"bcdfghjklmnpqrstvwxz"characterAtIndex:arc4random()%(6+(i%2)*14)]);}
```
With the help of Daniero
(I love to use the *tends to* operator (-->)
[Answer]
**Java AKA the most verbose language ever created, 176** 
with help of Doorknob, Daniero and Peter Taylor (thanks guys!)
```
class w{public static void main(String[]a){int i=11;while(--i>0)System.out.print((i%2==0?"aeiouy":"bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6+(i%2)*14)));}}
```
Ungolfed: 
```
    class w {
        public static void main(String[] a) {
            int i = 11;
            while (--i > 0) {
                System.out.print((i % 2 == 0 ? "aeiouy" : "bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6 + (i % 2) * 14)));
            }
     }
```
}
[Answer]
## Javascript, 85
```
for(r=Math.random,s="",i=5;i--;)s+="bcdfghjklmnpqrstvwxz"[20*r()|0]+"aeiouy"[6*r()|0]
```
If run from the console, output is shown. Explicit display would add `alert(s)` at 8 chars, still shorter than the other JS solutions.
Thanks C5H8NNaO4 and Howard!
[Answer]
## PHP, 100 Characters
```
<?while($i<6){echo substr('bcdfghjklmnpqrstvwxz',rand(0,20),1).substr('aeiouy',rand(0,5),1);$i++;}?>
```
[Answer]
# K, 40 bytes
```
,/+5?/:("bcdfghjklmnpqrstvwxz";"aeiouy")
```
`5?"abc"` will generate 5 random letters from the given string.
`5?/:` will generate 5 random letters from each of the strings on the right, producing two lists.
`+` transposes those two lists, giving us a list of tuples with one random character from the first list and then one from the second list.
`,/` is "raze"- fuse together all those tuples in sequence.
K5 can do this in 33 bytes by building the alphabet more cleverly and then using "except" (`^`) to remove the vowels, but K5 is much too new to be legal in this question:
```
,/+5?/:((`c$97+!26)^v;v:"aeiouy")
```
[Answer]
# Pyth, 26 characters
```
J-G"aeiouy"VT=k+kOJ=J-GJ;k
```
[You can try it in the online compiler here.](https://pyth.herokuapp.com/?code=J-G%22aeiouy%22VT%3Dk%2BkOJ%3DJ-GJ%3Bk&debug=0)
Someone posted a very similar challenge but it was closed after I had made a solution. I didn't realize it, but this question actually predates the creation of Pyth. Anyway, here is the breakdown:
```
J                             Set string J equal to:
  G                            the entire alphabet (lowercase, in order)
 - "aeiouy"                    minus the vowels
           VT                 For n in range(1, 10):
             =k                   Set string k to:
                k                  k (defaults to empty string)
               + OJ                plus a random character from J
                   =J             Set J to:
                      G            the entire alphabet
                     - J           minus J
                        ;     End of loop
                         k    print k
```
Every time the loop is run, J switches from being a list of consonants to a list of vowels. That way we can just pick a random letter from J each time.  
There may be a way to initialize J in the loop or remove the explicit assignments from the loop, but I have not had success with either yet.
[Answer]
## APL ~~30~~ 26
```
,('EIOUY'∪⎕A)[6(|,+)⍪5?20]
```
Explanation is very similar to the past version below, just reordered a bit to golf the solution.
Note: ⎕IO is set to 0 
---
```
('EIOUY'∪⎕A)[,6(|,(⍪+))5?20]
```
Explanation:
```
'EIOUY'∪⎕A    puts vowels in front of all letters.
5?20            for the indexes we start choosing 5 random numbers between 0 and 19
6(|,(⍪+))        then we sum 6 and the random numbers, convert to 5x1 matrix (⍪), add a column before this one containing 6 modulo the random numbers. 
                [[[ this one can be rewritten as: (6|n) , ⍪(6+n)  for easier understanding]]]
,6(|,(⍪+))5?20  the leading comma just converts the matrix to a vector, mixing the vowel and consonants indexes.
```
[Tryapl.org](http://tryapl.org/?a=%u2395IO%u21900%20%u22C4%20%2C%28%27EIOUY%27%u222A%u2395A%29%5B6%28%7C%2C+%29%u236A5%3F20%5D&run)
[Answer]
# C: 101
```
main(){int x=5;while(x-->0){putchar("bcdfghjklmnpqrstvwxyz"[rand()%21]);putchar("aeiou"[rand()%5]);}}
```
[Answer]
# Javascript, ~~104~~ 87
```
a="";for(e=10;e--;)a+=(b=e&1?"bcdfghjklmnpqrstvwxz":"aeiouy")[0|Math.random()*b.length]
```
*golfed a whole lot of simple unnecessary stuff, still not nearly as nice as [copys' one](https://codegolf.stackexchange.com/a/11897)*
*Oh, and that one just opped up during golfing: **"dydudelidu"***
Now I tried one using the 2 characters at once approach. Turns out it's almost the same as copys' second one, so I can't count it, also at 79.
`a="";for(e=5;e--;)a+="bcdfghjklmnpqrstvwxz"[m=0|20*Math.random()]+"aeiouy"[m%6]`
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 9 bytes
```
Ḍ;Ẉṣᵐzh₅c
```
[Try it online!](https://tio.run/##ATMAzP9icmFjaHlsb2cy/@KJnOKIp@KGsOKCgeG6ieKKpf/huIw74bqI4bmj4bWQemjigoVj//8 "Brachylog – Try It Online")
Gives output as a list of letters through the output variable.
```
   ṣ         Randomly shuffle
 ;  ᵐ        both
Ḍ            the consonants without y
  Ẉ          and the vowels with y,
     z       zip them into pairs,
      h₅     take the first five pairs,
             and output
        c    their concatenation.
```
[Answer]
# ["Random Word Generator"](https://bigyihsuan.github.io/phono-word-gen/), 70 +2 = 72 bytes
```
C=b c d f g h j k l m n p q r s t v w x z
V=a e i o u y
syllable:$C$V
```
Set minimum and maximum number of syllables settings to `5` (which I'm counting as flags, so 1 byte each).
This is written in a (WIP) tool I wrote for generating words from a sound inventory for conlanging (making constructed languages). I made the tool due to the other word generators (that I know of) having flaws (in my opinionated opinion).
The above code sets two categories `C` and `V`, and defines a syllable as a `C` followed by a `V`. The flags (minimum and maximum syllables) define how many syllables will be generated for a given word.
### No changed settings, 86 bytes
```
C=b c d f g h j k l m n p q r s t v w x z
V=a e i o u y
syllable:$C$V$C$V$C$V$C$V$C$V
```
Due to a bug in my implementation, this solution is extremely slow due to the large syllable size.
[Answer]
**F#**, 166 characters
```
open System;String.Join("",(Random(),"aeiouybcdfghjklmnpqrstvwxz")|>(fun(r,s)->[0..5]|>List.collect(fun t->[s.Substring(6+r.Next()%20,1);s.Substring(r.Next()%6,1)])))
```
[Answer]
# R, 83 bytes
```
cat(outer((l<-letters)[a<-c(1,5,9,15,21,25)],l[-a],paste0)[sample(1:120,5)],sep="")
```
Generate all possible vowel-consonant sequences in a matrix, then randomly sample 5 of them, yielding a 10-letter word.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
5FžPΩ?žOΩ?
```
[Try it online](https://tio.run/##yy9OTMpM/f/f1O3ovoBzK@2P7vMHkv//AwA) or [output \$n\$ amount of random words](https://tio.run/##yy9OTMpM/e/239Tt6L6Acyvtj@7zB5L/aw9ts/9vaAAA).
**Explanation:**
Pretty straight-forward:
```
5F      # Loop 5 times:
  žP    #  Push string "bcdfghjklmnpqrstvwxz"
    Ω   #  Pop and push a random character from this string
     ?  #  Output it without newline
  žOΩ?  #  Do the same with string "aeiouy"
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~57~~ ~~47~~ ~~46~~ 54 bytes
```
{`prng@0;,/{(1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"}'!5}
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs6pOKCjKS3cwsNbRr9YwtFdKSk5JS8/Iys7JzSsoLCouKSuvqFLS1AHKJKZm5pdWKtWqK5rWcnGlRccCAIl/FGE=)
*Down 1 byte thanks to ngn*
Takes inspiration from the [PHP answer](https://codegolf.stackexchange.com/a/11882/107017). This one now outputs random words at each call, with the cost of 8 extra bytes.
Explanation:
```
{`prng@0;,/{(1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"}'!5} Main function. Takes no input
                                                   !5  Generate a array with range from 0 to 4 ([0..4])
                                                  '    For each number...
           {                                     }     Execute a function that...
            (1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"      Chooses one random consonant, followed by one random vowel
         ,/                                            Joined each of these strings together
 `prng@0;                                              Use current time to set state of randomness (Thus allow random words)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-P`](https://codegolf.meta.stackexchange.com/a/14339/), ~~20~~ 17 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
;`Á<`
5Æö iCkU ö
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVA&code=O2CMwTxgCjXG9iBpQ2tVIPY)
Note that there is an unprintable character in front of the `Á`
```
;          # C = "abcdefghijklmnopqrstuvwxyz"
 `ŒÁ<`     # U = "oueayi"
5Æ         # Do this 5 times:
  ö        #  Pick a random letter from U
    i      #  Prepend: 
     CkU   #   Remove the letters in U from C
         ö #   Get a random letter from the result
-P         # Print all the pairs with no separator
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-P`](https://codegolf.meta.stackexchange.com/a/14339/), 14 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
;Cü_èyi%Ã®ö5ÃÕ
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVA&code=O0P8X%2bh5aSXDrvY1w9U)
```
;Cü_èyi%Ã®ö5ÃÕ
;C                 :Lowercase alphabet
  ü                :Group by
   _               :Passing each character through the following function
    è              :  Count
     yi%           :    "y" prepended with "%", giving the Japt RegEx "%y"=/[aeiouy]/i
        Ã          :End grouping
         ®         :Map
          ö5       :  5 random characters
            Ã      :End map
             Õ     :Transpose
                   :Implicitly join & output
```
[Answer]
# [JavaScript (V8)](https://v8.dev/), 89 bytes
```
for(;a=Math.random().toString(36).match(/([bcdfghj-np-tvwxz][aeiouy]){5}/g),!a;);print(a)
```
[Try it online!](https://tio.run/##DctNDsIgEAbQs7ibSYQujMaEeARXLpsuPqkFmhQIHfEvnh19@zejYrUlZFH12NqUChmczhCvC@KYFmIt6SIlREe7A@sFYj111F/tODk/q5iV1MfzPfS4hXR/DfzZfzvH2w0Mm/yPQuDWfg "JavaScript (V8) – Try It Online")
`/g` makes the result without an extra appearance of pair
]