text:
HelolW rdlo (A threading challenge)
I have a challenge for you:

Print "Hello World" using any language.
Each character must be printed from its own, unique thread

That's it. Obviously, as there's no guarantee that the threads will operate in the order you start them, you have to make your program thread safe to ensure the output is printed in the right order.
And, because this is code golf, the shortest program wins.
Update:
The winner is Marinus' APL entry, at 34 characters. It also wins the prize for the least readable entry.

A better name for this would have been HelolW rdlo

Ha, I like that. Changing it right away :D

Aww... it's too short

It is funny to see how many people ignore the "obviously, as there's no guarantee that the threads will operate in the order you start them" hint and think they got it right.

Albeit it's true that "there's no guarantee that the threads will operate in the order you start them" in practice they will almost always do for such a trivial program.
To avoid this confusion I'd add to the problem that each thread must

wait a (small) random number of milliseconds
output its char
wait for another random (maybe long) amount of time

This way people could tell if the code works by just running it a couple of times. And the join() solutions would perform much worse.
Without random waiting one could be mislead by a successful run to think that his program is correct.

@silviot That's a bit of an issue, but the point of this was to see how people deal with threading screw-ups without even encountering them (and how they compress those solutions into golf-sized programs).

@Tharwen are green threads threads?

APL (Dyalog) (44  43 39 34)
{⍞←⍺⊣⎕DL⍵}&⌿2 11⍴'Hello World',⍳11

Explanation:

2 11⍴'Hello World',⍳11 creates a matrix: (H,1), (e,2), ...
&⌿ means: for each column of the matrix, do on a separate thread:
In a thread, ⍺ is now the character and ⍵ is now the time
⎕DL⊃⍵ waits for ⍵ seconds.
Then, ⍞←⍺ outputs the character.

You know what? I'll take your word for it... :)

OK, this is the shortest. Congratulations!

C, 61 62 chars
i;main(){write(1,"Hello World\n"+i++,1);i>13||fork()||main();}

The pthread library functions all have loooooong names, so instead I fired up an entire separate process for each character. fork() is so much shorter.
It was necessary to use write() instead of putchar() because the stdio buffering functions are not thread-safe.
Edited: Back up to 62 chars. In my zeal, dropping down to 61 chars also dropped the thread-safety.

It should be possible to changed the write statement to write(1,"Hello World\n",!!++i) for 2 bytes. Nice solution otherwise.

You should try that and see what it produces.

My mistake, I meant !!++i

That appears to be what you wrote the first time, so I don't see what mistake you were trying to correct. And I wasn't being facetious: I honestly meant that you should try it yourself and see what happens. By removing the addition, every thread will just print the first character of the string.

I had originally written !!i++, but edited it a few seconds later, because I realized it would evaluate to 0 on the first iteration. I assumed you had seen the unedited version. I'm not able to test your code, because it only prints out the very first character, once. There's a lot of alternatives though; i++<13, using !!i, or even write(1,"Hello World\n",i++>13||fork()||main())

The point is that you still have to add i to the string. If you don't then it will only print the first character.

fork!=thread but nice cheat anyway.

Every process contains a thread, so I don't see the problem.

Ruby, 46 characters
"Hello World".chars{|c|Thread.new{$><<c}.join}

It is synchronized due to the fact that the program waits for the thread to end before starting the next thread and continuing with the next char.

Pythonect (35 chars)
http://www.pythonect.org
"Hello World"|list|_.split()->print

This is the shortest so far. Since I have no idea what it actually does, I'll assume it's correct and accept it in a day or two if no-one speaks out against it or posts anything shorter.

Just had a brief look at the examples.  Shouldn't print statement or list statement have brackets [] around it?

Hi, im forwarding Itzik's(creator of pythonect) answer:
'->' and '|' are both Pythonect operators. The pipe operator passes one item at a item, while the other operator passes all items at once.
What the program above does is, it takes "Hello World" string, turn's it into a list, split the list to chars, and send each char to print.
It's possible to optimize the program even further, to the following: iter("Hello World") | print
What it does is, it iterates "Hello World" string, and send each char to print (in a sync/blocking manner).
Regards,
Itzik Kotler | http://www.ikotler.org

how is the threading being done here???

Like @LeonFedotov mentioned, and from the pythonect source (available at pythonect) after parsing, for each iteration and the '->' operator, threading is done like this: thread = threading.Thread(target=run, args=([(operator, item)] + expression[1:], copy.copy(globals), copy.copy(locals), return_value_queue, not iterate_literal_arrays))
thread.start()

Python (101 93 98)
This is Peter Taylor's solution. It works by delaying printing the N-th character by N seconds. See comments.
import sys.threading as t
for x in range(11):t.Timer(x,sys.stdout.write,"Hello World"[x]).start()

This is the original one:
import sys,threading as t
for x in "Hello World":t.Thread(None,sys.stdout.write,x,x).start()

It worked because the time it takes to print a single character is less than the time it takes Python to initialize a new thread, therefore the N-th thread would finish before the N+1-th thread was created. Apparently it is against the rules to rely on this.

You can save 3 chars by changing import sys,threading to import sys,threading as t and you can save 2 more, by passing the arguments to Thread as positional args, rather than keyword arguments.

Where is the code that deals with thread safety?
You just fire threads hoping they'll run in the same order you start them.
This won't always be true and is in fact the "hard part" of this problem.
Instead of optimizing your program size you should re-consider the problem: you didn't get it in the first place. See https://gist.github.com/2761278 for a proof that this code doesn't work.

Quick fix. Use threading.Timer instead of threading.Thread. Pass in x as the sleep parameter.

Actually see my edit. Had to add an extra line. Back to 101

Joel's suggestion can be improved by 4 to for x in range(11):t.Timer(x,sys.stdout.write,"Hello World"[x]).start()

@silviot: I was exploiting the fact that thread creation involves instantiating an object, and thus takes one- to two-thirds of a millisecond on the systems I've tested. Character output does not have this overhead, taking only a tenth of this time. Therefore, it will "always" work, as long as you don't override anything. Stdout is buffered so that shouldn't ever give problems either.

C# 73
"hello world".ToList().ForEach(c=>Task.Run(()=>Console.Write(c)).Wait());

not sure this satisfies the requirement that each letter be printed via its own thread since the tpl may reuse threads.

In theory you're right, but on my pc ThreadPool.GetMaxThreads or ThreadPool.GetAvailableThreads returns a value around 1000 for both IO and worker threads.

APL (Dyalog Unicode), 28 bytesSBCS
Full program. Prints to stderr. Inspired by marinus' solution.
'Hello World'{⍞←⍺⊣⎕DL⍵}&¨⍳11

Try it online!
⍳11 first 11 integers
'Hello World'{…}&¨ for each integer as right argument (⍵), spawn the following function with the corresponding character as left argument (⍺):
 ⎕DL⍵ delay right-argument seconds
 ⍺⊣ discard that (the effective delay) in favour of the left-argument character
 ⍞← print that to stdout without trailing line break

how about ⍞∘←&¨'dlroW olleH'? - I don't know if it's guaranteed theoretically but it seems to always print them in the correct order

@ngn Obviously, as there's no guarantee that the threads will operate in the order you start them, you have to make your program thread safe to ensure the output is printed in the right order.

that's the constraint I was trying to address, it might be guaranteed. I ran this 100 times and it looks like the thread scheduler always picks up the threads in reverse order. Or at least that's the case when there are ≤11 tasks. AFAIK ⍞∘← is not interruptible (or is it? maybe you can ask a C developer?). Dyalog implements green threads - 1 real thread pretending to be many, so if a (green) thread switch cannot occur, the order is predictable.

Java (160 chars)
class A{static int i;public static void main(String...a){new Thread(){public void run(){System.out.print("Hello World".charAt(i++));if(i<11)main();}}.start();}}

Yeah, I know this is the wrong language for code golf, I do it for fun.

class A{public static void main(String[]args){new B(0).start();}}class B extends Thread{int i;B(int j){i=j;}public void run(){System.out.print("Hello World".charAt(i));if(i<10)new B(i+1).start();}}-197 chars

@Prince Yep, thanks for the correction!

class A extends Thread{static int i;public static void main(String[]args){System.out.print("Hello World".charAt(i++));if(i<11)new A().start();}public void run(){main(null);}} - 174 chars

@Wouter Very good one! I totally missed it.

class A{static int i;public static void main(String[]a){new Thread(){{start();}public void run(){System.out.print("Hello World".charAt(i++));if(i<11)main(null);}};}} - 165 chars

@Wouter Using an instance initializer is a cool improvement, thanks!

class A{static int i;public static void main(String[]a){new Thread(){public void run(){System.out.print("Hello World".charAt(i++));if(i<11)main(null);}}.start();}} - 163 chars

@bkail Yep, even simpler, not initializers at all.

@Malcolm,@bkil,@Wouter: class A{static int i;public static void main(String...a){new Thread(){public void run(){System.out.print("Hello World".charAt(i++));if(i<11)main();}}.start();}} - 160 chars

@Prince I thought about varargs, but it didn't come to my mind they could save some chars. By the way, you can only notify one user per comment with the @ notation. Also you don't have to notify me specifically because I am automatically notified about all the comments to my answers.

@PrinceJohnWesley Nice :-). I was looking for ways to get rid of that null, but I couldn't think of anything.

scala(81 79 chars)
def?(l:String){if(l.size!=0)new Thread{print(l(0));?(l.tail)}}
?("Hello World")

A little bit shorter:
def?(l:String){if(l.size>0)new Thread{print(l(0));?(l.tail)}}

@JoaEbert:yea,nice

Haskell (120 118)
import Control.Concurrent
t=threadDelay.(*3^8)
main=(\(x,y)->forkIO$t x>>putChar y)`mapM_`zip[0..]"Hello World">>t 99

I'm not all that sure about multiplying by 9999 - I have a 2Ghz Xeon on which it'll work fine even if you don't, but I also have a Pentium 4 that needs it (999 gave garbled output and 99 didn't do anything at all.)

Save 2 characters by using (*5^6) instead of (*9999) and not using backquotes for mapM_.

@Mechanicalsnail If you remove the backticks you need an extra pair of braces, otherwise it parses as (((mapM_ (\(x,y) ... )) zip) [0..]) ... which you don't want.

As for 999, it might be getting truncated to 0 due to operating system limitations, but I could be wrong.  What OS are you using?

Bash (64)
:(){ [ "$1" ]&&(echo -n "${1:0:1}"&: "${1:1}")};: "Hello World"

