[Question]
  [
*Inspiration*: in 1939, a man named Ernest Vincent Wright wrote a novel called [Gadsby](http://en.wikipedia.org/wiki/Gadsby_(novel)) without using the letter 'e'.
Your task is to write a set of (up to 5) programs in any language (which has a text-based syntax\*) to output all 26 letters of the alphabet in order. However for each vowel aeiou, at least one of the programs must not include any occurrence of the vowel.
So there must be
* a program that does not use '**a**' or '**A**' anywhere in the syntax of the program.
* a program that does not use '**e**' or '**E**' anywhere in the syntax of the program.
* a program that does not use '**i**'  or '**I**' anywhere in the syntax of the program.
* a program that does not use '**o**' or '**O**' anywhere in the syntax of the program.
* a program that does not use '**u**' or '**U**' anywhere in the syntax of the program.
All of them must output `abcdefghijklmnopqrstuvwxyz`.
The winner shall be the solution where the length of all programs is the shortest.
\* since the constraint wouldn't be much of a challenge in Piet or Whitespace
  
[Answer]
## Golfscript - 8 chars
```
123,97>+
```
[Answer]
## Brainfuck, 38 chars
```
++++++[->++++<]>[->+>++++<<]>++[->+.<]
```
There are, of course, no vowels (or any other letters) in [brainfuck](http://en.wikipedia.org/wiki/Brainfuck) syntax.
[Answer]
## PHP, 31 Bytes
No a,e,i,o,u:
```
<?=~žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…;
```
The binary string after the tilde has the following hex representation:
```
\x9e\x9d\x9c\x9b\x9a\x99\x98\x97\x96\x95\x94\x93\x92\x91\x90\x8f\x8e\x8d\x8c\x8b\x8a\x89\x88\x87\x86\x85
```
---
Since there's a language scoreboard, I may as well submit this one as well:
## Ruby (v1.8) 18 bytes
```
$><<[*97.chr..'z']
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth/blob/master/pyth.py), 1 Character
```
G
```
Pyth predefines certain variables. G is predefined as the lowercase alphabet. Pyth also implicitly prints each line with a reasonable return value.
[Answer]
# Ruby (24 22)
**Edit:** parentheses can be omitted, 2 chars less:
```
$><<'%c'*26%[*97..122]
```
24 chars in Ruby:
```
$><<('%c'*26)%[*97..122]
```
**How it works**
`$>` is an alias for `$stdout` or `STDOUT`. You can write to it using the `<<` operator. The term `'%c'*26` repeats the string `'%c'` 26 times. The `%` operator is defined on String as an alias to `sprintf`, so `str % val` is equivalent to writing `sprintf(str,val)`. The format character `%c` is used to transform a char value to a char. These values come from `[*97..122]` which creates an array containing the values from 97 to 122. Et voilá!
[Answer]
## JavaScript (100)
No 'aeou':
```
this['\x61l\x65rt']('\x61bcd\x65fghijklmn\x6fpqrst\x75vwxyz')
```
No 'i':
```
alert('abcdefgh\x69jklmnopqrstuvwxyz')
```
[Answer]
# K,9
```
_26#.Q.b6
```
# K,10
```
"c"$97+!26
```
# K,14
```
.:".Q.","c"$97
```
[Answer]
## R, 17 + 19 = 36 characters
no ae (17):
```
intToUtf8(97:122)
```
no iou (19):
```
cat(letters,sep="")
```
[Answer]
## J, 26 23 17 16 characters
After an hour or so rummaging around in J's underwear drawer I've finally found a way to eliminate the `a.` and `u:` verbs.
```
2(3!:4)96+#\26$1
```
Previously:
```
a.{~96++/\26$1
u:97+i.26
```
with thanks to [randomra](https://codegolf.stackexchange.com/users/7311/randomra) for the `#\` trick.
[Answer]
## Bash (38)
No vowels at all.
```
/*/*/*ntf "/*/?ch? {\x61..z}"|/*/b?sh
```
[Answer]
## C, 90 88 84 characters
Compile using `gcc -nostartfiles`
```
b;_exit(){for(;b<26;)printf("%c",b+++97);}    // 42 chars, works for a, u
b;_start(){putchar(b+++97)>121?:_start();}    // 42 chars, works for e, i, o
```
[Answer]
## Golfscript, 10 characters
```
26,{97+}%+
```
[Answer]
# BASH: 40 characters
* No `aeiou` used.
* No wildcard used.
> 
> 
> ```
> `tr c-y '\141-w'<<<'rtkpvh %s c'` {b..z}
> 
> ```
> 
> 
[Answer]
# Ruby, 20 chars
```
$><<[*97.chr..?z]*''
```
* `97.chr` is an elaborate way of saying 'a'
* `..` specifies a Range
* `?z` is a shorter way of saying "z"
* the `[*range]` causes the range to splat al it's values in an array
* `*''` is the same as `join('')`; it glues all array values together.
* `$><<` Perlicism: print to stdout.
[Answer]
# dc: 18 17 characters
```
97[dP1+dBD>m]dsmx
```
And there died a brave character.
[Answer]
# Powershell, 75 62 characters
**Edit:** Used -f (String.Format) and array indexing to significantly reduce the code length.
```
'{0}bcd{1}fgh{2}jklmn{3}pqrst{4}vwxyz'-f"$(1|gm)"[8,10,0,5,31]
```
**How it works**
`gm` is an alias for `get-members`, so `1|gm` returns members of the value `1`, which is of the `System.Int32` type:
```
PS C:\> 1|gm
   TypeName: System.Int32
Name        MemberType Definition
----        ---------- ----------
CompareTo   Method     int CompareTo(System.Object value), int CompareTo(int value)
Equals      Method     bool Equals(System.Object obj), bool Equals(int obj)
GetHashCode Method     int GetHashCode()
...
```
`"$(1|gm)"` returns a string representation of the above list, which happens to contain all the vowels we need to complete the alphabet: "`i`nt C`o`mp`a`r`e`To(System.Object val`u`e)..."
[Answer]
## Haskell, 12
```
['\97'..'z']
```
Or is this cheating? :)
[Answer]
**MATLAB, 12+20=32 characters**
No eiou (12):
```
char(97:122)
```
No aeou (20)
```
fprintf('%s',97:122)
```
[Answer]
## In Perl,
### it's also possible without any vowels
but much harder than in Ruby etc. This uses a total of **101** chars but doesn't require cmd line (perl -e) invocation.
```
`\160\145\162\154\40\55\145\40\42\160\162\151\156\164\40\123\124\104\105\122\122\40\141\56\56\172\42`
```
=> Result:
 abcdefghijklmnopqrstuvwxyz
In contrast to the 'similar looking' [PHP Solution](https://codegolf.stackexchange.com/a/5639/180), this is a **real program**. The program decoded reads:
```
perl -e "print STDERR a..z"
```
After encoding to octal values, another perl interpreter is called during run by the `` (backticks). The backticks would consume the output, therefore it's printed to STDERR.
The encoding is done by sprintf:
```
my $s = q{perl -e "print STDERR a..z"};
my $cmd = eval(
       '"' . join('', map sprintf("\\%o",ord $_), split //, $s) . '"'
       );
```
and the eval'd encoding **is** the program posted (within backticks):
```
"\160\145\162\154\40\55\145\40\42\160\162"
"\151\156\164\40\123\124\104\105\122\122"
"\40\141\56\56\172\42"
```
Regards
rbo
[Answer]
## Perl 5, 22 characters
(1) only contains `a` and `e`, 10 chars (requires 5.10+, run from the command line): 
```
-Esay+a..z
```
(2) only contains 'i', 12 chars:
```
print v97..z
```
If not allowed to run from the command line, then you need to use `use 5.01;say a..z` for the first one, at a cost of 7 characters and one more vowel, but it still has no 'i', so it results in a valid entry at 29 total characters.
[Answer]
## APL (Dyalog) (~~11~~ 13)
You might need an APL font. This is supposed to be Unicode but there's no preview...
Only `U` (and perhaps `⍳` if counting Greek vowels):
```
⎕UCS 96+⍳26
```
(That's: `[quad]UCS 96+[iota]26`)
Only `A`:
```
⎕A
```
[Answer]
# Python 2, 83
No **a**, **i**, **o** or **u**; **47**:
```
x=97;s='';exec"s+=chr(x);x+=1;"*26+"pr\x69nt s"
```
No **e**; **36**:
```
print"abcd\x65fghijklmnopqrstuvwxyz"
```
[Answer]
## Ruby, 22
```
$><<[*?`..?{][1,26]*''
```
No letters whatsoever :)
[Answer]
# Python 2, 175 characters
Note: prints to output unlike [earlier python answer](https://codegolf.stackexchange.com/a/5610/1721).
Uses 'e', but no a,i,o,u - ~~63~~ ~~61~~ ~~59~~ ~~65~~ (fix mistaken `i` move to lowercase) 115 chars (get rid of spaces).
```
exec('fr%cm sys %cmp%crt*\nf%cr x %cn r%cnge(97,123):std%c%ct.wr%cte(chr(x)),'%(111,105,111,111,105,97,111,117,105))
```
(Originally, it used print with a comma that inserted a space; also printed upper case letters. Now saw stringent requirements for 'abcdefghijklmnopqrstuvwxyz' as output; so adding import statement).
Doesn't use 'e' (uses a,i,o,u; could trivially get rid of a,u for small extension) - ~~61~~ 60 chars
```
import string
print string.__dict__['low%crcas%c'%(101,101)]
```
[Answer]
## JavaScript (154)
(1) Only contains `i` (99 chars):
```
t=this;s=-t+t+t.b;z=s[1]+'bcd'+s[7]+'fghijklmn'+s[4]+'pqrst'+s[21]+'vwxyz';t[s[1]+'l'+s[7]+'rt'](z)
```
(2) Only contains `aeou` (55 chars):
```
t=0;s=''+t.b;alert('abcdefgh'+s[5]+'jklmnopqrstuvwxyz')
```
Demo: <http://jsfiddle.net/SvN5n/>
[Answer]
## Python ~~159~~ 117
As mentioned in the other python post the hardest part is dealing with the fact that the only way to output is to use `print` or `sys.stdout.write`, both of which contain i. Have to do it with 2 programs (which are freestanding and don't use the python interactive shell to create the output):
This one only uses i for 55 chars:
```
print"%cbcd%cfghijklmn%cpqrst%cvwxyz"%(97,101,111,117)
```
This one avoids using i for 104 chars:
```
eval("sys.stdout.wr%cte"%105,{'sys':eval("__%cmport__('sys')"%105)})("%c"*26%tuple(range(97,123))+"\n")
```
**EDIT:**
Massive breakthrough!!! I was thinking that use of eval (or even exec) was a bit of a cheat and not truly in the spirit of the competition. Anyway, trawling through the builtins I found a way to get hold of the print function without using i. So here is the avoid-i (and o) program for 68 chars:
```
vars(vars().values()[0])['pr%cnt'%105]("%c"*26%tuple(range(97,123)))
```
But because that also avoids o, this can be paired with one that only avoids a, e, u for 49 chars:
```
print"%cbcd%cfghijklmnopqrst%cvwxyz"%(97,101,117)
```
[Answer]
## Ruby ~~196~~ ~~164~~ ~~44~~ 47
```
$><<"\x61bcd\x65fgh\x69jklmn\x6Fpqrst\x75vwxyz"
```
[Answer]
## VBA: 76 brute force, 116 without 'cheating' (98 if newlines are acceptable in the output)
**Standard Functions**
Thanks to VBA's verbosity, I don't believe this can be done without 'E' or 'U' in a standard code module... 
* "**E** nd"
* "F **u** nction"
* "S **u** b"
**Immediate Functions**
Running with mellamokb's assumption, here's without the function declaration (leaving out `SUB` and `FUNCTION`) (**116 chars**, **98** if newlines are acceptable in output):
The below uses neither 'e' nor 'a' (**43 chars**, formatted to run in the immediate window):
```
b=65:Do:z=z+Chr(b):b=b+1:Loop Until b=91:?z
```
The below uses neither 'i' nor 'a' nor 'u' (**33 chars**, formatted to run in the immediate window):
```
For b=65 To 90:z=z+Chr(b):Next:?z
```
The below uses neither 'a' nor 'o' nor 'u' (**40 chars**, formatted to run in the immediate window):
```
b=65:While b<91:z=z+Chr(b):b=b+1:Wend:?z
```
---
*If newline characters are allowed in the output, then the above examples can be shorter:*
(**37 chars**)
```
b=65:Do:?Chr(b):b=b+1:Loop Until b=91
```
(**27 chars**)
```
For b=65 To 90:?Chr(b):Next
```
(**34 chars**)
```
b=65:While b<91:?Chr(b):b=b+1:Wend
```
---
**Brute Force**
*Running with [w0lf's Ruby answer](https://codegolf.stackexchange.com/a/5603/3862)*
(**76 chars**, formatted to run in the immediate window):
```
?Chr(65)&"BCD"&Chr(69)&"FGH"&Chr(73)&"JKLMN"&Chr(79)&"PQRST"&Chr(85)&"VWXYZ"
```
[Answer]
### [Rebmu](http://hostilefork.com/rebmu): 15 characters
```
Ctc'`L26[pn++C]
```
Reading Rebmu always requires a bit of [unmushing](https://github.com/hostilefork/rebmu/blob/2965e013aa6e0573caa326780d97522a425103f0/mushing.rebol#L18) to start with:
```
c: tc '` l 26 [pn ++ c]
```
Then it helps to expand the abbreviations:
```
c: to-char-mu '`
loop 26 [
    prin ++ c
]
```
It would be more obvious using a character literal for the predecessor of lowercase a:
```
c: #"`"
loop 26 [
    prin ++ c
]
```
But that doesn't "mush", so converting a word literal to a character passes for the same purpose. What I like about it, as with most Rebmu, is that it has the spirit of a sensible program despite the compression. (The Golfscript answer is shorter but doesn't map to the way a programmer would usually think when coding.)
[Answer]
# <>< (Fish) - 22 characters
Because <>< uses the 'o' to print a character, this challenge seems impossible to do. Luckily, fish can change its own code in runtime. This allowed me to add the print instruction to the code.
This code uses none of the vowels:
```
'`78'+11pv
:X:'z'=?;>1+
```
[You can run the code here](http://fishlanguage.com/playground)
]