# Code to calculate "median of five" in C#

### Question

Note: Please don't interpret this as "homework question." This is just a thing I curious to know :)

The median of five is sometimes used as an exercise in algorithm design and is known to be computable using only 6 comparisons.

What is the best way to implement this "median of five using 6 comparisons" in C# ? All of my attempts seem to result in awkward code :( I need nice and readable code while still using only 6 comparisons.

``````public double medianOfFive(double a, double b, double c, double d, double e){
//
// return median
//
return c;
}
``````

Note: I think I should provide the "algorithm" here too:

I found myself not able to explain the algorithm clearly as Azereal did in his forum post. So I will reference his post here. From http://www.ocf.berkeley.edu/~wwu/cgi-bin/yabb/YaBB.cgi?board=riddles_cs;action=display;num=1061827085

Well I was posed this problem in one of my assignments and I turned to this forum for help but no help was here. I eventually found out how to do it.

1. Start a mergesort with the first 4 elements and order each pair (2 comparisons)

2. Compare the two lower ones of each pair and eliminate the lowest one from the possibilities (3 comparisons)

3. Add in the 5th number set aside to the number without a pair and compare the two (4 comparisons)

4. Compare the two lowest of the two new pairs and eliminate the lower one (5 comparisons)

5. Compare the one by itself and the lower of the last pair and the lower number is the median

The possible median is within the parentesis

(54321)

5:4 3:2 2 comparisons

(4<5 2<3 1)

4:2 3 comparisons

2(4<5 3 1)

1:3 4 comparisons

2(4<5 1<3)

4:1 5 comparisons

1,2(4<5 3)

4:3 6 comparisons

1,2(3)4,5

Three is the median

EDIT: As your request and to prevent myself from getting more downvotes, this are C++ code I wrote to find median of five. Don't mind it's awkwardness:

``````double StageGenerator::MedianOfFive(double n1, double n2, double n3, double n4, double n5){
double *a = &n1, *b = &n2, *c = &n3, *d = &n4, *e = &n5;
double *tmp;

// makes a < b and b < d
if(*b < *a){
tmp = a; a = b; b = tmp;
}

if(*d < *c){
tmp = c; c = d; d = tmp;
}

// eleminate the lowest
if(*c < *a){
tmp = b; b = d; d = tmp;
c = a;
}

// gets e in
a = e;

// makes a < b and b < d
if(*b < *a){
tmp = a; a = b; b = tmp;
}

// eliminate another lowest
// remaing: a,b,d
if(*a < *c){
tmp = b; b = d; d = tmp;
a = c;
}

if(*d < *a)
return *d;
else
return *a;

}
``````

It should be more compact, isn't it ?

EDIT:

As @pablito pointed out in his answer. The built-in List.Sort() cannot fulfill this requirement since it uses up to 13 comparisons :]

1
28
1/26/2009 8:17:22 PM

This is basically just factoring out the swapping and sorting code from your C++ example:

``````private static void Swap(ref double a, ref double b) {
double t = a;
a = b;
b = t;
}

private static void Sort(ref double a, ref double b) {
if (a > b) {
double t = a;
a = b;
b = t;
}
}

private static double MedianOfFive(double a, double b, double c, double d, double e){
// makes a < b and c < d
Sort(ref a, ref b);
Sort(ref c, ref d);

// eleminate the lowest
if (c < a) {
Swap(ref b, ref d);
c = a;
}

// gets e in
a = e;

// makes a < b
Sort(ref a, ref b);

// eliminate another lowest
// remaing: a,b,d
if (a < c) {
Swap(ref b, ref d);
a = c;
}

return Math.Min(d, a);
}
``````
15
1/22/2010 10:56:18 PM

I found this post interesting and as an exercise I created this which ONLY does 6 comparisons and NOTHING else:

``````static double MedianOfFive(double a, double b, double c, double d, double e)
{
return b < a ? d < c ? b < d ? a < e ? a < d ? e < d ? e : d
: c < a ? c : a
: e < d ? a < d ? a : d
: c < e ? c : e
: c < e ? b < c ? a < c ? a : c
: e < b ? e : b
: b < e ? a < e ? a : e
: c < b ? c : b
: b < c ? a < e ? a < c ? e < c ? e : c
: d < a ? d : a
: e < c ? a < c ? a : c
: d < e ? d : e
: d < e ? b < d ? a < d ? a : d
: e < b ? e : b
: b < e ? a < e ? a : e
: d < b ? d : b
: d < c ? a < d ? b < e ? b < d ? e < d ? e : d
: c < b ? c : b
: e < d ? b < d ? b : d
: c < e ? c : e
: c < e ? a < c ? b < c ? b : c
: e < a ? e : a
: a < e ? b < e ? b : e
: c < a ? c : a
: a < c ? b < e ? b < c ? e < c ? e : c
: d < b ? d : b
: e < c ? b < c ? b : c
: d < e ? d : e
: d < e ? a < d ? b < d ? b : d
: e < a ? e : a
: a < e ? b < e ? b : e
: d < a ? d : a;
}
``````