@marinus Golfed doen by 3 chars: :()([ "$1" ]&&(printf "${1:0:1}"&: "${1:1}"));: Hello\ World

@fossilet Works for me on both Linux and OSX, several bash versions.  The last one or two characters is sometimes printed after the shell prompt.

Groovy, 51 characters
"Hello World".each{a->Thread.start{print a}.join()}

D (135 chars)
import std.concurrency,std.stdio;
void main(){
    p("Hello World");
}
void p(string h){
    write(h[0]);
    if(h.length>1)spawn(&p,h[1..$]);
}

I only start the next thread when I have already printed the current char
edit +2 chars for better bound check

I get core.exception.RangeError@test.d(6): Range violation error.

@fossilet I fixed it

Scala 74
"Hello World".zipWithIndex.par.map(x=>{Thread.sleep(x._2*99);print(x._1)})

zipWithIndex produces ((H, 0), (e, 1), (l, 2) ...).
par makes it a parallel collection.

Tests:
(1 to 10).foreach {_ => "Hello World".zipWithIndex.par.map(x=>{Thread.sleep(x._2*99);print(x._1)});println()}
Hello World
Hello World
Hello World
...
Hello World

scala> "Hello World".zipWithIndex.par.foreach(x=>{Thread.sleep(x._2*99);print(x._1)}) Hel lWrolod - I got this

Also println(Thread.currentThread.getName) shows that the threads are not unique.

@PrinceJohnWesley: I guess you need one core per letter, so that par will distribute the work over all cores.

I got it. so one core per letter + high resolution of the system clock required.

use map instead of foreach. you can save 4 characters.

@PrinceJohnWesley: I don't think 100ms counts as high resolution system clock today. I just started 3 (1 to 10)-wrappers around the code, and all 30 ended in sync. Where did you run your code? Map: Okay, it's ideomatically wrong, but for 4 characters, maybe I should do it. ;)

it's nothing wrong saving 4 characters by ignoring return value. Also *99 is not required. small values will be mapped to low system resolution. i got wrong values only for the first time. Maybe it's because of start up issues.

Your solution does not guarantee that each character is printed using a different thread since the parallel collections are using a thread pool and work stealing so it is not predictable. Despite the 99 kittens that died for your Thread.sleep approach.

scala(45)
Thread#join based solution
"Hello World"map{x=>new Thread{print(x)}join}

or
for(x<-"Hello World")new Thread{print(x)}join

Javascript (72)
(function f(){console.log("Hello world"[i++]);i<11&&setTimeout(f)})(i=0)

This is my F# attempt. My first serious F# program. Please be kind.
let myprint c = async {
        printfn "%c"c
}
"Hello World"|>Seq.map myprint|>Async.Parallel|>Async.RunSynchronously|>ignore

C# 90 84
foreach(var c in"Hello World"){var t=new Thread(Console.Write);t.Start(c);t.Join();}

Running version: http://ideone.com/0dXNw

console.write is very fast which is why this may work for you but is definitely not thread safe!

@statichippo you're right; I fixed that.

Go
package main
import"fmt"
func main(){o:=make(chan int)
for _,c:=range"Hello World"{go func(c rune){fmt.Printf("%c",c)
o<-0}(c)}
for i:=0;i<11;i++{<-o}}

You don't need to count the characters - we will do so for you!

Erlang (90)
-module(h).
r()->r("Hello World").
r([])->'';r([H|T])->spawn(h,r,[T]),io:format("~c",[H]).

Compile erlc +export_all h.erl

Nimrod, 121
proc p(c:char){.thread.}=write(stdout,c)
for c in "Hello World":
 var t:TThread[char]
 createThread(t,p,c)
 joinThread(t)

Python: too many characters, but it works.
# Ok. First we patch Threading.start to test wether our solution actually works

import threading
import random, time
original_run = threading.Thread.run

def myRun(self):
    tosleep = random.randint(0,200)/1000.0
    time.sleep(tosleep)
    original_run(self)

threading.Thread.run = myRun

# And now the real code:
import time, sys, threading
string_to_write = "Hello World\n"
current_char_index = 0 # This integer represents the index of the next char to be written
# It will act as a semaphore: threads will wait until it reaches
# the index of the single char that particular thread is due to output

class Writer(threading.Thread):
    def __init__(self, char_to_write, index_to_write):
        self.char_to_write, self.index_to_write = char_to_write, index_to_write
        super(Writer, self).__init__()
    def run(self):
        ch = globals()['current_char_index']
        while not self.index_to_write == ch:
            time.sleep(0.005)
        sys.stdout.write(self.char_to_write)
        # This will be atomic because no other thread will touch it while it has "our" index
        globals()['current_char_index'] += 1

for i, char in enumerate(string_to_write):
    Writer(char, i).start()

I don't understand what the purpose of randomizing sleep time is.

@Joel to ensure that, when it works, it's not a lucky coincidence of the threads being executed in the same order as they were fired.

Objective-C (183 characters)
-(void) thread {[self performSelectorInBackground:@selector(printC) withObject:nil];}
-(void) printC {char *c = "Hello World"; for(int i = 0; c[i] != '\0'; i++) {printf("%c", c[i]);}}

Haskell 99 Characters
import Control.Concurrent
f[]=return()
f(x:xs)=(putChar x)>>(forkIO$f xs)>>f[]
main=f"Hello World"

How it works is each thread starts the next after having displayed its character, so they actually useful stuff can not happen out of sequence.

Bash, 43 bytes
xargs -n1 printf<<<'H e l l o \  W o r l d'

Try it online!
xargs forks a separate printf process for each character (and waits for it to exit).
Bash, 45 bytes, no external utilities
eval \(printf\ {H,e,l,l,o,\\\ ,W,o,r,l,d}\)\;

Try it online!
Expands to (printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d); before evaluation. The parentheses make Bash fork a subshell for each letter (and wait for it to exit), but this time printf is the Bash builtin.


text:
Adding, the old-fashioned way
Overview
The ancient Romans devised a number system using Latin letters, which served them well, and which is still used by modern civilization, though to a much smaller degree. In the time of its use, Romans would have had to learn to use and manipulate these numbers in order to be of much use for many applications. For example, if a man owned 35 oxen, and he procured 27 more, how would he know the new total other than counting them all? (Ok, that and using an abacus...) If the Romans could do it, surely we can figure it out as well.
Objective
Write the shortest algorithm/function/program that will add two Roman numerals together and output the result without converting the string representation of either input into a number.
Rules/Constraints
Because of historical/pre-medieval inconsistencies in formatting, I'm going to outline some non-standard (per modern usage) rules for orthography. See the value guide below as an example.

The letters I, X, C, and M can be repeated up to four times in succession, but no more. D, L, and V can never be repeated.
The letter immediately to the right of another letter in the Roman representation will be of the same or lesser value than that to its left.

In other words, VIIII == 9 but IX != 9 and is invalid/not allowed.

All input values will be 2,000 (MM) or less; no representation for numbers greater than M is necessary.
All input values will be a valid Roman numeral, pursuant to the rules above.
You may not convert any numbers to decimal, binary, or any other number system as part of your solution (you are welcome to use such a method to VERIFY your results).
This is code golf, so shortest code wins.

Value Guide
Symbol        Value
I             1
II            2
III           3
IIII          4
V             5
VIIII         9
X             10
XIIII         14
XXXXIIII      44
L             50
LXXXXVIIII    99
C             100
D             500
M             1,000

Examples
XII + VIII = XX (12 + 8 = 20)
MCCXXII + MCCXXII = MMCCCCXXXXIIII (1,222 + 1,222 = 2,444)
XXIIII + XXXXII = LXVI (24 + 42 = 66)

If any further clarification is needed, please ask.

XXXXIIII -> 44 or XIIII -> 14?

I think he's referring to a mistake in the value guide.

@grc Oh. Silly me... Fixed.

Why would anyone want to convert to a different base? Did you actually mean to prohibit parsing the string to a number?

@PeterTaylor Yes, that is correct.

IIII is not a roman numeral! I believe you are referring to IV. Look up Roman Numerals.

@PyRulez When I wrote this up two years ago, I did in fact look it up and this usage is not unheard of (though agreed, not the most common). http://en.wikipedia.org/wiki/Roman_numerals#Alternative_forms

APL (59 56)
,/N⍴⍨¨{∨/K←⍵≥D←7⍴5 2:∇⍵+(1⌽K)-K×D⋄⍵}⊃+/(N←'MDCLXVI')∘=¨⍞

