• What is median?
• What is the difference between the median and mean?
• Calculate median with simple algorithm
• Conclusion

What is median?

First of all, let’s get a good idea what median actually is. Let’s look at wiki definition:

The median of a list of numbers can be found by first sorting the numbers ascending. If there is an odd number of values, the middle one is picked. If there is an even number of values, the median is then defined to be the average of the two middle values. (Wikipedia)

So when we take the definition of median, we need to find the middle in the sorted array.

What is the difference between the median and mean?

The essential difference is that the mean gives a rough average (sum all elements together and divide the sum by the number of elements in the collection) of the whole dataset. At the same time, the median will provide the exact centric value, which falls between the smallest and highest value.

It is important to note that a single centric value can be picked only from ordered values arranged in an ascending or descending order for the median.

For example, if I have an array [1,2,3,4,5], number 3 is the median. But if have an arrray [1,2,3,4,5,6], number 3.5 is the median.

Calculate median with simple algorithm

Let’s use few words to describe our algorithm for computing the median.

First, we will need to take input. The inputs are the int numbers in the array and the size of the collection. One crucial thing to remember is to always keep in mind that the values in an array need to be sorted for computing median Order, ascending or descending, is necessary because we are looking for the value in the centre of the array.

Sorting array happens before computing median, and it is not part of the algorithm for computing median. Therefore, you can use any known sorting algorithm such as quicksort, bubble sort etc.

After taking the inputs, we must first check whether the number of elements in the array is odd or even.

If the number of elements in the array is even, we compute the median by taking two central pieces and divide them by two.

As we are familiar with arrays in computer science, array order starts with zero and ends with the number of elements minus one. Therefore, when an array length is an even number, we must select the middle array element and element before it.

Eventually, for computing the median for even array length, a division with a number represented as a double value will secure that median with decimal points. Otherwise, division with the number represented as int will floor the number, and the median will be incorrect.

Otherwise, if the number of elements in the array is odd, we compute the median by taking the centric array element.

But, again, as we are familiar with arrays in computer science, array order starts with zero and ends with the number of elements minus one.

We will do a small trick, which can look unnatural at first sight. We add one to the number of array elements in the array of odd length, then divide it by two. And then, we subtract from division one. The resulting number will give us the index position of the central component of the array of odd lengths.

