Yan Cui

I help clients go faster for less using serverless technologies.

#### Problem

Euler published the remarkable quadratic formula:

n² + n + 41

It turns out that the formula will produce 40 primes for the consecutive values n = 0 to 39. However, when n = 40, 40^{2}+ 40 + 41 = 40(40 + 1) + 41 is divisible by 41, and certainly when n = 41, 41² + 41 + 41 is clearly divisible by 41.

Using computers, the incredible formula n² – 79n + 1601 was discovered, which produces 80 primes for the consecutive values n = 0 to 79. The product of the coefficients, -79 and 1601, is -126479.

Considering quadratics of the form:

n² + an + b, where |a| < 1000 and |b| < 1000

where |n| is the modulus/absolute value of n

e.g. |11| = 11 and |-4| = 4

Find the product of the coefficients, a and b, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n = 0.

#### Solution

let hasDivisor(n) = let upperBound = int64(sqrt(double(n))) [2L..upperBound] |> Seq.exists (fun x -> n % x = 0L) // need to consider negative values let isPrime(n) = if n <= 1L then false else not(hasDivisor(n)) // the quadratic expression let F (n:int64) (a:int64) (b:int64) = (n*n) + (a*n) + b // function to return the number of consecutive primes the coefficients generate let primeCount a b = Seq.unfold (fun state -> Some(state, state + 1L)) 0L |> Seq.takeWhile (fun n -> isPrime (F n a b)) |> Seq.length let aList, bList = [-999L..999L], [2L..999L] |> List.filter isPrime let answer = let (a, b, _) = aList |> List.collect (fun a -> bList |> List.filter (fun b -> a + b >= 1L) |> List.map (fun b -> (a, b, primeCount a b))) |> List.maxBy (fun (_, _, count) -> count) a * b

Whilst I started off using a brute force approach (which took quite a while to run) I realised that most of the combinations of *a* and *b* don’t generate any primes at all. In order to reduce the number of combinations you need to check, consider the cases when *n = 0* and *n = 1*:

*n = 0*: expression evaluates to *b*, in order for this to generate a prime* b* must be *>= 2*.

*n = 1*: expression evaluates to *1 + a + b*, in order for this to generate a prime *1 + a + b* must be *>= 2*, therefore *a + b >= 1*.

**Whenever you’re ready, here are 4 ways I can help you:**

**Production-Ready Serverless**: Join 20+ AWS Heroes & Community Builders and 1000+ other students in levelling up your serverless game. This is your one-stop shop for**quickly levelling up your serverless skills**.- Do you want to know
**how to test serverless architectures**with a fast dev & test loop? Check out my latest course,**Testing Serverless Architectures**and learn the smart way to test serverless. - I help clients
**launch product ideas**,**improve their development processes**and**upskill their teams**. If you’d like to work together, then let’s**get in touch**. **Join my community on Discord**, ask questions, and join the discussion on all things AWS and Serverless.