Input on one line (i.e. XII + XII, though the + is not necessary).
Edit: changed shift to rotate to save three characters - it only matters when the answer ≥ 5000, which should never happen as the question says the input values will always be ≤ 2000.  The only effect is it now "overflows" at 5000, giving 5000=1, 5001=2, etc.
(I don't really think the Romans did it this way... APL is more something for Ancient Egyptians I think :) )
Explanation:

⍞: get user input
(N←'MDCLXVI')∘=¨: store 'MDCLXVI' in N. Return, for each character of the input string, a vector with a 1 in the place where the character corresponds to one of 'MDCLXVI', and 0 otherwise.
⊃+/: Sum the vectors and de-encapsulate. We now have a vector with information about how many of each Roman numeral we have. I.e, if the input was XXII XIIII, we now have:

     M D C L X V I
     0 0 0 0 3 0 6

Note that this is not converting the values.
{...:...⋄...} is a function with an if-else construct.
D←7⍴5 2: D is the vector 5 2 5 2 5 2 5. This is how many of a Roman numeral are not allowed. I.e. if you have 5 Is, that's too many, and if you have 2 Vs that's also too many. This vector also happens to be the multiplication factor for each Roman numeral, i.e. a V is worth 5 Is and an X is worth 2 Vs.
∨/K←⍵≥D: K is the vector where there's a 1 if we have too many Roman numerals of a certain kind. ∨/ ORs this vector together.
If this vector is not all zeroes:
K×D: Multiply K by D. This vector has zeroes where we don't have too many Roman numerals, and the amount of Roman numerals where we do.
⍵+(1⌽K): Rotate K to the left by 1, and add it to the input. For each Roman numeral we have too many, this will add one of the next-higher one.
⍵+(1⌽K)-K×D: Subtract this from the other vector. The effect is, for example if you have 6 Is, it will add one V and remove 4 Is.
∇: Recurse.
⋄⍵: But if K was all zeroes, then ⍵ represents a valid Roman numeral, so return ⍵.
N⍴⍨¨: For each element of the resulting vector, create that many of the corresponding Roman numeral.
,/: Join these vectors together to get rid of the ugly spaces in the output.

Python, 100
s="IVXLCDM"
r=raw_input()
a=""
i=2
u=0
for c in s:r+=u/i*c;i=7-i;u=r.count(c);a+=u%i*c
print a[::-1]

Takes one string from input (e.g. VIII + XII or VIII + XII =).

Ruby, 85 82 characters
gets;r=0;v=5;puts"IVXLCDM".gsub(/./){|g|r+=$_.count g;t=r%v;r/=v;v^=7;g*t}.reverse

This version takes input on STDIN as a single string (e.g. XXIIII + XXXXII) and prints output to STDOUT.
f=->*a{r=0;v=5;"IVXLCDM".gsub(/./){|g|r+=(a*'').count g;t=r%v;r/=v;v^=7;g*t}.reverse}

The second one is an implementation as a function. Takes two (or more) strings and returns the summed values. Usage:
puts f["XXIIII", "XXXXII"]     # -> LXVI

Perl, 132 chars
sub s{@a=VXLCDM=~/./g;@z=(IIIII,VV,XXXXX,LL,CCCCC,DD);$r=join"",@_;
$r=~s/$a[-$_]/$z[-$_]/gfor-5..0;$r=~s/$z[$_]/$a[$_]/gfor 0..5;$r}

Declares function s which takes any number of arguments and sums them. Pretty straightforward: it appends the input, reduces everything to Is and then immediately restores the Roman numerals. (Hopefully this doesn't count as using the unary number system!)

GNU Sed, 131 chars
:;s/M/DD/;s/D/CCCCC/;s/C/LL/;s/L/XXXXX/;s/X/VV/;s/V/IIIII/;t;s/\W//g;:b;s/IIIII/V/;s/VV/X/;s/XXXXX/L/;s/LL/C/;s/CCCCC/D/;s/DD/M/;tb

Python, 174 chars
A very simple algorithm - count each digit, loop to handle overflow to the next, print.
Reads from standard input. Something like XVI + CXX would work (ignores anything except numerals, so the + isn't really needed).
x="IVXLCDM"
i=raw_input()
d=dict((c,i.count(c))for c in x)
for c in x:
    n=2+3*(c in x[::2])
    if d[c]>=n:d[c]-=n;d[x[x.find(c)+1]]+=1
print"".join(c*d[c]for c in reversed(x))

Scala 150
val c="IVXLCDM"
def a(t:String,u:String)=((t+u).sortBy(7-c.indexOf(_))/:c.init)((s,z)=>{val i=c.indexOf(z)+1
s.replaceAll((""+z)*(2+i%2*3),""+c(i))})

invocation:
a("MDCCCCLXXXXVIIII", "MDCCCCLXXXXVIIII")

ungolfed Version:

val c = "IVXLCDM"
def add (t:String, u:String) = (
  (t+u).  // "MDCCCCLXXXXVIIIIMDCCCCLXXXXVIIII"
  sortBy(7-c.indexOf(_)) // MMDDCCCCCCCCLLXXXXXXXXVVIIIIIIII
  /: // left-fold operator to be used: (start /: rest) ((a,b)=> f (a,b))
  c.init) /* init is everything except the rest, so c.init = "IVXLCD"
    (because M has no follower to be replaced with */
  ((s, z) => { /* the left fold produces 2 elements in each step,
    and the result is repeatedly s, on initialisation
    MMDDCCCCCCCCLLXXXXXXXXVVIIIIIIII
    and z is the iterated element from c.init, namely I, V, X, L, C, D
    in sequence */
    val i = c.indexOf (z) + 1 // 1, 2, ..., 7
    /* i % 2 produces 1 0 1 0 1 0
       *3 => 3 0 3 0
       +2 => 5 2 5 2
       (""+ 'I') * 5 is "IIIII", ("" + 'V') * 2 is "VV", ...
       ""+c(i) is "V", "X", ...
    */
    s.replaceAll (("" + z) * (2+i%2*3), "" + c (i))
    }
  )

VBA, 187 chars
Function c(f,s)
a=Split("I,V,X,L,C,D,M",",")
z=f & s
For i=0 To 6
x=Replace(z,a(i),"")
n=Len(z)-Len(x)+m
r=IIf(i Mod 2,2,5)
o=n Mod r
m=Int(n/r)
c=String(o,a(i)) & c
z=x
Next
End Function

As o is only used once, you cans save 3 bytes by removing the assignment and evaluation of it and plugging n Mod r Directly into the String( function call

JavaScript 195 179
My system is fairly rudimentary, reduce all Roman numerals to a series of I for both numbers, join them up and then reverse the process turning certain blocks of I into their respective larger versions...
Iteration 1

a="IIIII0VV0XXXXX0LL0CCCCC0DD0M".split(0);d=b=>x.replace(g=RegExp((c=z)>b?a[c][0]:a[c],"g"),c>b?a[b]:a[b][0]);x=prompt().replace("+","");for(z=6;0<z;z--)x=d(z-1);for(z=0;6>z;z++)x=d(z+1);alert(x)

Iteration 2
a="IIIII0VV0XXXXX0LL0CCCCC0DD0M".split(0);x=prompt().replace("+","");for(z=-6;6>z;z++)b=0>z?-z:z,c=0>z?~z:z+1,x=x.replace(g=RegExp(b>c?a[b][0]:a[b],"g"),b>c?a[c]:a[c][0]);alert(x)
Features:

Zero delimited array string, quicker than setting up a string array.
Reduced the two recursions to the one, and recalculating the parameters for the specific regex.
More ternary operators than you can poke a stick at!

Input is entered via prompt in the form of <first roman number>+<second roman number> (no spaces), output in the form of an alert.
e.g.
XVI+VII // alert shows XXIII, correct!
MCCXXXIIII+DCCLXVI // alert shows MM, also correct!

JavaScript, 190
x=prompt(r=[]);p=RegExp;s="MDCLXVI";for(i=-1;++i<7;){u=x.match(new p(s[i],'g'));if(u)r=r.concat(u)};for(r=r.join("");--i>0;){r=r.replace(new p(s[i]+'{'+(i%2==0?5:2)+'}','g'),s[i-1])}alert(r)

Putting some instruction inside the third slot of the for operator let me save some semicolons!
When the input prompts, you insert the two numbers (the + and spaces are not necessary, but if you put them you don't get an error). Then the alert show you the sum.

C++, 319 chars
#define A for(j=0;j<
#define B .length();j++){
#define C [j]==a[i]?1:0);}
#include <iostream>
int main(){std::string x,y,s,a="IVXLCDM";int i,j,k,l,m=0,n;std::cin>>x>>y;for(i=0;i<7;i++){k=0;l=0;A x B k+=(x C A y B l+=(y C n=k+l+m;m=(n)%(i%2?2:5);for(j=0;j<m;j++){s=a[i]+s;}m=(n)/(i%2?2:5);}std::cout<<s<<"\n";return 0;}

PHP, 136 Bytes
for($r=join($argv);$c=($n=IVXLCDM)[$i];$r.=$p($n[++$i],$z/$d))$t=($p=str_repeat)($c,($z=substr_count($r,$c))%($d="52"[$i&1])).$t;echo$t;

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
De-Nesting Lists
Given a list with lists nested inside it, return the list with the nested lists' items  de-nested.
Input
The list will have, at most, 4-deep nested lists. Count all 0's within the input as a null space.
Output
Individually print out each item. Do not print out the output as a list. You can seperate each item with any kind of whitespace.
Example Cases
[[1, 0], [2, 0], [2, 3]] -> 1 2 2 3
[[[4, 5, 8]], [[5, 6, 20]], [[1, 20, 500]]] -> 4 5 8 5 6 20 1 20 500
[[[1, 0], [0, 0], [0, 0]], [[1, 0], [1, 2], [2, 0]], [[2, 0], [0, 0], [0, 0]]] -> 1 1 1 2 2 2
The shortest code wins.

You should include at least one example of a 4-deep list. If I understood correctly, a 4-deep is something like [[[[5]]]], right?

[[[[5]]]] works on https://tio.run/##bY47DoAwDEN3TuGBial8ijgAIzdADKgr0ArKFOXsJaUIMbBYjvVsxZslBLdbgx4DyNjNzB5U8Phr82GaOCzr7CKdEZVQDKoerZklowYaHUtCGi0qddtSDLSS42ZSUb2akHgJ@Ey@yx8sdklzXJHInf7A2EP@4nAB but not on https://tio.run/##TY47DoAwDEN3TuGBial8ijgAIzdADFVXPhWUKcrZS1oQsFiO9WzF2zkEt28WPQaQ3VZrPKjg8bP5MHGYF@MikRGVUAyqHq2ZJaMGGh1LQhotKpVsKQZayZGYu6hevZF4CfhMvss/LHZJc1yRyJ3@wNgjvXUB

Hard to recognize that Count all 0's within the input as a null space. mean ignore zeros

IMO this answer does not add too much to ^

 APL (10)
0~⍨⍎⍞~'[]'

Explanation:

⍞~'[]': User input (⍞) without (~) the characters '[]'
This gives something like '1,2,0,2,3'
⍎: Evaluate this string. It so happens that , is the concatenation operator, so now we have a list: 1 2 0 2 3 (APL lists are whitespace-separated by default)
0~⍨: Remove all the numbers 0 from this list. (It is a list of numbers, not of strings,  by now, so zeroes within numbers are not removed.
This value is output (by default, because it's the value of the whole program, kind of like Golfscript). APL lists are whitespace-separated by default so it looks exactly like in the question.

Shortest answer, so this one takes the cake. For all non-answers, I've given a + if your code was really short or creative.

Sed, 20 chars
Solution is based on POSIX Extended Regular Expression.
s;[^0-9]+0|[],[]+;;g

Output:
bash-3.2$ sed -rf sedFile <<< "[[[4, 5, 8]], [[5, 6, 20]], [[1, 20, 500]]]"
4 5 8 5 6 20 1 20 500

Edit:
POSIX Basic Regular Expression(@clueless's solution), 19 chars:
s/[^0-9][^1-9]*/ /g

s/[^0-9][^1-9]*/ /g also works, and doesn't require extended regular expressions.

Python, 45
w00, exception handling in golf!
def d(x):
 try:map(d,x)
 except:print`x`*(x!=0)

Very clever way of checking for types.

I like the solution, though I do think it's cheating to not include a d(input()) line in the character count.

The challenge is vague... nay, contradictory, when it comes to I/O.

Perl, 20 16 13 chars
perl -ple 's/\D+0?/ /g'

The -l switch is necessary to preserve the final newline in the output.
Here's an alternate version that actually works with the lists semantically (51 chars).
perl -E '$,=$";sub p{map{ref$_?p(@$_):$_||""}@_}say p eval<>'

Both of these programs take advantage of the problem's stipulation that it "can separate each item with any kind of whitespace", and replaces the zeros with blanks, instead of removing them outright.

K, 12
{x@?&x:,//x}

.
k){x@?&x:,//x}((1;0);(2;0);(2;3))
1 2 2 3
k){x@?&x:,//x}(((4;5;8));((5;6;20));((1;20;500)))
4 5 8 5 6 20 1 20 500
k){x@?&x:,//x}(((1;0);(0;0);(0;0));((1;0);(1;2);(2;0));((2;0);(0;0);(0;0)))
1 1 1 2 2 2

Depending on the version of k, you may be able to make use of "except" (x^y) like so: {(,//x)^0} or even {,/x^0}/. Works in https://johnearnest.github.io/ok/index.html

Perl 13, 14 char dit: p count for one char
s/\D+|\b0/ /g

usage:
cat '[[1, 0], [2, 0], [2, 3]]' | perl -pe 's/\D+|\b0/ /g'

Well done. Though your count is actually 14 chars (you need to include the p switch in the count).

@breadbox: Yes, you're right. I missed that.

With echo instead of cut, it even would work - neutral operation in char count.

Ruby, 38 characters
puts eval(gets).flatten.reject &:zero?

The numbers are printed separated by a line break.

Golfscript  15
~{[]*}4*{},' '*

Input
Run from the command line, like so:
echo [[[1 0] [0 0] [0 0]] [[1 0] [1 2] [2 0]] [[2 0] [0 0] [0 0]]] | ruby golfscript.rb x.gs

(assumung that the x.gs file contains the code presented above).
Note that there are no commas (,) when defining the arrays; that's Golfscript syntax
Output
When the command described in the Input section is issued, the output is:
1 1 1 2 2 2

Python 3, 49 chars
import re
print(*re.findall('[1-9]\d*',input()))

Python 2, 58 chars
import re
print re.sub('\D[^1-9]*',' ',raw_input())[1:-1]

Japt, 5 bytes
c f ¸

Test it

Explanation
Implicit input of array U. Flatten the array with c. Filter it with f to remove the 0s. Join it to a string using spaces with ¸. Implicit output of resulting string.

Java 10, 106 bytes
void c(Object i){for(var o:(Object[])i)try{System.out.print((int)o>0?o+" ":"");}catch(Exception e){c(o);}}

Input as nested Object[], output printed to STDOUT.
Try it online.

46 bytes
s->s.replaceAll("[^0-9 ]","").replace(" 0","")

Input and output both as String.
Try it online.

@Giuseppe Oops.. That's a pretty stupid mistake. Should be fixed now.

C, 45 chars
for(;s=strtok(s,"[], ");s=0)atoi(s)&&puts(s);

It assumes that the input is given in a modifiable memory area pointed by s.

Shouldn't the answer be a program, or at least a function? If fails for the number 01 (seems legal to me). And *s-49&&puts(s) is shorter.

@ugoren I didn't find any requirements restricting an answer to complete programs/functions only. Are there any?

@ugoren Rewritten to cope with numbers with leading zeros. And thanks for shortening suggestion!

Python, 99 111 chars
def d(l):
    if list==type(l):return[y for x in l for y in d(x)]
    return[str(l)]*(l!=0)
print" ".join(d(input()))

Previous 99 char version - fails when lists with zeros only are included:
d=lambda l:list==type(l)and[y for x in l for y in d(x)]or[str(l)]*(l!=0)
print" ".join(d(input()))

d(l) recursively flattens the list l, while filtering zeros and converting numbers to strings.

It returns 1 [0, 0] [0, 0] 1 1 2 2 2 [0, 0] [0, 0] for the third test case.

@beary605, I just skipped this one test... I use a and b or c instead of C's a?b:c, but it fails when b evaluates to false (empty list in this case).

Scala, 42 chars
Tokenized the string by non digits and non-digit followed by zero.
print(readLine split"\\D|\\b0"mkString" ")

Prolog (79)
It inputs the list as a term, so you need to put a '.' after the list in the input.
Actually does list flattening.
x([H|T]):-x(H),x(T).
x(0). x([]).
x(M):-write(M),put(32).
:-read(X),x(X),halt.

APL (Dyalog), 4 bytes
0~⍨∊

Try it online!
0~⍨ zeros removed from
∊ the ϵnlisted (flattened) data

Stax, 2 bytes
$f

Run and debug it
$ is flatten.  f is filter out falsey values and print on separate lines.

Vyxal S, 2 bytes
fꜝ

Try it Online!

bash: 29 chars
l=$(echo "[[[1, 0], [0, 0], [0, 0]], [[1, 0], [1, 2], [2, 0]], [[2, 0], [0, 0], [0, 0]]]")
echo $l|tr -d '][,'|sed 's/\b0\b/ /g'
1           1   1 2 2   2

counting line 2 only withtout 'echo $l |'.
Test for 3 samples:
  1    2    2 3
   4 5 8   5 6 20   1 20 500
   1               1    1 2  2     2

Scala 147:
Working on real lists, not on strings:
def f[A](l:List[_]):List[_]=l match{
case Nil=>l
case(l:List[_])::s=>(f(l):::f(s))
case e::s=>e::f(s)}
def p(l:List[_])=f(l)filter(!=0)mkString " "

Now the testdata:
val l1 = List (List (1, 0), List (2, 0), List (2, 3))
val l2 = List (List (List (4, 5, 8)), List (List (5, 6, 20)), List (List (1, 20, 500)))
val l3 = List (List (List (1, 0), List (0, 0), List (0, 0)), List (List (1, 0), List (1, 2), List (2, 0)), List (List (2, 0), List (0, 0), List (0, 0)))
val l4 = List (l1, l2, l3)

scala> l4.map(p)
res94: List[String] = List(1 2 2 3, 4 5 8 5 6 20 1 20 500, 1 1 1 2 2 2)

scala> p(l4)
res95: String = 1 2 2 3 4 5 8 5 6 20 1 20 500 1 1 1 2 2 2

Tcl, 47 bytes
proc D L {concat {*}[concat {*}[concat {*}$L]]}

Try it online!
Assuming 4-deep is something like {{{{5}}}}. As there is no example of such thing on test cases it may be something like {{{5}}}; if it is I can make my code shorter!

Tcl, 66 bytes
proc D L {lsearch -al -inl -not "[string map {\{ "" \} ""} $L]" 0}

Try it online!

Pyth, 5 bytes
jfT.n

Test suite

R, 29 bytes
function(l)(x=unlist(l))[!!x]

Try it online!
unlist converts the list to an atomic vector recursively, so we just need to filter out the zero elements.

JavaScript (Node.js), 53 bytes
function(x){return(','+x+',').replace(/,(0,)*/g,' ')}

Try it online!

Brachylog, 8 bytes
ċ∋↰|ℕ₁ẉ⊥

Try it online!
Takes input through the input variable and prints the output separated by newlines. Ordinarily I'd complain about the output format, but it actually saved me a byte in a way I might not have thought to otherwise--putting ẉ⊥ on the end is shorter than wrapping it in {}ᶠ.
ċ           If the input is a list,
 ∋          pick some element of it
  ↰         and recur with it as the input.
   |        Otherwise, if the input
    ℕ₁      is a natural number,
      ẉ     print it with a trailing newline
       ⊥    then trigger backtracking.

If the list items aren't restricted to being non-negative integers:
Brachylog, 11 bytes
ċ!∋↰|0!⊥|ẉ⊥

Try it online!

PHP, 70 bytes
function($a){array_walk_recursive($a,function($a){echo$a?"$a ":'';});}

Try it online!
This isn't going to be the shortest (nor the longest), but figured it would be a chance to get to use array_walk_recursive(), which until today I can't think of ever having a use for it!  At least it should be able to handle an arbitrary level deep nested lists.

Wolfram Language (Mathematica), 37 bytes
Flatten/*DeleteCases[0]/*StringRiffle

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Remove vowels without using too many different characters
The challenge is to remove vowels (a, e, i, o, u) from string from STDIN (yes, I know, simple). You can expect that your program will be not ran with any arguments in argv.
Example:
This program will remove VOWELS.
So we can now speak without them.

Is changed to:
Ths prgrm wll rmv VWLS.
S w cn nw spk wtht thm.

There is a catch. The winning entry is decided basing on number of different bytes. For example a ab has three different bytes (a, b and space). If two or more entries will have this same ammount of different bytes, then fallback is done on number of bytes for those entries.

A job for Whitespace language

What about input like Renée’s naïveté? Stripped of vowels, that should of course be  Rn’s nvt as output. Seem like these approaches are all pretty ahem naïve if you ask me. :)

If you remove é, you might want to remove y too.

@tchrist, read the question.  Says to remove a,e,i,o,u.  You're off topic, please drop it.

@boothby I did read the question. It doesn’t say what should be done with naïve: remember that is a six-character string with a COMBINING DIAERESIS. If you blindly strip the vowels, it sticks an umlaut on the  n.  Is that what is intended?

@tchrist: Especially the challenge didn't say "all vowels" and enumerated what we should consider as removable.

@J.F.Sebastian Ook would run a close second.

Binary Whitespace (2 distinct chars, 324 total chars)
TTSSSTTSSSSTTTSTTTSSSSSSTTSSSTSSSSSSTSTTSSSTSSSSTSSTSTTSSSTSSSTSSSTSTTSSSTSSSTSTSTSTSTTSSSTSSTSSTSSTSTTSSSTSTSSSSSTSTTSSSTSTSSSTSSTSTTSSSTSTSSTSSSTSTTSSSTSTSSTSTSTSTSTTSSSTSTSTSSTSSTSTTTTSSSTSTTSTTSTTTSSTSTTSSSSTTTSTSTSTSSSTSTTTSSTTTTSTTSTSTTTTSSTTTTTSSSTTTTSTTTTTTSSTSTTSSSSTTTSTSTSSTTSTTTSSSSTTTSTTSSTTSTTSTTTTSSSSTTTTTTTT
where S,T,L denotes Space,Tab,Linefeed, respectively. (Shamelessly obtained by converting the Whitespace answer by "breadbox" into Binary Whitespace -- this posting should probably be a comment to his answer, but it's too long.)
Binary Whitespace is Whitespace converted to a prefix-code language by everywhere using TS instead of T and using TT instead of L; e.g. the BWS instruction to push -5 onto the stack is SSTSTSSTSTT instead of SSTTSTL, etc. Link: A both-ways translator for an arbitrary 3-symbol language and its binary prefix-code versions [archive].
NB: It would be straightforward to design a true bitwise interpreter for Binary Whitespace programs regarded as bit-sequences, rather than char-sequences (e.g. using 0,1 bit-values instead of S,T characters, respectively). The above would then be a 324-bit program requiring 41 bytes of storage.

Brainfuck, 8 distinct (2121 total)
>,+[-<>>>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>[-]++<[-<+>>>>->>>->>>->>>->>>->>>->>>->>>->>>->>>-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>[<<<]+>-[<-<.>>-]<[<<<]<[-]>,+]

The distict characters: <>+-[],.. Works with interpreters that use -1 for EOF.

$ echo '
  This program will remove VOWELS.
  So we can now speak without them.
  ' | bf vowel-rm.bf

  Ths prgrm wll rmv VWLS.
  S w cn nw spk wtht thm.

+1 for nice language choice :). I've pretty much expected this, but...

+1 Well done! I didn't see that coming. :)

By the requirements as stated, this is the best answer; but OTOH it's the worst in that it uses every syntactically-significant character in its language.

That doesn’t seem to get the correct answer when supplied with Renée’s naïveté as input.

@tchrist: It assumes ASCII. Anyway, only {a, e, i, o, u} are in the requirements.

So it’s ok to turn Renée’s naïveté into Rń’s n̈vt́, then? That doesn’t seem right to me, but if you say so. Since you can’t assume any normalization, it is perfectly reasonable that Renée’s naïveté is really "Rene\N{COMBINING ACUTE ACCENT}e\N{RIGHT SINGLE QUOTATION MARK}s nai\N{COMBINING DIAERESIS}vete\N{COMBINING ACUTE ACCENT}" — or if you prefer magic numbers, "Rene\x{301}e\x{2019}s nai\x{308}vete\x{301}". If you remove the vowels without their attendant diacritics, you get extreme silliness. Welcome to the Brave New Millennium! :)

Use Unary, you'd only have one distinct character! :-P http://esolangs.org/wiki/Unary

@marinus, I've converted this to Unary and I just needed 1.166921663690E+1824 bytes to store it (I've uploaded exact number to pastebin, it wouldn't fit in this comment). I wonder how much time it would take to send it to this site.

Whitespace, 3 points (218 chars)
You knew it was coming.
↲___↲____↲⇥↲⇥_____↲___⇥_____⇥↲___⇥___⇥_⇥↲___⇥__⇥__⇥↲___⇥__⇥⇥⇥⇥↲___⇥_⇥_⇥_⇥
↲___⇥⇥____⇥↲___⇥⇥__⇥_⇥↲___⇥⇥_⇥__⇥↲___⇥⇥_⇥⇥⇥⇥↲___⇥⇥⇥_⇥_⇥↲↲___⇥↲_↲_↲⇥_⇥↲___
_↲⇥⇥⇥⇥__⇥↲⇥_↲↲_↲_⇥↲↲__↲↲⇥__↲↲_↲↲↲__⇥↲____↲⇥⇥⇥_↲_↲⇥___↲⇥↲__↲_↲_↲↲____↲↲↲↲

(_ = space, ⇥ = tab, ↲ = newline)
Here's the script encoded in base64:
CiAgIAogICAgCgkKCSAgICAgCiAgIAkgICAgIAkKICAgCSAgIAkgCQogICAJICAJICAJCiAgIAkg
IAkJCQkKICAgCSAJIAkgCQogICAJCSAgICAJCiAgIAkJICAJIAkKICAgCQkgCSAgCQogICAJCSAJ
CQkJCiAgIAkJCSAJIAkKCiAgIAkKIAogCgkgCQogICAgCgkJCQkgIAkKCSAKCiAKIAkKCiAgCgoJ
ICAKCiAKCgogIAkKICAgIAoJCQkgCiAKCSAgIAoJCiAgCiAKIAoKICAgIAoKCgo=

And here's the program written in visible assembler-like form:
ioloop: charin  0
        push    0, 'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'
ckloop: dup
        jz      out
        get     0
        sub
        jz      skip
        jump    ckloop
skip:   jz      ioloop
        jump    skip
out:    get     0
        dup
        jz      done
        charout
        jump    ioloop
done:   exit

Smells like Acme::Bleach to me. :)

When I convert your "symbolic" program to Whitespace, it has fatal syntax errors.

That's odd. Did you remember to remove the actual newlines before doing the conversion? I should just include a base64-encoding of the actual script.

Yes, I did that -- your base64 version decodes into exactly what I'm using. Here's an "STL" version (with S,T,L coding Space,Tab,Linefeed respectively): LSSSLSSSLTLTSSSSLSSSTSSSSSTLSSSTSSSTSTLSSSTSSTSSTLSSSTSSTTTTLSSSTSTSTSTLSSSTTSSSSTLSSSTTSSTSTLSSSTTSTSSTLSSSTTSTTTTLSSSTTTSTSTLLSSSTLSLSLTSTLSSSLTTTTSSTLTSLLSLSTLLSSLLTSSLLSLLLSSTLSSSLTTTSLSLTSSSLTLSSLSLSLLSSSSLLLL. It appears that two problems (among others) are that you're trying to push a 0 onto the stack using SSSL instead of SSSSL, and also trying to define an "empty" label by using LSSL for skip.

Oh, right. I forgot about that. Many whitespace interpreters accept SL for zero (including the prebuilt Linux binary, which is the one used on golf.shinh.org). Since it doesn't matter for this problem, I'll use the longer SSL form for zero.

Sorry for the delay ... I just confirmed that indeed Edwin Brady's Version 0.3 (Linux binary) of the Whitespace interpreter  does indeed run your program without complaint. I've been using the Ruby implementation (available at the same page), which disallows the syntax you're using.

SED (10 distinct bytes, 13 total)
s/[aeIou]//gI

Sample usage:
echo The quick brown fox jumps over the lazy dOg. | sed -e s/[aeIou]//gI

outputs:
Th qck brwn fx jmps vr th lzy dg.

Just wondering, why I is uppercase? It works fine when I characters are lowercase.

@GlitchMr I just did that to emphasize that the I character is reused.

Good.  Now, how do you make that work for Renée’s naïveté?

@tchrist I don't think the OP mentioned French vowels in his post. Also, I like writing naïve programs. :-)

True, but he didn’t rule them out either. English text can contain diacritics, as I’ve shown. Would you like a zoölogist’s perspective on reïnvigorating a snail’s DNA using a splice from a jalapeño?  It makes for the tastiest escargot, especially with a nice Curaçao chaser!

I'm pretty sure ö and ï are misused in your example and the other two are consonants. Still, I think you have a point. But this way we may end up supporting ò̟̣̱͉̙t̝͔͖͇͙̦̝h̵̩e͎r͓̥ ̱̼̞̰̠͔k̞̝̮̕i̴̘̟̬̠n̻͜d̦̰̼̰͔s͈̺̝̭ ̫̺͔̠̭̖o̼f̲͘ ͓̮v̳̙͔̝o͔̭̫͕͢ẃ̜͉̪̩̗e̻͔̺̬̣ĺs͖̭̮ as well; perhaps even ,,slǝʍoʌ uʍop ǝpısdn,, :-)

@w0lf, those uses of ö and ï were once found in English, though they've nearly disappeared now.

C, 22 20 19 distinct characters.
Letters needed for main, putchar, getchar = 12.
Punctuation - (){}; = 5.
Operators - &-= 2.
i;ii;
p(c){
    (c&ii-(-ii-ii))-(i-ii-ii-ii-ii-ii-ii)&&
    (c&ii-(-ii-ii))-(i-ii-ii-ii-ii-ii-ii-i-i-i-i)&&
    (c&ii-(-ii-ii))-(i-ii-ii-ii-ii-ii-ii-ii-(-i-i-i))&&
    (c&ii-(-ii-ii))-(-ii-ii-ii-ii-ii-ii-ii-i-i)&&
    (c&ii-(-ii-ii))-(i-ii-ii-ii-ii-ii-ii-ii-ii-(-i-i))&&
    putchar(c);
}
a(c){c-i&&n(p(c));}
n(c){a(getchar());}
main(){
    n(i---ii---ii---ii---ii---ii---ii---ii---ii---ii---ii---ii---i);
}

main invokes undefined behavior (too much -- in one line).
I don't care about the expression value, and it does decrement ii the right number of times.
Can be fixed easily by separating the decrements with ;. But it's so much nicer as it is.
Old version, 20 characters:
Actually 21, because I didn't notice that some spaces are significant and must be counted, but they can be replaced with parentheses easily.
ii;iii;c;a;
main(i){
    i=c;i-=--c;
    ii=-i-i-i-i-i-i-i-i-i-i-i;
    iii=i-ii-ii-ii-ii-ii-ii-ii-ii-ii-ii;
    -(c=a=getchar())-i&&main(
        (c&=ii- -ii- -ii)- -            a&&
        -ii-ii-ii-ii-ii-ii-  i-         c&&
        -ii-ii-ii-ii-ii-ii- -i- -i- -i- c&&
        iii- -ii- -ii- -ii-  i-i-i-i-i- c&&
        iii- -ii- -ii- -ii- -i-         c&&
        iii- -ii- -ii-       i-i-i-i-   c&&
        putchar(a));
}

Can perhaps be improved further, by compiling with gcc -nostartfiles, and renaming main to _start. min are removed (after some variable renaming), _s added. But then I need to use exit(), which adds 3 chars.
Instead of _start, any name can be used, and it works in Linux. This allows going down to 18 chars, but is very non-standard.

Perl: 8 or 10 distinct characters
s/// solution: 10 distinct, 13 total
The (purported; see below) sed technique always works in perl, too, and yields the name number of distinct characters (10):
s/[aeiou]//gi

For example:
$ echo 'This program will remove VOWELS. So we can speak without them.' |
  perl -ple 's/[aeiou]//gi'
Ths prgrm wll rmv VWLS. S w cn spk wtht thm.

That’s 10 distinct characters, as this proves:
$ echo 's/[aeiou]//gi' | perl -nle '@s{split//}=(); print scalar keys %s'
10

The problem with the sed solution is that its /i is not part of POSIX sed, and thus is not portable:
$ echo 'This program will remove VOWELS. So we can speak without them.' |
  sed -e 's/[aeiou]//gi'
sed: 1: "s/[aeiou]//gi": bad flag in substitute command: 'i'

That’s running on an OpenBSD system.  In contrast, because /i is indeed always part of standard perl, you can count on its always being there. Unlike sed.
If you want to include “y” in the list of vowels, it is of course one greater if you use the same technique:
$ echo 'This nifty program remove any VOWELS. So we easily can speak without them.' |
  perl -ple 's/[aeiouy]//gi'
Ths nft prgrm rmv n VWLS. S w sl cn spk wtht thm.

$ echo 's/[aeiouy]//gi' | perl -nle '@s{split//}=(); print scalar keys %s'
11

And it is now 14 total characters.
tr[][] solution: 8 distinct 10 total
You could also use tr/// to remove anything it matches. Perl can even use sed’s y/// alias for tr:
y/aeiou//d

which is now 8 distinct characters, but does’t work on uppercase.  You end up having to add 5 more characters to cope with the casemaps:
$ echo 'y/aeiouAEIOU//d' | perl -nle '@s{split//}=(); print scalar keys %s'
13

and of course that’s now 15 total.
However, adding “y” to the mix as a vowel doesn’t up the number of distinct characters as it did with the s/// version:
$ echo 'This nifty program remove any VOWELS. So we easily can speak without them.' |
  perl -ple 'y/aeiouy//d'
Ths nft prgrm rmv n VOWELS. S w sl cn spk wtht thm.

So that’s still just the original 8 distinct out of 11 total:
$ echo 'y/aeiouy//d' | perl -nle '@s{split//}=(); print scalar keys %s'
8

EDIT: Accounting for Diacritics
And what about inputs like Renée’s naïveté? The correct output should of course be Rn’s nvt.  Here’s how to do that, using v5.14’s /r flag for s///:
$ echo 'Renée’s naïveté' |
  perl5.14.0 -CS -MUnicode::Normalize -nle 'print NFD($_)=~s/[aeiou]\pM*//rgi'
Rn’s nvt

That’s 27 distinct characters:
$ echo 'print NFD($_) =~ s/[aeiou]\pM*//rgi' |
  perl -nle '@s{split//}=(); print scalar keys %s'
27

You can trim that to 26 if you can guarantee that you’re running at least v5.10 by swapping out the print for a say:
$ echo 'Renée’s naïveté' |
  perl -Mv5.14 -CS -MUnicode::Normalize -nlE 'say NFD($_) =~ s/[aeiou]\pM*//rgi'
Rn’s nvt

$ echo 'say NFD($_) =~ s/[aeiou]\pM*//rgi' |
  perl -nle '@s{split//}=(); print scalar keys %s'
26

And you can get it down to 22 if you don’t mind moving the diacritics instead of removing them:
$ echo 'Renée’s naïveté' |
  perl -Mv5.14 -CS -MUnicode::Normalize -nlE 'say NFD($_) =~ s/[aeiou]//rgi'
Rń’s n̈vt́

Which is ... interesting to look at, to say the least. :)  Here’s its distinct-count:
$ echo 'say NFD($_) =~ s/[aeiou]//rgi' |
  perl -nle '@s{split//}=(); print scalar keys %s'
22

Good luck getting any other language to properly deal with diacritics using fewer characters than this!

ɢᴏᴏᴅ ᴘₒᵢⁿᵗ αβουτ    ,      ℍ?

@leftaroundabout Most of that’s fixed by committing to an NFKD decomposition. The Greeks don’t count though they’re lookalikes, and the smallcaps don’t decompose to regulars. The result is "ɢᴏᴏᴅ ᴘnt αβουτ dcrtcs y gt thr, bvt hw bt stff lk THS", or "\N{LATIN LETTER SMALL CAPITAL G}\N{LATIN LETTER SMALL CAPITAL O}\N{LATIN LETTER SMALL CAPITAL O}\N{LATIN LETTER SMALL CAPITAL D} \N{LATIN LETTER SMALL CAPITAL P}nt \N{GREEK SMALL LETTER ALPHA}\N{GREEK SMALL LETTER BETA}\N{GREEK SMALL LETTER OMICRON}\N{GREEK SMALL LETTER UPSILON}\N{GREEK SMALL LETTER TAU} dcrtcs y gt thr, bvt hw bt stff lk THS".

But are there are some Latin vowels that don't have compatibility decompositions, such as ø.

@dan04 True, although ø (and ǿ) both have a primary collation strength that is equal to that of o in the DUCET used by the Unicode Collation Algorithm. Similarly with the insular letters, the combining letters, the small caps, etc: in all cases, the UCA1 strength would work better than either NFD or even NFKD. We don’t get that till Level 3 in tr18, although I’d like to get it at Level 2 somehow. And of course, if it were Welsh, they’d need w to be a vowel. Many languages that use the Latin script have “interestinger” notions of vowels than we may be used to.

challenge doesn't say to remove vowels with diacritics -- just a,e,i,o,u -- so Renée’s naïveté should give Rné’s nïvté.

Why would greek vowels not count, if äèïóű etc. (not in [a,e,i,o,u]!) do? Or Cyrillic, for that matter (which aren't lookalikes, but sure enough vowels).

GolfScript (7 distinct bytes, 103 total)
Sufficiently much of an improvement over w0lf's answer that I think it qualifies as a separate one:
[9-99))--9+99))99))))))99)9+))9-9)99--)99-9+9--9+9-))99-9+9)))--9+99-9+-9+9-)99-9+9)))-)99)9-9-)))]''+-