public class Median {
    public static void main(String arg[]) {
        int oddLength = 5;
        int oddArr[] = new int[oddLength];
        oddArr[0] = 10;
        oddArr[1] = 30;
        oddArr[2] = 50;
        oddArr[3] = 70;
        oddArr[4] = 90;

        System.out.println("Median for odd length array is : " + computeMedian(oddArr, oddLength);
    
        int evenLength = 6;
        int evenArr[] = new int[evenLength];
        evenArr[0] = 10;
        evenArr[1] = 30;
        evenArr[2] = 50;
        evenArr[3] = 70;
        evenArr[4] = 90;
        evenArr[5] = 100;
    
        System.out.println("Median for even length array is :" + computeMedian(evenArr, evenLength);
    }
    
    private static double computeMedian(int[] arr, int n) {
        if (n % 2 == 0) {
            return (arr[n/2 - 1] + arr[n/2]) / 2.0;
        } else  {
            return arr[(n+1)/2 - 1];
        }
    }
}

Output

Median for odd length array is : 50
Median for even length array is : 60

Conclusion

This article has shown us a simple algorithm for how to compute median in Java.

It is important to remember that we can compute the median only on sorted arrays. Ascending or descending order does not matter unless we are looking for the value in the centre of the array.

Sorting of the array can happen before computing the median, and you can use any known sorting algorithm.

Did you find computing median easy? Do you have your trick or know another way how to calculate median in Java? Let us know in the comments below the article. We would like to hear your ideas and stories.

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

The idea is to compute the biggest prime factor of the number 600851475143. Fortunately I did not understand idea very well and I start looking for the biggest prime number under the 600851475143 number. Here is the code for searching the biggest prime number smaller than 10000.

<?php 
$endNumber = 10000; 
$primeArray = array(2);

for ($i=2;$i<=$endNumber;$i++) {
        $isPrime = null; 
        $isNotPrime = null; 
        foreach ($primeArray as $prime) {
                switch ($i%$prime == 0) {
                        case true:
                                $isNotPrime = true; 
                                break;
                        case false:
                                $isPrime = true;
                                break;
                }
                if ($isPrime == true && $isNotPrime == false) {
                        if ($prime === end($primeArray)) {
                                array_push($primeArray, $i);
                        }
                }
        }
}

foreach ($primeArray as $num) {
	echo $num."<br>";
};
?>

When I made this code I realized something is wrong. Server default response exceeded default 30s and server outputed error. Brute force is not definitely not the right way to search for the bug prime numbers.

Computing the big prime number (and anything around  the 600 billions number is a big number) takes enormous computational power. Does the Problem 3 really ask me to compute such difficult computations?

I check an online resources for the algorithms for computing  the big prime numbers. I found out that I did not understand the Problem 3 description correctly. Instead of looking for the biggest prime number under 600851475143 the idea is to actually find the biggest prime factor of the number 600851475143 . This is the task from the Math lecture of an elementary school .

<?php
define('NUMBER', 600851475143);
$whileEnd = NUMBER;
$number = NUMBER;
$division = 2;
$primeFactor = array();

while ($division <= $whileEnd) {
	if (fmod($number, $division) == 0) {
		$number = $number/$division;
		array_push($primeFactor, $division);
		// echo $number." - ".$division.". <br>";
	} else {
		$division++;
	}
	$whileEnd = round(NUMBER/$division) + 1;
}

echo "The biggest prime is ".end($primeFactor)." and last round ended at ".$division." .";
?>

The idea is simple. Every number is possible to divide on a multiple of several prime numbers, for example the number 90 can be divide on the multiple of 2*3*3*5 where the number 5 is the biggest prime factor. So let’s try to divide the original number starting from the number 2.

If the number 2  is the prime number, we divide a reminder further by the number 2. We repeat the divide till the reminder is not dividable by current number.

If the number is not dividable by the current number, we increase the division number by 1 and try the whole process  with the remainder again.

We do it until (current number division the original number) times . Anything bigger this can not be the prime number of the original number. Thus by increasing the division we decrease the threshold for the end of loop.

Improvements for the Problem 3

I believe this is the algorithm for which exist many improved versions doing the faster computation of the prime numbers. While reviewing the code the best way to speed up the loop would be cleverly get rid of the all multiple of the all previous prime numbers. Unfortunately we can not use a Fibonacci algorithm from the previous Project Euler Problem 3.

Hint

While working on the algorithm I encountered big problem with modulo. Using a normal operator % with such big number leads to incorrect results caused by float. The PHP math function fmod provide correct result.

<?php
$number = 600851475143;
$division = 3;
echo $number%$division;        // result 0
echo fmod($number, $division); // result 2
?>

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

In the order to find a final sum, first it is necessary to generate the Fibonacci sequence. The sum of the first 2 elements in the sequence creates the third. The loop than go on and the second and the third element create forth , etc.

All we need to do now do is just to check if the newly generated number is dividable by 2. If it is we can sum it up with the rest. The sum is already 2 since we begin by generating the 3rd number (the sum of first 2 elements $a and $b).

So the algorithms goes like this:

1. Definition of starting variables.
2. Loop for generating +1 bigger number.
3. Check if number is dividable by 2.
4. If yes, number is summed.
5. Output of result.

PHP:

<?php 
$sum = 2;
$a = 1;
$b = 2;
$c = null;
while ($c < 4000000) {
	$c = $a + $b;
	if($c%2 == 0) {
		$sum += $c;
	}
	$a = $b;
	$b = $c;
}
echo $sum;
?>

Java:

public class Project_Euler_Problem_002 {
	public static void main(String[] args) {
		
		System.out.println("Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:");
		System.out.println("1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …");
		System.out.println("Find the sum of all the even-valued terms in the sequence which do not exceed four million.");

		int sum = 2, a = 1, b = 2, c = 0;
		while (c < 4000000) {
			c = a + b;
			if(c%2 == 0) {
				sum += c;
			}
			a = b;
			b = c;
		}
		
		System.out.println("\n"+ "Sum is: " + sum);;
	}
}

Hint:  While reviewing the algorithm with the solutions of others I notice a difference. This algorithm is based on the Fibonacci sequence starting 1,2,3… not 1,1,2,3.

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

The problem is very easy. We are checking division of the numbers 3 and/or 5, the end number is not high and an idea of the sum is very clear. Despite the fact we need to brute-forcefully iterate all over the first 1000 numbers, I did not think much about any other complicated algorithm. The brute-force can be enough in this case.

PHP:

<?php 
$sum = 0;
for ($i=0;$i<1000;$i++) {
	if(($i%3 == 0) OR ($i%5 == 0)){
		$sum += $i;
	}
}
echo $sum;
?>

JAVA:

public class Project_Euler_Problem_001 {

	public static void main(String[] args) {
		
		System.out.println("If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.");
		System.out.println("Find the sum of all the multiples of 3 or 5 below 1000.");

		int sum = 0;
		for (int i = 0; i<1000; i++) {
			if((i%3 == 0) || (i%5 == 0)){
				sum += i;
			}
		}
		System.out.println("\n"+ "Sum is: " + sum);;
	}
}