Yan Cui

I help clients go faster for less using serverless technologies.

**This article is brought to you by**

**Hookdeck: The Serverless Event Gateway
**

Hookdeck is a reliable and scalable serverless event gateway for sending, receiving, authenticating, transforming, filtering, and routing events between services in your event-driven architecture.

#### Problem

The number, 1406357289, is a 0 to 9 pandigital number because it is made up of each of the digits 0 to 9 in some order, but it also has a rather interesting sub-string divisibility property.

Let d_{1}be the 1^{st}digit, d_{2}be the 2^{nd}digit, and so on. In this way, we note the following:

d_{2}d_{3}d_{4}=406 is divisible by 2d_{3}d_{4}d_{5}=063 is divisible by 3d_{4}d_{5}d_{6}=635 is divisible by 5d_{5}d_{6}d_{7}=357 is divisible by 7d_{6}d_{7}d_{8}=572 is divisible by 11d_{7}d_{8}d_{9}=728 is divisible by 13d_{8}d_{9}d_{10}=289 is divisible by 17

Find the sum of all 0 to 9 pandigital numbers with this property.

#### Solution

let rec distribute e = function | [] -> [[e]] | x::xs' as xs -> (e::xs)::[for xs in distribute e xs' -> x::xs] let rec permute = function | [] -> [[]] | e::xs -> List.collect (distribute e) (permute xs) // generate the 0 to 9 pandigitals let numbers = permute [0..9] |> List.map (fun l -> l |> List.map string |> List.reduce (+)) // the corresponding prime divisors and digits let primes = [2; 3; 5; 7; 11; 13; 17] let ns = [2..10] |> Seq.windowed 3 |> Seq.toList // returns the number retrieved from taking the digits at the supplied positions let d ns (numberStr:string) = int(ns |> Array.map (fun n -> numberStr.[n-1].ToString()) |> Array.reduce (+)) // predicate which identifies pandigital numbers with the desired property let predicate number = List.forall2 (fun n p -> (d n number) % p = 0) ns primes let answer = numbers |> List.filter predicate |> List.sumBy int64

One thing you might notice in the creation of the permutations of all 0 to 9 pandigital numbers is the use of (+) in the List.reduce function call. This is actually just the shortened form of:

List.reduce (fun acc item –> acc + item)

Another List function of interest here is the List.forAll2 function, which tests if all corresponding elements in both lists satisfy the given predicate pairwise. In this case, I’m using it to pair up the digits list ([[2;3;4]; [3;4;5];…]) with the primes list ([2;3;5;..17]) to test if a given number has the desired property as described in the problem brief.

We arrive at the answer by simply adding up all the pandigital numbers which matches the predicate condition.

**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.