12 distinct bytes, 13 total:
'aeiouAEIOU'-

Great! I wish I could upvote you again.

Golfscript (8 distinct bytes, 837 total)
[9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) 9))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))]''+-

Explanation:

The program creates the following array of integer values: [97 101 105 111 117 65 69 73 79 85] (corresponding to the ASCII codes of a,e,i,o,u,A,E,I,O,U). Each number is represented by pushing on stack the value 9, followed by the needed number of ) (increment operators). For example, the number 67 is obtained using 9 and 58 )s
Using ''+, the array is converted into the string "a,e,i,o,u,A,E,I,O,U", representing all vowels
The subtraction sign ('-') is then used to subtract all vowels from the source string

The 8 unique characters that were used: [,],9,),+,-,' and (space)

Unreadable (2 distinct, 2666 total)
Since everyone is posting Turing tarpits, I thought I'd use this one. It's not a very well-known one but it does exist ( http://esolangs.org/wiki/Unreadable ) and it has only two characters.
'""""'""""'""""'""""""'"""'""'""'""'""'""'""'""'""'""'"""'""""'"""""'"""""""'"""'""""'"""
"'""""'""""""'"""'""""""""'"""""""'"""'""""""'""'"""'""'""'""'""'""'""'"""""""'""'"""'"""
"'""""""'""'""'"""'""'""'""'""'""'""'""'"""""""'""'""'"""'""""""'""'""'""'"""'""'""'""'""
'""'""'""'""'"""""""'""'""'""'"""'""""'""""'""""""'""'""'""'""'"""'""'""'""'""'""'""'""'"
"'""'"""""""'""'""'""'""'"""'""""""'""'""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""""
"""'""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'""'"""'""'""'""'""'""'""'""'""'""'""'""
'"""""""'""'""'""'""'""'""'"""'""""""'""'""'""'""'""'""'""'"""'""'""'""'""'""'""'""'""'""
'""'""'""'"""""""'""'""'""'""'""'""'""'"""'""""""'""'""'""'""'""'""'""'""'""'""'"""'"""""
"""'""""""""'"""""""'""'""'""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'""'""'""'""'"""'
""'""'"""""""'""'""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'""'""'""'"""'""""""""'""""
""""'""""""""'""""""""'"""""""'""'""'""'""'""'""'"""'""""""'""'""'""'""'""'""'""'"""'""'"
"'"""""""'""'""'""'""'""'"""'""""'""""'""""""'""'""'""'""'""'""'"""'""""""""'""""""""'"""
""""'""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'"""'""""""""'""""""""'""""""""'"""""""
"'"""""""'""'""'""'""'"""'""""""'""'""'""'""'"""'"""""""'""'""'""'"""'""""'""""'""""""'""
'""'""'"""'""'""'""'""'"""""""'""'""'"""'""""""'""'"""'""'""'""'""'""'""'"""""""'""'"""'"
"""'""""""'"""'""'""""""""""'"""""'"""""""'"""'""""'""""'""""""'""'""'""'""'""'""'""'""'"
"'""'""'"""'""'""'""'""'""'""'""'""'""'""'"""'""""""'""'""'""'""'""'""'""'""'""'""'""'""'
"""'""""""""'"""'""""'"""""""""'""""""""'"""""""'""'""'""'""'""'""'""'""'""'""'""'"""'"""
""'""""""""'"""""""'""'""'""'""'""'""'""'""'""'""'""'"""'""""'""""'""""""'""'""'""'""'""'
""'""'""'""'""'""'""'""'"""'"""""""'"""'""""""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'
"""'"""""""'"""""""'""'""'""'""'""'""'""'""'""'""'""'"""'""""'"""""""""'"""""""'""'""'""'
""'""'""'""'""'""'""'""'""'""'""'"""'"""""'"""""""'""'""'""'""'""'""'""'""'""'""'""'""'""
'""'"""'""""'""""""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""'""""""""'"""""""'""'""'
""'""'""'""'""'""'""'""'""'""'""'""'"""'""""""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""
'""""""""'"""""""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""'"""'""""'"""""""""'"""""""'"
"'""'""'""'""'""'""'""'""'""'""'""'""'"""'""""""'""'""'""'""'""'""'""'""'""'""'""'""'"""'
""'"""""""'""'""'""'""'""'""'""'""'""'""'""'""'"""'"""'""""""'""'""'""'""'""'""'""'""'""'
""'""'"""'""""""""'"""""""'""'""'""'""'""'""'""'""'""'""'""'"""'"""'""""'"""""""""'""""""
""'""""""""'""""""""'""""""""'""""""""'""""""""'""""""""'""""""""'""""""""'"""""""'""'""'
""'""'""'""'""'""'""'""'""'""'"""'"'""""""""'"""""""'"""'"""'""""""'"""'""'""""""""""

(+1) Nice ... I verified it with your interpreter. Is it still considered "unapproved", even though the creator of this language approved it?  (It  seems a shame that the language wasn't defined using two whitespace characters instead of single- and double-quotes ;o)))

@r.e.s. That shouldn't be hard to implement. Just pick two whitespaces and modify the interpreter so that it replaces the whitespaces by the single- and double-quotes at first!

VBA - 25 22 distinct bytes (120 total)
I know this won't win with so many different bytes, but here it is in VBA.
(space),(newline),",,,(,),=,a,b,c,d,e,E,I,l,n,O,p,R,S,u,1
Sub S(u)
u=Replace(Replace(Replace(Replace(Replace(u,"u","",,,1),"O","",,,1),"I","",,,1),"e","",,,1),"a","",,,1)
End Sub

*,,,1 allows for ignoring case. (1 represents the constant vbTextCompare)

You didn't count the E in End Sub. But quite nice, considering it's Basic.

@leftaroundabout Thanks! Absolutely right about E, and I've corrected. I think I was too worried about the meat of the Sub. ;-)

Actually, as VBA as a language suppotts autoformatting, you can change your answer to be in all lower (or upper) case and VBA will correct for this itself, and because it is accepted that autoformatting languages may be considered before the autoformatting occurs, that would mean that you can drop either the e or E

you could configure this down to an immediate window function as ?Replace(Replace(Replace(Replace(Replace(cells(1,1),"u","",,,1),"O","",,,1),"I","",,,1),"e","",,,1),"a","",,,1) with by my count 18 Distinct Bytes ?Replace(s1,)"uOI and 111 bytes total

JavaScript, 6 (7325 total)
[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(+(!+[]+!+[]+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][[]]+[])[+!+[]]+(![]+[])[+!+[]]+((+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]]](!+[]+!+[]+!+[]+[!+[]+!+[]])+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]])()((!![]+[])[+!+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[+!+[]]]+([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[!+[]+!+[]]+(!![]+[])[+!+[]]+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][[]]+[])[+!+[]]+(![]+[])[+!+[]]+((+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[+!+[]+[!+[]+!+[]+!+[]]]+(![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+([][(!![]+[])[!+[]+!+[]+!+[]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()+[])[+[]]+(![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+[]]+([][(!![]+[])[!+[]+!+[]+!+[]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()+[])[!+[]+!+[]+[!+[]+!+[]]]+(![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+(![]+[+[]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+[[]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]([[]])+[]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+([+[]]+![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[!+[]+!+[]+[+[]]])

This uses JSFuck to turn r=>r.replace(/[aeiou]/g,"") into six unique characters.

You would need to add the i flag as well to satisfy the challenge requirements.

Scala, 25 total bytes, 15 distinct bytes
_ filterNot "aeiou".toSet

Try it in Scastie!

Itr, 4 distinct characters, 5197 bytes
newlines for readability
(
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
(()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())L
)©

online interpreter
Explanation
It is possible to execute arbitrary Itr code using only ()L©:
(()...()) creates an array of empty arrays
L gets the length of that array
© interprets the (flattened) array as a sequence of characters and executes that sequence
The code that is encoded by this program is äµ»»AEIOUaeiou«=S¬«×:
ä                     ; duplicate the (implicit) input
 µ»               «   ; map over all characters in the input
   »AEIOUaeiou«=S     ; is the character in the string "AEIOUaeiou"
                 ¬    ; negated
                    × ; pick the elements that have a one in the second array

K, 29. (18 distinct bytes)
{i@&~(i:0:0)in(_i),i:"AEIOU"}

distinct bytes: {@&~(:0)in_,"AEIOU}
k){i@&~(i:0:0)in(_i),i:"AEIOU"}`
Hello WoOOrld
"Hll Wrld"

Python 3.x, 19 distinct chars, 62 total
print(''.join(x for x in input() if x.lower() not in 'aeiou'))

That doesn’t work properly on inputs like Renée’s naïveté, you know.

J, 21 characters (18 distinct)
'AEIOUaeiou'-.~1!:1[1

ASM - 6 distinct characters 520 source characters
(MsDOS .com)
Assembled using A86
db 10110100xb
db 00000110xb
db 10110010xb
db 11111111xb
db 11001101xb
db 00100001xb
db 01110101xb
db 00000001xb
db 11000011xb
db 10001010xb
db 11010000xb
db 10111110xb
db 00011101xb
db 00000001xb
db 10111001xb
db 00001010xb
db 00000000xb
db 01000110xb
db 00101010xb
db 00000100xb
db 01110100xb
db 11101010xb
db 11100010xb
db 11111001xb
db 10110100xb
db 00000110xb
db 11001101xb
db 00100001xb
db 11101011xb
db 11100010xb
db 01000001xb
db 00000100xb
db 00000100xb
db 00000110xb
db 00000110xb
db 00001100xb
db 00000100xb
db 00000100xb
db 00000110xb
db 00000110xb

Just write the machine language, it will be two distinct characters.

MATL, 8 bytes (all distinct)
t13Y2m~)

Try it on MATL Online
Just a straight up golf, didn't really find any trick to reuse characters to reduce unique bytecount.
13Y2 is a literal containing aeiouAEIOU.
Take a duplicate of the input string, make a logical (boolean) array indicating which letters of the input are not (~) members of that literal, and index ()) at those places, to return an array of only non-vowel characters.

K (oK), 16 bytes, 14 distinct
Solution:
^[;v,_v:"AEIOU"]

Try it online!
Explanation:
Using except (^) to filter out the vowels.
^[;v,_v:"AEIOU"] / the solution
^[;            ] / except (^) projection
      v:"AEIOU"  / save vowels as v
     _           / lowercase (_), "AEIOU" => "aeiou"
    ,            / join (,)
   v             / uppercase vowels

Vyxal, 4 bytes, 4 distinct characters
k∨$F

Try it Online!
Only works with single-line strings. Explanation:
      # Implicit input
k∨    # Constant "aeiouAEIOU"
  $   # Swap top two values
   F  # Remove from second string any characters in first string
      # Implicit output

Unary, ~3.081e1915 bytes, 1 distinct character
Specifically, this is how many 0s are required. Simply a Unary port of the brainfuck answer by @ceased to turn clockwis.

Jelly, 3 bytes
ḟØc

Try it online!

APL (Dyalog Extended), 17 bytes, 13 distinct
((⌊,⊢)'AEIOU')~⍨⊢
 (⌊,⊢)'AEIOU' ⍝ concatenate with lower case version of string
   ~⍨⊢ ⍝ remove vowels

Try it online!

Python 2, 7 distinct bytes, 2091 2082 bytes
c="%c%%c%%%%c%%%%%%%%c"
ex=c==c
ee=c==""
exec"e=%x%%x"%ex%ex
exec"e%%%%%%%%=%x%%x%%%%x"%ee%ex%ee
exec"ee=%x%%x"%e%ee
exec"ee%%%%=%x%%x"%ex%e
exec"e=%x%%x"%ee%e
exec"ec=ex%cex"%e
exec"xe=ec%cec"%e
exec"xx=xe%cxe"%e
exec"xc=xx%cxx"%e
exec"ce=xc%cxc"%e
exec"cc=ce%cce"%e
exec"xee=ce%cec"%e
exec"cee=ce%cxx"%e
exec"exe=ce%cex%%cxx"%e%e
exec"xxe=ce%cec%%cxe%%%%cxx"%e%e%e
exec"cxe=ce%cec%%cxx%%%%cxc"%e%e%e
exec"ece=cc%cex"%e
exec"xce=cc%cex%%cxe"%e%e
exec"cce=cc%cex%%cxx"%e%e
exec"eex=cc%cex%%cec%%%%cxe%%%%%%%%cxx"%e%e%e%e
exec"xex=cc%cex%%cxe%%%%cxc"%e%e%e
exec"cex=cc%cex%%cec%%%%cxx%%%%%%%%cxc"%e%e%e%e
exec"exx=cc%cex%%cxe%%%%cxx%%%%%%%%cxc"%e%e%e%e
exec"xxx=cc%cex%%cec%%%%cxe%%%%%%%%cxx%%%%%%%%%%%%%%%%cxc"%e%e%e%e%e
exec"cxx=cc%cex%%cce"%e%e
exec"ecx=cc%cex%%cec%%%%cce"%e%e%e
exec"xcx=cc%cex%%cxe%%%%cce"%e%e%e
exec"ccx=cc%cec%%cxe%%%%cce"%e%e%e
exec"eec=cc%cxx%%cce"%e%e
exec"xec=cc%cex%%cxx%%%%cce"%e%e%e
exec"cec=cc%cec%%cxx%%%%cce"%e%e%e
exec"exc=cc%cxe%%cxx%%%%cce"%e%e%e
exec"xxc=cc%cec%%cxe%%%%cxx%%%%%%%%cce"%e%e%e%e
exec"cxc=cc%cex%%cec%%%%cxe%%%%%%%%cxx%%%%%%%%%%%%%%%%cce"%e%e%e%e%e
exec"ecc=cc%cxc%%cce"%e%e
exec"xcc=cc%cec%%cxc%%%%cce"%e%e%e
exec"ccc=cc%cex%%cec%%%%cxc%%%%%%%%cce"%e%e%e%e
exec"eeee=cc%cxe%%cxc%%%%cce"%e%e%e
exec"xeee=cc%cex%%cxe%%%%cxc%%%%%%%%cce"%e%e%e%e
exec"ceee=cc%cec%%cxe%%%%cxc%%%%%%%%cce"%e%e%e%e
exec"exee=cc%cex%%cec%%%%cxe%%%%%%%%cxc%%%%%%%%%%%%%%%%cce"%e%e%e%e%e
exec"xxee=cc%cxx%%cxc%%%%cce"%e%e%e
exec"""x=""
"""
exec"x%c=c%%xcx%%xxee%%xcx%%ecx"%e
exec"x%c=c%%xee%%xee%%xxe%%cec"%e
exec"x%c=c%%cxc%%xec%%xxc%%cee"%e
exec"x%c=c%%ecx%%eec%%xcc%%cee"%e
exec"x%c=c%%xcx%%ceee%%cxx%%exc"%e
exec"x%c=c%%cee%%ecx%%exe%%exe"%e
exec"x%c=c%%ccx%%cxc%%xcc%%ce"%e
exec"x%c=c%%ecx%%ce%%xec%%xxc"%e
exec"x%c=c%%ce%%ecx%%xxee%%xxe"%e
exec"x%c=c%%ccc%%ecc%%exc%%xec"%e
exec"x%c=c%%eeee%%cee%%exe%%exe"%e
cx="""ecc
xcc
xec
xxc
eeee
xee
xee
xxe
cec
cxc
xec
xxc
cee
cxx
cex
cxx
ce
xec
xxc
xee
cxx
xcx
xec
cxc
xeee
ece
xce
cce
eex
xex
xee
cxe
exx
ccx
cxc
xcc
ce
cxx
ce
xec
xxc
ce
xcc
cxx
exee
xxx
xec
xxc
ecc
xeee
eeee
cee
exe
exe"""
exec"exec%cx"%ce

Try it online!
I'm using the algorithm of this question to translate the following code in the code above to only use e, x, c, ", =, % and newline. Make sure to follow the link to understand how the transformation works
code before transformation: (57 54 bytes)
print"".join(a[a in"aeiouAEIOU":]for a in raw_input())

Try it online!
Even if the first code isn't golfed, this one is :p
Thanks to dingledooper for -3 bytes on the second program

By the way, I think you can do a[a in"aeiouAEIOU":] which is 3 bytes shorter.

@dingledooper I didn' thought of that. Thanks :)

Lua, 12 distinct characters, 3245 2924 bytes
load(('').char(#'################################################################################################################')..'r'..('').char(#'#########################################################################################################')..('').char(#'##############################################################################################################')..('').char(#'####################################################################################################################')..'(('..('').char(#'#########################################################################################################')..'o'..('').char(#'##############################################')..'r'..('').char(#'#####################################################################################################')..'ad'..('').char(#'#######################################')..('').char(#'##########################################')..'a'..('').char(#'#######################################')..('').char(#'##########################################################')..('').char(#'#######################################################################################################')..('').char(#'###################################################################################################################')..('').char(#'#####################################################################################################################')..('').char(#'##################################################################################################')..'('..('').char(#'#######################################')..('').char(#'###########################################################################################')..'a'..('').char(#'#####################################################################################################')..('').char(#'#########################################################################################################')..'o'..('').char(#'#####################################################################################################################')..('').char(#'#################################################################')..('').char(#'#####################################################################')..('').char(#'#########################################################################')..('').char(#'###############################################################################')..('').char(#'#####################################################################################')..('').char(#'#############################################################################################')..('').char(#'#######################################')..('').char(#'############################################')..('').char(#'#######################################')..('').char(#'#######################################')..')))')()

Try it online!
Uses the characters #load(').chr. Essentially, this program builds the string print((io.read'*a':gsub('[aeiouAEIOU]',''))), loads it as a function, and then runs it.
Thanks to xigoi for saving about 300 bytes.

You can decrease the length by using literals for ( and ), as you're already doing for some other characters.

Ruby, 8 distinct, 557 bytes
eval""<<11+11+11+1+1+1<<11+11+11+11+11+1+1+1+1+1+1+1<<"<<"<<11+11+11+1+1+1<<"<"<<11+11+11+11+1+1<<111+1+1+1<<"ea"<<11+11+11+11+11+11+11+11+11+1<<11+11+11+11+1+1<<11+11+11+11+11+11+11+11+11+1+1+1+1<<111+1+1+1+1<<111+1+1+1+1+1+1<<11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1<<11+11+11+1+1+1+1+1+1+1<<11+11+11+11+1+1+1<<11+11+11+11+11+11+11+11+1+1+1<<"ae"<<11+11+11+11+11+11+11+11+11+1+1+1+1+1+1<<111<<111+1+1+1+1+1+1<<11+11+11+11+11+11+11+11+1+1+1+1+1<<11+11+11+11+1+1+1<<11+11+11+11+11+11+11+11+11+1+1+1+1+1+1<<11+11+11+1+1+1+1+1+1+1+1<<111+11+1<<111+11+1+1+1

Attempt This Online!
Encodes the following 30 byte (21 unique) program in the minimum distinct characters eval"<1+ using the technique from GB's answer to this question.
$><<$<.read.gsub(/[aeiou]/i){}

Lexurgy, 17 distinct, 28 bytes
a:
{a,e,i,o,u,A,E,I,O,U}=>*

If we didn't have to support uppercase letters, 12 distinct, 18 bytes:
a:
{a,e,i,o,u}=>*

Vyxal, 18 bitsv2, 2.25 bytes, 2 distinct characters
011110011111001000

Try it Online! (link is to bitstring)
Vyncode FTW! The actual program is encoded as a bitstring. I also shaved a character off of @Aaroneous Miller's answer

PHP - 30 distinct bytes
<?=preg_replace('/[aeiou]/i','',fgets(STDIN));

Couldn't you change /[aeiou|AEIOU]/ into /[aeiou]/i? Also, your code also causes | to disappear.

bash 26 distinct, 37 total
c=$(cat -)
echo "${c//[aeiouAEIOU]/}"

sorted:
""$$()-///=AEIOU[]aacccceehiootu{}"

scala> code.toList.distinct.length
res51: Int = 26

scala> code.length
res52: Int = 37

"
  ""$$()-///=AEIOU[]aacccceehiootu{}"

scala> code.distinct.sorted
res56: String =
"
 "$()-/=AEIOU[]acehiotu{}"

Result (preserves linefeeds):
echo "This program will remove VOWELS.
So we can now speak without them." | ./cg-6025-remove-vowels.sh
Ths prgrm wll rmv VWLS.
S w cn nw spk wtht thm.

For tr, it isn't clear how to count: '-d aeiouAEIOU' as 10 or 13:
echo "This program will remove VOWELS.
So we can now speak without them." | tr -d aeiouAEIOU

I considered using tr, but I concluded that since it's not a programming language it would have to be wrapped in a shell, so it would count the full text of tr -d aeiouAEIOU for 15.

16

15 distinct, 16 total.

F# 105 121 91 characters
Console.ReadLine()|>Seq.filter(fun c->not("aeiouAEIOU".Contains(c)))|>Seq.iter(printf"%c")

Hmmm... I just noticed that this code will work in Linqpad but not in Visual Studio. And since I don't feel like down voting my own contribution, I will leave it here with this comment until I figure out what's wrong with it.

Excel Formula - 19 distinct bytes (196 total)
=,S,B,T,(,),,,",a,e,i,o,u,A,E,I,O,U,1
Cell A1: <Value>
Cell B1: =SUBSTITUTE(SUBSTITUTE(A1,"a",""),"e","")
Cell C1: =SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(B1,"i",""),"o",""),"u",""),"A",""),"E",""),"I",""),"O",""),"U","")

*This actually is too many nested functions to work in Excel 2003, but the concept is there.
Splitting the formulas into two cells achieved the desired effect. -- Result is in C1.

Noether, 16 individual bytes (17 total)
I"[aeiouAEIOU]"-P

Try it online!
Uses the regex
[aeiouAEIOU]

to remove the vowels from the input string.

jq, 119 bytes, 15 distinct characters
explode-[121-2-2,111,111-2-2-2,111-2-2-2-2-2,111-12-2,111-22-2-2,111-21-11,111-22-12-2-2,111-21-21,111-22-22-2]|implode

Try it online!
Here's how is works.
explode

Converts the input, which has to be a quoted string or jq can't parse it, to an array of codepoints.
-[121-2-2,111,111-2-2-2,111-2-2-2-2-2,111-12-2,111-22-2-2,111-21-11,111-22-12-2-2,111-21-21,111-22-22-2]

Remove all occurrences of upper and lower case vowels, which are representing as numeric expressions that map to the codepoints.  You COULD make a program with one less unique character by limiting the expressions to 1 and -, but it would be very long...
|implode

Converts the array of codepoints left into a string and prints it.

PowerShell, 26 bytes
|%{$_-replace'[aeiou]',''}

Anything before the | will be devowel'd.

Befunge-98 (PyFunge), 11 distinct characters, 263 bytes
<,_v#-''-''-'':_v#----'<'~':_v#--'-<':_v#--#'''-:'-'':_v#-:'-'':_v#---''-'-#'~':_v#--''v':_v#---,'-'-,'v':_v#--,'-'--:'~':_v#--,'-'-@':~@#
v<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Try it online!
Basically, checks each character against each of AEIOUaeiou, whose code points are constructed from the code points of the characters used elsewhere in the program, #',-:<@_v~.
The program also contains a newline. I'm pretty sure with much editing this could get down to 10 or even 9 characters by replacing v and the newline with some other method of returning to the start without the extra line, and there may be a way to also remove < in that case by leveraging a _.
For example:
The first chunk of code after the character read (right to left above, presented here left to right for clarity) is :'@-'-',--#v_. : duplicates the character, '@- subtracts the value @ (64) from the character, '-',- subtracts , (44) from - (45) to get 1, which is then subtracted (-) from the character, in total subtracting by 65, the code point for A. Then #v_ checks if this total is 0 (the character is A), and either sends the program down and to the next input or continues through the other vowels. If it passes all the checks, the character is printed.

Pascal, 35 distinct characters
This complete program requires a processor supporting features of Extended Pascal (as defined by ISO standard 10206), in particular the index function needs to be present.
Note, to avoid the drama associated with all sorts of various end‑of‑line markers, Pascal (as defined by the ISO standard 7185 and 10206) says that for a text file (such as input) substitutes the end‑of‑line marker (whatever it may be) with a single space character (' ').
Therefore the program does not reproduce the example’s two lines but one line joined by a space.
program p(input,output);var c:char;begin while not eof do begin read(c);if 0=index('AEIOUaeiou',c)then write(c)end end.

Ungolfed:
program removeVowelsWithoutUsingTooManyDifferentCharacters(input, output);
    var
        currentCharacter: char;
    begin
        while not EOF(input) do
        begin
            { This is equivalent to `currentCharacter ≔ input↑; get(input);`. }
            read(input, currentCharacter);

            { `index` returns zero if the pattern `currentCharacter`
              does not appear in the sample `'AEIOUaeiou'`. }
            if index('AEIOUaeiou', currentCharacter) = 0 then
            begin
                { Equivalent to `output↑ ≔ currentCharacter; put(output);`. }
                write(output, currentCharacter);
            end;
        end;
    end.

Python (23)
Somebody had to do it.
print filter(lambda x:x not in'aeiou',raw_input())

That has "only" 23 distinct characters. But fails to work on uppercase vowels.

By adding one new character and changing the variable from x to either c or s you can use lowercase() (or uppercase) and deal also with uppercase vowels.