Yan Cui

I help clients go faster for less using serverless technologies.

#### Problem

A unit fraction contains 1 in the numerator. The decimal representation of the unit fractions with denominators 2 to 10 are given:

^{1}/_{2 }= 0.5

^{1}/_{3 }= 0.(3)

^{1}/_{4 }= 0.25

^{1}/_{5 }= 0.2

^{1}/_{6 }= 0.1(6)

^{1}/_{7 }= 0.(142857)

^{1}/_{8 }= 0.125

^{1}/_{9 }= 0.(1)

^{1}/_{10 }= 0.1

Where 0.1(6) means 0.166666…, and has a 1-digit recurring cycle. It can be seen that^{1}/_{7}has a 6-digit recurring cycle.

Find the value of d < 1000 for which^{1}/_{d}contains the longest recurring cycle in its decimal fraction part.

#### Solution

let naturalNumbers = Seq.unfold (fun state -> Some(state, state+1)) 1 let rec cycleLength n = if n % 2I = 0I then cycleLength (n/2I) else if n % 5I = 0I then cycleLength (n/5I) else naturalNumbers |> Seq.filter (fun x -> ((pown 10I x) - 1I) % n = 0I) |> Seq.head let answer = [1I..999I] |> Seq.maxBy cycleLength

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

- If you want a one-stop shop to help you
**quickly level up your serverless skills**, you should check out my**Production-Ready Serverless**workshop. Over 20 AWS Heroes & Community Builders have passed through this workshop, plus 1000+ students from the likes of AWS, LEGO, Booking, HBO and Siemens. - If you want to learn
**how to test serverless applications**without all the pain and hassle, you should check out my latest course,**Testing Serverless Architectures**. - If you’re a manager or founder and want to help your team
**move faster and build better software**, then check out my**consulting services**. - If you just want to hang out, talk serverless, or ask for help, then you should join my
**FREE****Community**.

Omulet p26 =

let getSeqLen i =

let rec loop rem remainders rlen =

match rem with

|x when List.exists (fun y -> y = x) remainders -> rlen

|x -> let r = ((rem*10)%i)

match r with

|0 -> rlen

|r -> loop r (x::remainders) (rlen+1)

loop 1 [] 0

let findMax =

let rec loop maxLen maxI i =

match i with

|i when i (maxLen, maxI)

|0 -> (maxLen, maxI)

|i -> let iLen = getSeqLen i

match iLen > maxLen with

|true -> loop iLen i (i-1)

|false -> loop maxLen maxI (i-1)

loop 0 0 1000

findMax