39 lines
2.1 KiB
Markdown
39 lines
2.1 KiB
Markdown
|
My first approach here was a simple brute force algorithm, but that one was *far* too slow. So I needed an more intelligent algorithm. And I have to say the one I came up is pretty quick and I like the concept that lies behind it.
|
||
|
|
|
||
|
|
First I calculated the primes from `0` to `1 000 000`.
|
||
|
|
|
||
|
|
Next I calculated the maximum chain *(starting by the first prime `2`)* with a sum less than one million.
|
||
|
|
|
||
|
|
Now think of all the primes laid down in an array side by side:
|
||
|
|
|
||
|
|
**1)** We move our chain from left to right until the sum exceeds one million (the movement is a really cheap operation: take the previous sum, subtract the most left prime and add the new prime from the reight side).
|
||
|
|
|
||
|
|
**2)** Then we shorten the chain length by one as we remove the most left prime.
|
||
|
|
|
||
|
|
**3)** After that we do the movement back wards (from right to left) until we end up at the left end of our prime array.
|
||
|
|
|
||
|
|
**4)** Then we again shorten the chain *(this time by removing the right tail)* and start over again (by moving right).
|
||
|
|
|
||
|
|
**X)** In every step we test if the current sum is a prime number and if so we print it and terminate the program.
|
||
|
|
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
OOOOOOOOOOOOO // the prime array
|
||
|
|
#####OOOOOOOO // our chain
|
||
|
|
O#####OOOOOOO // move right
|
||
|
|
OO#####OOOOOO
|
||
|
|
OOO#####OOOOO // until sum > MAX_VALUE
|
||
|
|
OOOO####OOOOO // shorten left
|
||
|
|
OOO####OOOOOO // move left
|
||
|
|
OO####OOOOOOO
|
||
|
|
O####OOOOOOOO
|
||
|
|
####OOOOOOOOO // until left side is hit
|
||
|
|
###OOOOOOOOOO // shorten right
|
||
|
|
O###OOOOOOOOO // repeat until prime is found
|
||
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
|
|
||
|
|
This algorithm works because we first test every possibility with maximum chain length, and then every with length = `maximum - 1` and so on and so on. So the first prime that we find is from the longest possible chain.
|
||
|
|
|
||
|
|
There are two nice things about this algorithm:
|
||
|
|
|
||
|
|
- We don't need to calculate an extreme amount of prime sums. The step from the sum of one chain to the next is literally only an addition and an subtraction
|
||
|
|
- Because we start with the longest chain and reduce its length in every step, the first prime we find is directly our optimal result.
|