## Project Euler 58: Counting primes that lie on the diagonals of the spiral grid

#### Problem Description

Starting with 1 and spiralling counterclockwise in the following way, a square spiral with side length 7 is formed.

37 36 35 34 33 32 31

38 17 16 15 14 13 30

39 18 5 4 3 12 29

40 19 6 1 2 11 28

41 20 7 8 9 10 27

42 21 22 23 24 25 26

43 44 45 46 47 48 49

It is interesting to note that the odd squares lie along the bottom right diagonal, but what is more interesting is that 8 out of the 13 numbers lying along both diagonals are prime; that is, a ratio of 8/13 ≈ 62%.

If one complete new layer is wrapped around the spiral above, a square spiral with side length 9 will be formed. If this process is continued, what is the side length of the square spiral for which the ratio of primes along both diagonals first falls below 10%?

#### Analysis

Forget about the geometry and determine the series instead: (3, 5, 7, 9), (13, 17, 21, 25), (31, 37, 43, 49), … This represents the “corners” for every square layer.

Determine and count the primes, *p _{n}*, in the series ignoring every 4th one since it will always be a square and therefore composite. As soon as we reach a ratio of primes to series length (

*n*),

*p*/

_{n}*n*< 10% we can calculate a side length as

*n*/2.

It’s important to have a decent *is_prime()* function to achieve a better run time.

#### Project Euler 58 Solution

Runs < 0.500 seconds in Python 2.7.Use this link to get the Project Euler 58 Solution Python 2.7 source.

#### Afterthoughts

- Function
`miller_rabin`

is listed in Common Functions and Routines for Project Euler - Using the Miller-Rabin primality test,
`miller_rabin`

, in place of`is_prime`

sped things up 3 fold. We are using the default accuracy of 5 which is low but fast. - Note how we calculate the answer as n-1. This is because we count only even n and the side length of our layer has to be odd.
- See also, Project Euler 28 Solution:

*Project Euler 58 Solution last updated*

Could someone tell me what is the final ratio at the answer length? I feel like I am not getting the right answer because of floating point error. I don’t know what to do about it. I am using C++

It is fun to note that this solution provides incorrect answers around bound<=0.0895. This is because the floating point error on the ratio is enough by then to push us just under the limit one iteration too soon. If we re-compute n from the precise integrals we seem to last longer, but it is still a matter of time before that result differs from a result using exact rational values.