initial commit

2025-08-03 20:16:55 -07:00
commit 87a130499d
89 changed files with 10241 additions and 0 deletions
@@ -0,0 +1,33 @@
 #Ignore thumbnails created by Windows
 Thumbs.db
 #Ignore files built by Visual Studio
 *.obj
 *.exe
 *.pdb
 *.user
 *.aps
 *.pch
 *.vspscc
 *_i.c
 *_p.c
 *.ncb
 *.suo
 *.tlb
 *.tlh
 *.bak
 *.cache
 *.ilk
 *.log
 [Bb]in
 [Dd]ebug*/
 *.lib
 *.sbr
 obj/
 [Rr]elease*/
 _ReSharper*/
 [Tt]est[Rr]esult*
 .vs/
 .idea/
 #Nuget packages folder
 packages/
@@ -0,0 +1,16 @@
 $arr = New-Object bool[] 2000000
 $arr[0] = $arr[1] = $TRUE
 $sum = 0
 for ($i=2; $i -lt $arr.Length; $i++)
 {
 	if ($arr[$i] -eq $TRUE)
 	{
 		continue
 	}
 	for ($j=$i*2; $j -lt $arr.Length; $j += $i)
 	{
 		$arr[$j] = $TRUE
 	}
 	$sum += $i
 	write-host "$i, $sum"
 }
@@ -0,0 +1,54 @@
 module _101
 open common
 open System
 let leGrange points x =
    points
    |> Seq.mapi (fun j (xj,y) -> 
        y * (
            points
            |> Seq.mapi (fun k (xk,_) -> 
                    if (j = k) then 1.0 else
                    (x - xk) / (xj - xk)
                )
            |> Seq.fold (*) 1.0
            )
        )
    |> Seq.sum
 let rec polynomialGen p x =
    if p = 0 then 1L else
    let rest = polynomialGen (p-1) x
    let this = int64 (Math.Pow(float x, float p))
    if p % 2 = 0 then
        rest + this
    else
        rest - this
 let poly10 = polynomialGen 10
 let cube x =
    int64 (Math.Pow(float x,3.0))
 let funTup f n = (n, f n)
 let sumOfFITsOfBOPs =
    let leGrangeTermChecker f seqLimit =
        [1..seqLimit]
        |> Seq.map (fun n -> (float n, float (f n)))
        |> (fun points -> 
            let nth = points |> Seq.nth (seqLimit - 1) |> snd
            let pointsMinusLast = points |> Seq.take (seqLimit - 1)
            let nthLegrange = leGrange pointsMinusLast (float seqLimit)
            (int64 nth, int64 nthLegrange)
            )
    allIntegers |> Seq.skip 2
    |> Seq.map (leGrangeTermChecker poly10)
    |> Seq.take 11
    //|> Seq.takeWhile (fun (nth,nthLeGrange) ->  .Abs( nth - nthLeGrange) < 2)
    |> Seq.toArray
    //|> Array.map snd
    //|> Array.sum
@@ -0,0 +1,57 @@
 module _11
 open System
 open System.IO
 let rightTrans = (0, 1)
 let downTrans = (1, 0)
 let sidewayRightTrans = (1, 1)
 let sidewayLeftTrans = (1, -1)
 let len = 4
 let maximum max v = if v > max then v else max
 let maxProduct =
    let getData = 
        let lines = File.ReadAllLines(@"11.txt")
        let convertDataRow(line:string) =
            line.Split(' ') |> Array.map int
        lines |> Array.map convertDataRow
    let rows = getData
    let rowLen = rows.Length
    let colLen = rows.[0].Length
    let getAdjacentCells (r, c) (rInc, cInc) =
        if (r + rInc*len > rowLen 
            || c + cInc*len > colLen
            || c + cInc*len < 0) then
            Seq.empty
        else
            Seq.init len (fun i -> rows.[r + rInc*i].[c + cInc*i])
    seq{
        for r in 0..rowLen-1 do
        for c in 0..colLen-1 do
            let getCells = getAdjacentCells (r, c)
            let product = Seq.fold (*) 1
            yield getCells rightTrans |> product
            yield getCells downTrans |> product
            yield getCells sidewayRightTrans |> product
            yield getCells sidewayLeftTrans |> product 
        }
        |> Seq.fold maximum -1
 (*
 for row in rows do
    for cell in row do
        printf "%u " cell
    printf "\n"
 *)
@@ -0,0 +1,3 @@
 $file = gc 11.txt
 $arr = New-Object int[][] 2000000
@@ -0,0 +1,20 @@
 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
 32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
 67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
 24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
 21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
@@ -0,0 +1,18 @@
 module _112
 let bouncy90 =
    let bouncy n =
        common.numDigits n
        |> Seq.pairwise
        |> Seq.filter (fun (i,j) -> i <> j)
        |> Seq.map (fun (i,j) -> i > j)
        |> Seq.distinct
        |> Seq.length > 1
    common.allIntegers
    |> Seq.skip 1
    |> Seq.map (fun i -> (i,bouncy i))
    |> Seq.scan (fun (t,f) (i,b) -> 
        if b then (t+1,f) else (t,f+1)) (0,0)
    |> Seq.map (fun (t,f) -> if t = 0 then 0.0 else ((float t)/((float t)+(float f))))
    |> Seq.findIndex ((<=) 0.99)
@@ -0,0 +1,17 @@
 module _12
 open System
 let fiveDivisorTriangle =
    let root (n : int) = int( Math.Sqrt(float(n)) )
    // observation: if number has a factor < sqrt(num), then it has a corresponding
    //   factor > sqrt(num)
    let factorCount x = Seq.sum (seq { for i = 1 to root x do if x % i = 0 then yield 2 })
    let result =
        (1, 0) |> Seq.unfold (fun (num,acc) -> 
                    Some(num + acc, (num + 1, num + acc)))
                 |> Seq.filter (fun x -> 
                    let factCount = factorCount x
                    factCount >= 500 )
                 |> Seq.head
    result
@@ -0,0 +1,36 @@
 module _13
 open System
 open System.IO
 let getSum =
    let numbers = File.ReadAllLines(@"13.txt")
    let add i carry =
        let sum = carry + 
                    (Seq.sum 
                        (seq 
                            { for string in numbers 
                                do yield System.Int32.Parse(string.Substring(string.Length - i, 1)) }
                         )
                     )
        (sum % 10, int(sum / 10))
    let unfold (i, carry) =
        if i = 51 then
            None
        else
            let (digit, nextCarry) = add i carry
            if i <> 50 then 
                Some(digit.ToString(), (i+1, nextCarry))
            else 
                Some(nextCarry.ToString() + digit.ToString(), (i+1, nextCarry))
    let number_string = 
        Seq.unfold unfold (1, 0)
        |> Seq.reduce (fun current next -> next + current)
    let hard = number_string.Substring(0, 10)
    hard
@@ -0,0 +1,100 @@
 37107287533902102798797998220837590246510135740250
 46376937677490009712648124896970078050417018260538
 74324986199524741059474233309513058123726617309629
 91942213363574161572522430563301811072406154908250
 23067588207539346171171980310421047513778063246676
 89261670696623633820136378418383684178734361726757
 28112879812849979408065481931592621691275889832738
 44274228917432520321923589422876796487670272189318
 47451445736001306439091167216856844588711603153276
 70386486105843025439939619828917593665686757934951
 62176457141856560629502157223196586755079324193331
 64906352462741904929101432445813822663347944758178
 92575867718337217661963751590579239728245598838407
 58203565325359399008402633568948830189458628227828
 80181199384826282014278194139940567587151170094390
 35398664372827112653829987240784473053190104293586
 86515506006295864861532075273371959191420517255829
 71693888707715466499115593487603532921714970056938
 54370070576826684624621495650076471787294438377604
 53282654108756828443191190634694037855217779295145
 36123272525000296071075082563815656710885258350721
 45876576172410976447339110607218265236877223636045
 17423706905851860660448207621209813287860733969412
 81142660418086830619328460811191061556940512689692
 51934325451728388641918047049293215058642563049483
 62467221648435076201727918039944693004732956340691
 15732444386908125794514089057706229429197107928209
 55037687525678773091862540744969844508330393682126
 18336384825330154686196124348767681297534375946515
 80386287592878490201521685554828717201219257766954
 78182833757993103614740356856449095527097864797581
 16726320100436897842553539920931837441497806860984
 48403098129077791799088218795327364475675590848030
 87086987551392711854517078544161852424320693150332
 59959406895756536782107074926966537676326235447210
 69793950679652694742597709739166693763042633987085
 41052684708299085211399427365734116182760315001271
 65378607361501080857009149939512557028198746004375
 35829035317434717326932123578154982629742552737307
 94953759765105305946966067683156574377167401875275
 88902802571733229619176668713819931811048770190271
 25267680276078003013678680992525463401061632866526
 36270218540497705585629946580636237993140746255962
 24074486908231174977792365466257246923322810917141
 91430288197103288597806669760892938638285025333403
 34413065578016127815921815005561868836468420090470
 23053081172816430487623791969842487255036638784583
 11487696932154902810424020138335124462181441773470
 63783299490636259666498587618221225225512486764533
 67720186971698544312419572409913959008952310058822
 95548255300263520781532296796249481641953868218774
 76085327132285723110424803456124867697064507995236
 37774242535411291684276865538926205024910326572967
 23701913275725675285653248258265463092207058596522
 29798860272258331913126375147341994889534765745501
 18495701454879288984856827726077713721403798879715
 38298203783031473527721580348144513491373226651381
 34829543829199918180278916522431027392251122869539
 40957953066405232632538044100059654939159879593635
 29746152185502371307642255121183693803580388584903
 41698116222072977186158236678424689157993532961922
 62467957194401269043877107275048102390895523597457
 23189706772547915061505504953922979530901129967519
 86188088225875314529584099251203829009407770775672
 11306739708304724483816533873502340845647058077308
 82959174767140363198008187129011875491310547126581
 97623331044818386269515456334926366572897563400500
 42846280183517070527831839425882145521227251250327
 55121603546981200581762165212827652751691296897789
 32238195734329339946437501907836945765883352399886
 75506164965184775180738168837861091527357929701337
 62177842752192623401942399639168044983993173312731
 32924185707147349566916674687634660915035914677504
 99518671430235219628894890102423325116913619626622
 73267460800591547471830798392868535206946944540724
 76841822524674417161514036427982273348055556214818
 97142617910342598647204516893989422179826088076852
 87783646182799346313767754307809363333018982642090
 10848802521674670883215120185883543223812876952786
 71329612474782464538636993009049310363619763878039
 62184073572399794223406235393808339651327408011116
 66627891981488087797941876876144230030984490851411
 60661826293682836764744779239180335110989069790714
 85786944089552990653640447425576083659976645795096
 66024396409905389607120198219976047599490197230297
 64913982680032973156037120041377903785566085089252
 16730939319872750275468906903707539413042652315011
 94809377245048795150954100921645863754710598436791
 78639167021187492431995700641917969777599028300699
 15368713711936614952811305876380278410754449733078
 40789923115535562561142322423255033685442488917353
 44889911501440648020369068063960672322193204149535
 41503128880339536053299340368006977710650566631954
 81234880673210146739058568557934581403627822703280
 82616570773948327592232845941706525094512325230608
 22918802058777319719839450180888072429661980811197
 77158542502016545090413245809786882778948721859617
 72107838435069186155435662884062257473692284509516
 20849603980134001723930671666823555245252804609722
 53503534226472524250874054075591789781264330331690
@@ -0,0 +1,15 @@
 module _14
 let collatzConjecture n =
    match n with
        | 0L -> None
        | 1L -> Some(1L,0L)
        | n -> Some(n,
                    if n % 2L = 0L then n/2L
                    else if n % 2L = 1L then 3L*n + 1L
                    else 1L)
 let getLongestChain =
    [1L..1000000L]
        |> Seq.map (fun i -> (i |> Seq.unfold collatzConjecture |> Seq.length, i))
        |> Seq.max
@@ -0,0 +1,7 @@
 $assemblyName = gci .\Oyster.IntX.dll | % {$_.FullName }
 [System.Reflection.Assembly]::LoadFile($assemblyName)
 $num = [Oyster.Math.IntX]::Pow(2,1000) | % {$_.ToString() }
 $sum = 0
 [char[]]$num | % { $sum += [int][string]$_;}
 $sum
@@ -0,0 +1,81 @@
 module _17
 open System.Text.RegularExpressions
 let rec numberToWords i =
    let firstDigit number =
        int (number.ToString().Substring(0,1))
    let remainingDigits number =
        int (number.ToString().Substring(1))
    let numberHeadTuple i =
        (firstDigit i, remainingDigits i)
    let concatWith separator s1 s2 =
        if not (System.String.IsNullOrEmpty(s2))
            then s1 + separator + s2
        else
            s1
    let hyphen = concatWith "-"
    let concatAnd = concatWith " and "
    match i.ToString().Length with
        | 1 ->
            match i with
                | 1 -> "one"
                | 2 -> "two"
                | 3 -> "three"
                | 4-> "four"
                | 5 -> "five"
                | 6 -> "six"
                | 7 -> "seven"
                | 8 -> "eight"
                | 9 -> "nine"
                | _ -> ""
        | 2 ->
            match numberHeadTuple i with
                | (1,0) -> "ten"
                | (1,1) -> "eleven"
                | (1,2) -> "twelve"
                | (1,3) -> "thirteen"
                | (1,4) -> "fourteen"
                | (1,5) -> "fifteen"
                | (1,8) -> "eighteen"
                | (1,j) -> (numberToWords j) + "teen"
                | (2,j) -> (numberToWords j) |> hyphen "twenty" 
                | (3,j) -> (numberToWords j) |> hyphen "thirty" 
                | (4,j) -> (numberToWords j) |> hyphen "forty"
                | (5,j) -> (numberToWords j) |> hyphen "fifty"
                | (6,j) -> (numberToWords j) |> hyphen "sixty"
                | (7,j) -> (numberToWords j) |> hyphen "seventy"
                | (8,j) -> (numberToWords j) |> hyphen "eighty"
                | (9,j) -> (numberToWords j) |> hyphen "ninety"
                | (_, _) -> "wtf"
        | 3 ->
            let (first,remaining) = numberHeadTuple i
            (numberToWords remaining) |> concatAnd ((numberToWords first) + " hundred") 
        | 4 -> 
            let (first,remaining) = numberHeadTuple i
            (numberToWords remaining) |> concatAnd ((numberToWords first) + " thousand") 
        | _ -> "unknown"
 let getNumberWords =
    let nums = [1..1000]
    let numWords = Seq.map numberToWords nums
    //printfn "%s" (String.concat "\n" numWords)
    let strip s = Regex.Replace(s, "[^a-z]", "")
    numWords |> Seq.fold (fun acc elem -> acc + (strip elem).Length) 0
 //let getNumberWords =
 //    let nums = [1..100]
 //    let strip s = Regex.Replace(s, "[^a-z]", "")
 //    nums 
 //    |> Seq.map (fun n -> (n, ((numberToWords >> strip) n).Length, numberToWords n))
 //    |> Seq.toArray
 //    |> Array.filter (fun (n, l, _) -> n % l = 0)
@@ -0,0 +1,18 @@
 module _18
 open System.IO
 let getTriangleMaxTotal =
    let t = 
        File.ReadAllLines(@"18_67.txt") 
        |> Array.map (fun line -> line.Split(' ') |> Array.map int)
        |> Array.rev
    for i in 1 .. t.Length - 1 do
        for j in 0 .. t.[i].Length - 1 do
            let current = t.[i].[j]
            let prev = max t.[i - 1].[j] t.[i - 1].[j + 1]
            t.[i].[j] <- current + prev
    t.[t.Length - 1].[0]
@@ -0,0 +1,15 @@
 75
 95 64
 17 47 82
 18 35 87 10
 20 04 82 47 65
 19 01 23 75 03 34
 88 02 77 73 07 63 67
 99 65 04 28 06 16 70 92
 41 41 26 56 83 40 80 70 33
 41 48 72 33 47 32 37 16 94 29
 53 71 44 65 25 43 91 52 97 51 14
 70 11 33 28 77 73 17 78 39 68 17 57
 91 71 52 38 17 14 91 43 58 50 27 29 48
 63 66 04 68 89 53 67 30 73 16 69 87 40 31
 04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
@@ -0,0 +1,100 @@
 59
 73 41
 52 40 09
 26 53 06 34
 10 51 87 86 81
 61 95 66 57 25 68
 90 81 80 38 92 67 73
 30 28 51 76 81 18 75 44
 84 14 95 87 62 81 17 78 58
 21 46 71 58 02 79 62 39 31 09
 56 34 35 53 78 31 81 18 90 93 15
 78 53 04 21 84 93 32 13 97 11 37 51
 45 03 81 79 05 18 78 86 13 30 63 99 95
 39 87 96 28 03 38 42 17 82 87 58 07 22 57
 06 17 51 17 07 93 09 07 75 97 95 78 87 08 53
 67 66 59 60 88 99 94 65 55 77 55 34 27 53 78 28
 76 40 41 04 87 16 09 42 75 69 23 97 30 60 10 79 87
 12 10 44 26 21 36 32 84 98 60 13 12 36 16 63 31 91 35
 70 39 06 05 55 27 38 48 28 22 34 35 62 62 15 14 94 89 86
 66 56 68 84 96 21 34 34 34 81 62 40 65 54 62 05 98 03 02 60
 38 89 46 37 99 54 34 53 36 14 70 26 02 90 45 13 31 61 83 73 47
 36 10 63 96 60 49 41 05 37 42 14 58 84 93 96 17 09 43 05 43 06 59
 66 57 87 57 61 28 37 51 84 73 79 15 39 95 88 87 43 39 11 86 77 74 18
 54 42 05 79 30 49 99 73 46 37 50 02 45 09 54 52 27 95 27 65 19 45 26 45
 71 39 17 78 76 29 52 90 18 99 78 19 35 62 71 19 23 65 93 85 49 33 75 09 02
 33 24 47 61 60 55 32 88 57 55 91 54 46 57 07 77 98 52 80 99 24 25 46 78 79 05
 92 09 13 55 10 67 26 78 76 82 63 49 51 31 24 68 05 57 07 54 69 21 67 43 17 63 12
 24 59 06 08 98 74 66 26 61 60 13 03 09 09 24 30 71 08 88 70 72 70 29 90 11 82 41 34
 66 82 67 04 36 60 92 77 91 85 62 49 59 61 30 90 29 94 26 41 89 04 53 22 83 41 09 74 90
 48 28 26 37 28 52 77 26 51 32 18 98 79 36 62 13 17 08 19 54 89 29 73 68 42 14 08 16 70 37
 37 60 69 70 72 71 09 59 13 60 38 13 57 36 09 30 43 89 30 39 15 02 44 73 05 73 26 63 56 86 12
 55 55 85 50 62 99 84 77 28 85 03 21 27 22 19 26 82 69 54 04 13 07 85 14 01 15 70 59 89 95 10 19
 04 09 31 92 91 38 92 86 98 75 21 05 64 42 62 84 36 20 73 42 21 23 22 51 51 79 25 45 85 53 03 43 22
 75 63 02 49 14 12 89 14 60 78 92 16 44 82 38 30 72 11 46 52 90 27 08 65 78 03 85 41 57 79 39 52 33 48
 78 27 56 56 39 13 19 43 86 72 58 95 39 07 04 34 21 98 39 15 39 84 89 69 84 46 37 57 59 35 59 50 26 15 93
 42 89 36 27 78 91 24 11 17 41 05 94 07 69 51 96 03 96 47 90 90 45 91 20 50 56 10 32 36 49 04 53 85 92 25 65
 52 09 61 30 61 97 66 21 96 92 98 90 06 34 96 60 32 69 68 33 75 84 18 31 71 50 84 63 03 03 19 11 28 42 75 45 45
 61 31 61 68 96 34 49 39 05 71 76 59 62 67 06 47 96 99 34 21 32 47 52 07 71 60 42 72 94 56 82 83 84 40 94 87 82 46
 01 20 60 14 17 38 26 78 66 81 45 95 18 51 98 81 48 16 53 88 37 52 69 95 72 93 22 34 98 20 54 27 73 61 56 63 60 34 63
 93 42 94 83 47 61 27 51 79 79 45 01 44 73 31 70 83 42 88 25 53 51 30 15 65 94 80 44 61 84 12 77 02 62 02 65 94 42 14 94
 32 73 09 67 68 29 74 98 10 19 85 48 38 31 85 67 53 93 93 77 47 67 39 72 94 53 18 43 77 40 78 32 29 59 24 06 02 83 50 60 66
 32 01 44 30 16 51 15 81 98 15 10 62 86 79 50 62 45 60 70 38 31 85 65 61 64 06 69 84 14 22 56 43 09 48 66 69 83 91 60 40 36 61
 92 48 22 99 15 95 64 43 01 16 94 02 99 19 17 69 11 58 97 56 89 31 77 45 67 96 12 73 08 20 36 47 81 44 50 64 68 85 40 81 85 52 09
 91 35 92 45 32 84 62 15 19 64 21 66 06 01 52 80 62 59 12 25 88 28 91 50 40 16 22 99 92 79 87 51 21 77 74 77 07 42 38 42 74 83 02 05
 46 19 77 66 24 18 05 32 02 84 31 99 92 58 96 72 91 36 62 99 55 29 53 42 12 37 26 58 89 50 66 19 82 75 12 48 24 87 91 85 02 07 03 76 86
 99 98 84 93 07 17 33 61 92 20 66 60 24 66 40 30 67 05 37 29 24 96 03 27 70 62 13 04 45 47 59 88 43 20 66 15 46 92 30 04 71 66 78 70 53 99
 67 60 38 06 88 04 17 72 10 99 71 07 42 25 54 05 26 64 91 50 45 71 06 30 67 48 69 82 08 56 80 67 18 46 66 63 01 20 08 80 47 07 91 16 03 79 87
 18 54 78 49 80 48 77 40 68 23 60 88 58 80 33 57 11 69 55 53 64 02 94 49 60 92 16 35 81 21 82 96 25 24 96 18 02 05 49 03 50 77 06 32 84 27 18 38
 68 01 50 04 03 21 42 94 53 24 89 05 92 26 52 36 68 11 85 01 04 42 02 45 15 06 50 04 53 73 25 74 81 88 98 21 67 84 79 97 99 20 95 04 40 46 02 58 87
 94 10 02 78 88 52 21 03 88 60 06 53 49 71 20 91 12 65 07 49 21 22 11 41 58 99 36 16 09 48 17 24 52 36 23 15 72 16 84 56 02 99 43 76 81 71 29 39 49 17
 64 39 59 84 86 16 17 66 03 09 43 06 64 18 63 29 68 06 23 07 87 14 26 35 17 12 98 41 53 64 78 18 98 27 28 84 80 67 75 62 10 11 76 90 54 10 05 54 41 39 66
 43 83 18 37 32 31 52 29 95 47 08 76 35 11 04 53 35 43 34 10 52 57 12 36 20 39 40 55 78 44 07 31 38 26 08 15 56 88 86 01 52 62 10 24 32 05 60 65 53 28 57 99
 03 50 03 52 07 73 49 92 66 80 01 46 08 67 25 36 73 93 07 42 25 53 13 96 76 83 87 90 54 89 78 22 78 91 73 51 69 09 79 94 83 53 09 40 69 62 10 79 49 47 03 81 30
 71 54 73 33 51 76 59 54 79 37 56 45 84 17 62 21 98 69 41 95 65 24 39 37 62 03 24 48 54 64 46 82 71 78 33 67 09 16 96 68 52 74 79 68 32 21 13 78 96 60 09 69 20 36
 73 26 21 44 46 38 17 83 65 98 07 23 52 46 61 97 33 13 60 31 70 15 36 77 31 58 56 93 75 68 21 36 69 53 90 75 25 82 39 50 65 94 29 30 11 33 11 13 96 02 56 47 07 49 02
 76 46 73 30 10 20 60 70 14 56 34 26 37 39 48 24 55 76 84 91 39 86 95 61 50 14 53 93 64 67 37 31 10 84 42 70 48 20 10 72 60 61 84 79 69 65 99 73 89 25 85 48 92 56 97 16
 03 14 80 27 22 30 44 27 67 75 79 32 51 54 81 29 65 14 19 04 13 82 04 91 43 40 12 52 29 99 07 76 60 25 01 07 61 71 37 92 40 47 99 66 57 01 43 44 22 40 53 53 09 69 26 81 07
 49 80 56 90 93 87 47 13 75 28 87 23 72 79 32 18 27 20 28 10 37 59 21 18 70 04 79 96 03 31 45 71 81 06 14 18 17 05 31 50 92 79 23 47 09 39 47 91 43 54 69 47 42 95 62 46 32 85
 37 18 62 85 87 28 64 05 77 51 47 26 30 65 05 70 65 75 59 80 42 52 25 20 44 10 92 17 71 95 52 14 77 13 24 55 11 65 26 91 01 30 63 15 49 48 41 17 67 47 03 68 20 90 98 32 04 40 68
 90 51 58 60 06 55 23 68 05 19 76 94 82 36 96 43 38 90 87 28 33 83 05 17 70 83 96 93 06 04 78 47 80 06 23 84 75 23 87 72 99 14 50 98 92 38 90 64 61 58 76 94 36 66 87 80 51 35 61 38
 57 95 64 06 53 36 82 51 40 33 47 14 07 98 78 65 39 58 53 06 50 53 04 69 40 68 36 69 75 78 75 60 03 32 39 24 74 47 26 90 13 40 44 71 90 76 51 24 36 50 25 45 70 80 61 80 61 43 90 64 11
 18 29 86 56 68 42 79 10 42 44 30 12 96 18 23 18 52 59 02 99 67 46 60 86 43 38 55 17 44 93 42 21 55 14 47 34 55 16 49 24 23 29 96 51 55 10 46 53 27 92 27 46 63 57 30 65 43 27 21 20 24 83
 81 72 93 19 69 52 48 01 13 83 92 69 20 48 69 59 20 62 05 42 28 89 90 99 32 72 84 17 08 87 36 03 60 31 36 36 81 26 97 36 48 54 56 56 27 16 91 08 23 11 87 99 33 47 02 14 44 73 70 99 43 35 33
 90 56 61 86 56 12 70 59 63 32 01 15 81 47 71 76 95 32 65 80 54 70 34 51 40 45 33 04 64 55 78 68 88 47 31 47 68 87 03 84 23 44 89 72 35 08 31 76 63 26 90 85 96 67 65 91 19 14 17 86 04 71 32 95
 37 13 04 22 64 37 37 28 56 62 86 33 07 37 10 44 52 82 52 06 19 52 57 75 90 26 91 24 06 21 14 67 76 30 46 14 35 89 89 41 03 64 56 97 87 63 22 34 03 79 17 45 11 53 25 56 96 61 23 18 63 31 37 37 47
 77 23 26 70 72 76 77 04 28 64 71 69 14 85 96 54 95 48 06 62 99 83 86 77 97 75 71 66 30 19 57 90 33 01 60 61 14 12 90 99 32 77 56 41 18 14 87 49 10 14 90 64 18 50 21 74 14 16 88 05 45 73 82 47 74 44
 22 97 41 13 34 31 54 61 56 94 03 24 59 27 98 77 04 09 37 40 12 26 87 09 71 70 07 18 64 57 80 21 12 71 83 94 60 39 73 79 73 19 97 32 64 29 41 07 48 84 85 67 12 74 95 20 24 52 41 67 56 61 29 93 35 72 69
 72 23 63 66 01 11 07 30 52 56 95 16 65 26 83 90 50 74 60 18 16 48 43 77 37 11 99 98 30 94 91 26 62 73 45 12 87 73 47 27 01 88 66 99 21 41 95 80 02 53 23 32 61 48 32 43 43 83 14 66 95 91 19 81 80 67 25 88
 08 62 32 18 92 14 83 71 37 96 11 83 39 99 05 16 23 27 10 67 02 25 44 11 55 31 46 64 41 56 44 74 26 81 51 31 45 85 87 09 81 95 22 28 76 69 46 48 64 87 67 76 27 89 31 11 74 16 62 03 60 94 42 47 09 34 94 93 72
 56 18 90 18 42 17 42 32 14 86 06 53 33 95 99 35 29 15 44 20 49 59 25 54 34 59 84 21 23 54 35 90 78 16 93 13 37 88 54 19 86 67 68 55 66 84 65 42 98 37 87 56 33 28 58 38 28 38 66 27 52 21 81 15 08 22 97 32 85 27
 91 53 40 28 13 34 91 25 01 63 50 37 22 49 71 58 32 28 30 18 68 94 23 83 63 62 94 76 80 41 90 22 82 52 29 12 18 56 10 08 35 14 37 57 23 65 67 40 72 39 93 39 70 89 40 34 07 46 94 22 20 05 53 64 56 30 05 56 61 88 27
 23 95 11 12 37 69 68 24 66 10 87 70 43 50 75 07 62 41 83 58 95 93 89 79 45 39 02 22 05 22 95 43 62 11 68 29 17 40 26 44 25 71 87 16 70 85 19 25 59 94 90 41 41 80 61 70 55 60 84 33 95 76 42 63 15 09 03 40 38 12 03 32
 09 84 56 80 61 55 85 97 16 94 82 94 98 57 84 30 84 48 93 90 71 05 95 90 73 17 30 98 40 64 65 89 07 79 09 19 56 36 42 30 23 69 73 72 07 05 27 61 24 31 43 48 71 84 21 28 26 65 65 59 65 74 77 20 10 81 61 84 95 08 52 23 70
 47 81 28 09 98 51 67 64 35 51 59 36 92 82 77 65 80 24 72 53 22 07 27 10 21 28 30 22 48 82 80 48 56 20 14 43 18 25 50 95 90 31 77 08 09 48 44 80 90 22 93 45 82 17 13 96 25 26 08 73 34 99 06 49 24 06 83 51 40 14 15 10 25 01
 54 25 10 81 30 64 24 74 75 80 36 75 82 60 22 69 72 91 45 67 03 62 79 54 89 74 44 83 64 96 66 73 44 30 74 50 37 05 09 97 70 01 60 46 37 91 39 75 75 18 58 52 72 78 51 81 86 52 08 97 01 46 43 66 98 62 81 18 70 93 73 08 32 46 34
 96 80 82 07 59 71 92 53 19 20 88 66 03 26 26 10 24 27 50 82 94 73 63 08 51 33 22 45 19 13 58 33 90 15 22 50 36 13 55 06 35 47 82 52 33 61 36 27 28 46 98 14 73 20 73 32 16 26 80 53 47 66 76 38 94 45 02 01 22 52 47 96 64 58 52 39
 88 46 23 39 74 63 81 64 20 90 33 33 76 55 58 26 10 46 42 26 74 74 12 83 32 43 09 02 73 55 86 54 85 34 28 23 29 79 91 62 47 41 82 87 99 22 48 90 20 05 96 75 95 04 43 28 81 39 81 01 28 42 78 25 39 77 90 57 58 98 17 36 73 22 63 74 51
 29 39 74 94 95 78 64 24 38 86 63 87 93 06 70 92 22 16 80 64 29 52 20 27 23 50 14 13 87 15 72 96 81 22 08 49 72 30 70 24 79 31 16 64 59 21 89 34 96 91 48 76 43 53 88 01 57 80 23 81 90 79 58 01 80 87 17 99 86 90 72 63 32 69 14 28 88 69
 37 17 71 95 56 93 71 35 43 45 04 98 92 94 84 96 11 30 31 27 31 60 92 03 48 05 98 91 86 94 35 90 90 08 48 19 33 28 68 37 59 26 65 96 50 68 22 07 09 49 34 31 77 49 43 06 75 17 81 87 61 79 52 26 27 72 29 50 07 98 86 01 17 10 46 64 24 18 56
 51 30 25 94 88 85 79 91 40 33 63 84 49 67 98 92 15 26 75 19 82 05 18 78 65 93 61 48 91 43 59 41 70 51 22 15 92 81 67 91 46 98 11 11 65 31 66 10 98 65 83 21 05 56 05 98 73 67 46 74 69 34 08 30 05 52 07 98 32 95 30 94 65 50 24 63 28 81 99 57
 19 23 61 36 09 89 71 98 65 17 30 29 89 26 79 74 94 11 44 48 97 54 81 55 39 66 69 45 28 47 13 86 15 76 74 70 84 32 36 33 79 20 78 14 41 47 89 28 81 05 99 66 81 86 38 26 06 25 13 60 54 55 23 53 27 05 89 25 23 11 13 54 59 54 56 34 16 24 53 44 06
 13 40 57 72 21 15 60 08 04 19 11 98 34 45 09 97 86 71 03 15 56 19 15 44 97 31 90 04 87 87 76 08 12 30 24 62 84 28 12 85 82 53 99 52 13 94 06 65 97 86 09 50 94 68 69 74 30 67 87 94 63 07 78 27 80 36 69 41 06 92 32 78 37 82 30 05 18 87 99 72 19 99
 44 20 55 77 69 91 27 31 28 81 80 27 02 07 97 23 95 98 12 25 75 29 47 71 07 47 78 39 41 59 27 76 13 15 66 61 68 35 69 86 16 53 67 63 99 85 41 56 08 28 33 40 94 76 90 85 31 70 24 65 84 65 99 82 19 25 54 37 21 46 33 02 52 99 51 33 26 04 87 02 08 18 96
 54 42 61 45 91 06 64 79 80 82 32 16 83 63 42 49 19 78 65 97 40 42 14 61 49 34 04 18 25 98 59 30 82 72 26 88 54 36 21 75 03 88 99 53 46 51 55 78 22 94 34 40 68 87 84 25 30 76 25 08 92 84 42 61 40 38 09 99 40 23 29 39 46 55 10 90 35 84 56 70 63 23 91 39
 52 92 03 71 89 07 09 37 68 66 58 20 44 92 51 56 13 71 79 99 26 37 02 06 16 67 36 52 58 16 79 73 56 60 59 27 44 77 94 82 20 50 98 33 09 87 94 37 40 83 64 83 58 85 17 76 53 02 83 52 22 27 39 20 48 92 45 21 09 42 24 23 12 37 52 28 50 78 79 20 86 62 73 20 59
 54 96 80 15 91 90 99 70 10 09 58 90 93 50 81 99 54 38 36 10 30 11 35 84 16 45 82 18 11 97 36 43 96 79 97 65 40 48 23 19 17 31 64 52 65 65 37 32 65 76 99 79 34 65 79 27 55 33 03 01 33 27 61 28 66 08 04 70 49 46 48 83 01 45 19 96 13 81 14 21 31 79 93 85 50 05
 92 92 48 84 59 98 31 53 23 27 15 22 79 95 24 76 05 79 16 93 97 89 38 89 42 83 02 88 94 95 82 21 01 97 48 39 31 78 09 65 50 56 97 61 01 07 65 27 21 23 14 15 80 97 44 78 49 35 33 45 81 74 34 05 31 57 09 38 94 07 69 54 69 32 65 68 46 68 78 90 24 28 49 51 45 86 35
 41 63 89 76 87 31 86 09 46 14 87 82 22 29 47 16 13 10 70 72 82 95 48 64 58 43 13 75 42 69 21 12 67 13 64 85 58 23 98 09 37 76 05 22 31 12 66 50 29 99 86 72 45 25 10 28 19 06 90 43 29 31 67 79 46 25 74 14 97 35 76 37 65 46 23 82 06 22 30 76 93 66 94 17 96 13 20 72
 63 40 78 08 52 09 90 41 70 28 36 14 46 44 85 96 24 52 58 15 87 37 05 98 99 39 13 61 76 38 44 99 83 74 90 22 53 80 56 98 30 51 63 39 44 30 91 91 04 22 27 73 17 35 53 18 35 45 54 56 27 78 48 13 69 36 44 38 71 25 30 56 15 22 73 43 32 69 59 25 93 83 45 11 34 94 44 39 92
 12 36 56 88 13 96 16 12 55 54 11 47 19 78 17 17 68 81 77 51 42 55 99 85 66 27 81 79 93 42 65 61 69 74 14 01 18 56 12 01 58 37 91 22 42 66 83 25 19 04 96 41 25 45 18 69 96 88 36 93 10 12 98 32 44 83 83 04 72 91 04 27 73 07 34 37 71 60 59 31 01 54 54 44 96 93 83 36 04 45
 30 18 22 20 42 96 65 79 17 41 55 69 94 81 29 80 91 31 85 25 47 26 43 49 02 99 34 67 99 76 16 14 15 93 08 32 99 44 61 77 67 50 43 55 87 55 53 72 17 46 62 25 50 99 73 05 93 48 17 31 70 80 59 09 44 59 45 13 74 66 58 94 87 73 16 14 85 38 74 99 64 23 79 28 71 42 20 37 82 31 23
 51 96 39 65 46 71 56 13 29 68 53 86 45 33 51 49 12 91 21 21 76 85 02 17 98 15 46 12 60 21 88 30 92 83 44 59 42 50 27 88 46 86 94 73 45 54 23 24 14 10 94 21 20 34 23 51 04 83 99 75 90 63 60 16 22 33 83 70 11 32 10 50 29 30 83 46 11 05 31 17 86 42 49 01 44 63 28 60 07 78 95 40
 44 61 89 59 04 49 51 27 69 71 46 76 44 04 09 34 56 39 15 06 94 91 75 90 65 27 56 23 74 06 23 33 36 69 14 39 05 34 35 57 33 22 76 46 56 10 61 65 98 09 16 69 04 62 65 18 99 76 49 18 72 66 73 83 82 40 76 31 89 91 27 88 17 35 41 35 32 51 32 67 52 68 74 85 80 57 07 11 62 66 47 22 67
 65 37 19 97 26 17 16 24 24 17 50 37 64 82 24 36 32 11 68 34 69 31 32 89 79 93 96 68 49 90 14 23 04 04 67 99 81 74 70 74 36 96 68 09 64 39 88 35 54 89 96 58 66 27 88 97 32 14 06 35 78 20 71 06 85 66 57 02 58 91 72 05 29 56 73 48 86 52 09 93 22 57 79 42 12 01 31 68 17 59 63 76 07 77
 73 81 14 13 17 20 11 09 01 83 08 85 91 70 84 63 62 77 37 07 47 01 59 95 39 69 39 21 99 09 87 02 97 16 92 36 74 71 90 66 33 73 73 75 52 91 11 12 26 53 05 26 26 48 61 50 90 65 01 87 42 47 74 35 22 73 24 26 56 70 52 05 48 41 31 18 83 27 21 39 80 85 26 08 44 02 71 07 63 22 05 52 19 08 20
 17 25 21 11 72 93 33 49 64 23 53 82 03 13 91 65 85 02 40 05 42 31 77 42 05 36 06 54 04 58 07 76 87 83 25 57 66 12 74 33 85 37 74 32 20 69 03 97 91 68 82 44 19 14 89 28 85 85 80 53 34 87 58 98 88 78 48 65 98 40 11 57 10 67 70 81 60 79 74 72 97 59 79 47 30 20 54 80 89 91 14 05 33 36 79 39
 60 85 59 39 60 07 57 76 77 92 06 35 15 72 23 41 45 52 95 18 64 79 86 53 56 31 69 11 91 31 84 50 44 82 22 81 41 40 30 42 30 91 48 94 74 76 64 58 74 25 96 57 14 19 03 99 28 83 15 75 99 01 89 85 79 50 03 95 32 67 44 08 07 41 62 64 29 20 14 76 26 55 48 71 69 66 19 72 44 25 14 01 48 74 12 98 07
 64 66 84 24 18 16 27 48 20 14 47 69 30 86 48 40 23 16 61 21 51 50 26 47 35 33 91 28 78 64 43 68 04 79 51 08 19 60 52 95 06 68 46 86 35 97 27 58 04 65 30 58 99 12 12 75 91 39 50 31 42 64 70 04 46 07 98 73 98 93 37 89 77 91 64 71 64 65 66 21 78 62 81 74 42 20 83 70 73 95 78 45 92 27 34 53 71 15
 30 11 85 31 34 71 13 48 05 14 44 03 19 67 23 73 19 57 06 90 94 72 57 69 81 62 59 68 88 57 55 69 49 13 07 87 97 80 89 05 71 05 05 26 38 40 16 62 45 99 18 38 98 24 21 26 62 74 69 04 85 57 77 35 58 67 91 79 79 57 86 28 66 34 72 51 76 78 36 95 63 90 08 78 47 63 45 31 22 70 52 48 79 94 15 77 61 67 68
 23 33 44 81 80 92 93 75 94 88 23 61 39 76 22 03 28 94 32 06 49 65 41 34 18 23 08 47 62 60 03 63 33 13 80 52 31 54 73 43 70 26 16 69 57 87 83 31 03 93 70 81 47 95 77 44 29 68 39 51 56 59 63 07 25 70 07 77 43 53 64 03 94 42 95 39 18 01 66 21 16 97 20 50 90 16 70 10 95 69 29 06 25 61 41 26 15 59 63 35
@@ -0,0 +1,15 @@
 75
 95 64
 17 47 82
 18 35 87 10
 20 04 82 47 65
 19 01 23 75 03 34
 88 02 77 73 07 63 67
 99 65 04 28 06 16 70 92
 41 41 26 56 83 40 80 70 33
 41 48 72 33 47 32 37 16 94 29
 53 71 44 65 25 43 91 52 97 51 14
 70 11 33 28 77 73 17 78 39 68 17 57
 91 71 52 38 17 14 91 43 58 50 27 29 48
 63 66 04 68 89 53 67 30 73 16 69 87 40 31
 04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
@@ -0,0 +1,62 @@
 module _19
 open common
 //1 Jan 1900 was a Monday.
 //Thirty days has September,
 //April, June and November.
 //All the rest have thirty-one,
 //Saving February alone,
 //Which has twenty-eight, rain or shine.
 //And on leap years, twenty-nine.
 //A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.
 type day =
    Sunday | Monday | Tuesday | Wednesday | Thursday | Friday | Saturday
 let dayNum d =
    match d with
    | Sunday -> 0
    | Monday -> 1
    | Tuesday -> 2
    | Wednesday -> 3
    | Thursday -> 4
    | Friday -> 5
    | Saturday -> 6
 let numDay n =
    match n with
    | 0 -> Sunday
    | 1 -> Monday
    | 2 -> Tuesday
    | 3 -> Wednesday
    | 4 -> Thursday
    | 5 -> Friday
    | 6 -> Saturday
    | _ -> raise(System.ArgumentException("No!"))
 type date =
    { Year : int;
      Month : int }
 let isLeapYear y =
    y % 4 = 0 && (y % 100 <> 0 || y % 400 = 0)
 let getDaysInMonth d =
    let thirtyMonths = [|9;4;6;11|];
    match d with
    | date when date.Month = 2 && isLeapYear date.Year -> 29
    | date when date.Month = 2 -> 28
    | date when Array.exists ((=) date.Month) thirtyMonths  -> 30
    | _ -> 31
 let getNextFirstDay d daysInMonth =
    (daysInMonth + (dayNum d)) % 7 |> numDay
 let firstSaturdays =
    //getNextFirstDay Thursday 30
    crossMapList [1900..1999] [1..12]
    |> Seq.map (fun (y, m) -> { Year = y; Month = m })
    |> Seq.scan (fun (day:day) ym -> getNextFirstDay day (getDaysInMonth ym)) Monday
    |> Seq.filter ((=) Sunday)
    |> Seq.length
@@ -0,0 +1,7 @@
 module _20
 let getSum =
    let n = [ 1I .. 100I ] |> List.fold (*) 1I
    (string n).ToCharArray()
        |> Array.map (string >> int)
        |> Array.fold (fun acc d -> acc + d) 0
@@ -0,0 +1,19 @@
 module _21
 let amicalbleNumbers len =
    // get divisor sums
    let dSums = common.divisors len |> Array.map (List.fold (+) 0)
    // find amicable ones
    [2..len] |> List.filter (fun i -> 
        dSums.[i] > 0 &&
        dSums.[i] <= len && 
        not (i = dSums.[i]) &&
        i < dSums.[i] &&
        i = dSums.[dSums.[i]]
        )
        |> List.map (fun i -> (i, dSums.[i]))
 let amicalbleSum =
    let a = amicalbleNumbers 10000
    let all = List.append (a |> List.map fst) (a |> List.map snd)
    all |> List.sum
@@ -0,0 +1,13 @@
 module _22
 open System.IO
 let nameScores =
    let names =
        File.ReadAllLines(@"22_names.txt")
        |> Seq.collect (fun l -> l.Split(','))
        |> Seq.map (fun w -> w.Substring(1, w.Length - 2))
        |> Seq.sort
    names
        |> Seq.mapi (fun i name -> (i + 1) * common.wordValue name)
        |> Seq.sum
@@ -0,0 +1,28 @@
 module _23
 let abundantUpperLimit = 28123
 let abundantNumbers =
    let dSums = 
        common.divisors abundantUpperLimit
        |> Array.mapi (fun i divisors -> (i,  List.fold (+) 0 divisors))
    dSums |> Array.choose ( fun (i, dSum) -> 
        match dSum with
        | abundant when dSum > i -> Some(i)
        | _ -> None
        )
 let sumNotAbundant = 
    let a = abundantNumbers
    // add all abubundant numbers together
    let sums = common.crossMap (+) a a |> Seq.distinct |> Seq.toArray
    let sna = 
        sums
        |> Set.ofSeq
        |> (-) (Set.ofList [1..abundantUpperLimit])
        |> Set.toSeq
        //|> Array.rev
    sna |> Seq.fold (+) 0
@@ -0,0 +1,5 @@
 module _24
 let run =
    common.permutations ([0..9] |> Set.ofList)
        |> Seq.nth 999999
@@ -0,0 +1,9 @@
 module _25
 let digitCount (d:bigint) =
    (string d).Length
 let find1000 =
    common.fibinoci 
        |> Seq.findIndex (fun f -> digitCount f = 1000) 
        |> (+) 1
@@ -0,0 +1,30 @@
 module _26
 let division d = 
    let digit = 10 / d
    let mutable remainder = 10 % d
    let mutable quotient = [(digit, remainder)]
    let mutable cycleIndex = None
    while remainder <> 0 && cycleIndex = None do
        remainder <- remainder * 10
        let digit =  remainder / d
        remainder <- remainder % d
        let next = (digit, remainder)
        let cycle = quotient |> List.tryFind (fun e -> e = next)
        if cycle <> None then 
            cycleIndex <- Some(
                 quotient.Length 
                 - (quotient |> List.findIndex (fun e -> e = next)) 
                 - 1)
        else quotient <- next :: quotient
    List.rev quotient |> List.map fst, cycleIndex
 let cycleLength d =
    match division d with
    | (_,None) -> 0
    | (q,Some(c)) -> q.Length - c
 let longestRecurringCycle =
    [2..1000] 
    |> List.mapi ( fun i d -> (i + 2, cycleLength d))
    |> List.maxBy snd
@@ -0,0 +1,24 @@
 module _27
 open System
 let quadraticConsecutivePrimes =
    let range = [-1000..1000]
    let isPrime = common.isPrimeFunByMax 100000
    let primeLength f =
        common.allIntegers
        |> Seq.map f
        |> Seq.takeWhile isPrime
        |> Seq.length
    let abs = common.crossMap (fun a b -> (a,b)) range range
    let quadradic (a,b) n =
        n*n + a*n + b
    abs
    |> Seq.map (fun ab -> (ab, ab |> (quadradic >> primeLength)))
    |> Seq.maxBy snd
    |> (fun ((a,b),_)-> a * b)
@@ -0,0 +1,12 @@
 module _28
 let sumNum =
    let sideLength count =
        seq {
            for i in 1..(count/2) do
                for l in 1..4 do
                    yield i * 2
        }
    sideLength 1001
    |> Seq.scan ( fun sum item -> sum + item) 1
    |> Seq.sum
@@ -0,0 +1,6 @@
 module _29
 let getDistinctTerms =
    let range = [2..100]
    common.crossMap (fun (a:int) b -> bigint.Pow(bigint a,b)) range range
    |> Seq.distinct |> Seq.length
@@ -0,0 +1,16 @@
 module _30
 let sumOfFifth n =
    common.numDigits n
    |> Seq.map (fun d -> System.Math.Pow(float d, 5.0))
    |> Seq.sum
    |> int
 let isSumOfFifth n =
    sumOfFifth n = n
 let sumOfSumOfFifthNumbers =
    [2..200000]
    |> List.map (fun n -> (n,isSumOfFifth n))
    |> List.filter (fun r -> snd r)
    |> List.sumBy fst
@@ -0,0 +1,13 @@
 module _31
 let getCurrencyCombos =
    let total, coins = 200, [1;2;5;10;20;50;100;200]
    let rec count (n, coins) =
        match n, coins with
        | 0,_ -> 1
        | n,_ when n < 0 -> 0
        | n,[] when n >= 1 -> 0
        | n,coins -> count (n, coins |> List.tail) + count (n - (coins |> List.head),coins)
    count (total, coins)
@@ -0,0 +1,12 @@
 module _32
 open common
 let panDigitalProduct =
    crossMapList [12..98] [123..987]
    |> Seq.append (crossMapList [1..9] [1234..9876])
    |> Seq.map (fun (x,y) -> [x;y;x*y])
    |> Seq.filter ((List.map unbox) >> isPanDigitalGroup)
    |> Seq.map (fun l -> l.[2])
    |> Seq.distinct
    |> Seq.sum
@@ -0,0 +1,37 @@
 module _33
 open common
 let cancelling =
    let nds = seq {
        for d in 11..99 do
            if d % 10 <> 0 then
                for n in 11..(d-1) do
                    if n % 10 <> 0 then
                        yield (n,d)
        }
    let cancelCommonDigits (n,d) =
        let nd = numDigits n
        let dd = numDigits d
        seq {
            for ndi in nd do
                for ddi in dd do
                    if ndi = ddi then
                        let ndmi = Array.filter ((<>) ndi) nd
                        let ddmi = Array.filter ((<>) ddi) dd
                        if (ndmi.Length > 0 && ddmi.Length > 0) then
                            yield (digitsNum ndmi, digitsNum ddmi)
        }
    nds
    |> Seq.collect (fun (n,d) -> 
        let f = float n/float d
        cancelCommonDigits (n,d) 
        |> Seq.map (fun (cn,cd) -> (float cn/float cd,cn,cd,n,d))
        |> Seq.filter (fun (cf,_,_,_,_) -> cf = f)
        )
    |> Seq.fold (fun (pn, pd) (_,n,d,_,_) -> (pn * n, pd * d)) (1,1)
    |> Fraction.reduce
    |> snd
@@ -0,0 +1,18 @@
 module _34
 let numSumDigitFactorials =
    let digitFactorials =
        [|0..9|]
        |> Array.map common.factorial
    let digitFactorialSum n =
        n
        |> common.numDigits
        |> Seq.map (Array.get digitFactorials)
        |> Seq.sum
    [3..1000000]
    |> List.map (fun n -> (n, digitFactorialSum n))
    |> List.filter (fun n -> fst n = snd n)
    |> List.sumBy fst
@@ -0,0 +1,26 @@
 module _35
 open common
 let circularPrime =
    let rotations (s:string) =
        let len = s.Length
        seq {
            for n in 0..(len - 1) do
                yield s.Substring(len - n)
                      + s.Substring(0, len - n)
        } |> Seq.toList
    let oddOr2 i = i % 2 = 1 || i = 2
    let pa = 
        primeArray 1000000 
        |> Array.filter (numDigits >> (Array.forall oddOr2))
        |> Array.map (string)
    let isPrime = isPrimeFunByArray pa
    pa
    |> Array.map rotations
    |> Array.filter (List.forall isPrime)
    |> Array.map (Seq.nth 0)
    |> Array.length
@@ -0,0 +1,12 @@
 module _36
 let binary (n:int) =
    System.Convert.ToString(n,2)
 let palindromicBase10and2Sum =
    [1..1000000] 
    |> List.map (fun n -> (string n, binary n))
    |> List.filter (fst >> common.isPalindrome)
    |> List.filter (snd >> common.isPalindrome)
    |> List.map (fst >> int)
    |> List.sum
@@ -0,0 +1,26 @@
 module _37
 let truncations i =
    let s = string i
    let len = s.Length
    seq {
        for n in 0..(len - 1) do
            yield s.Substring(0, len - n) 
            if (n > 0) then
                yield s.Substring(len - n)
    } |> Seq.distinct |> Seq.toList |> List.map (int)
 let truncatablePrimes =
    let oddOr2 i = i % 2 = 1 || i = 2
    let pa = 
        common.primeArray 1000000
        |> Array.filter (common.numDigits >> (Array.forall oddOr2))
    let isPrime n = Array.exists (fun p -> p = n) pa
    pa
    |> Array.filter ((<) 10)
    |> Array.map truncations
    |> Array.filter (List.forall isPrime)
    |> Array.map (Seq.nth 0)
    |> Array.sum
@@ -0,0 +1,26 @@
 module _39
 let rightTriPerimeter =
    let pythagreonTriple m n =
        (m * m - n * n, 2 * m * n, m * m + n * n)
    let sumTriple (a,b,c) =
        a + b + c
    let parity a b =
        (a + b) % 2 = 1
    let multiples lim n  =
        seq { n .. n .. lim }
    common.coprimeArray 33
    |> Array.mapi (fun i cp ->
        cp 
        |> Seq.filter (parity i)
        |> Seq.map ((pythagreonTriple i)  >> sumTriple)
        |> Seq.collect (multiples 1000)
        )
    |> Seq.collect (fun l -> l)
    |> Seq.groupBy (fun n -> n)
    |> Seq.maxBy (fun g -> Seq.length (snd g))
@@ -0,0 +1,28 @@
 function IsPalendrome([string] $str)
 {
 	for ($i = 0; $i -lt $str.Length/2; $i++)
 	{
 		if ($str[$i] -ne $str[$str.Length - 1 - $i])
 		{
 			return $FALSE;
 		}
 	}
 	return $TRUE;
 }
 $greatest = [int]::minvalue
 for ($j = 999; $j -gt 99; $j--)
 {
 	for ($k = $j; $k -lt 1000; $k++)
 	{
 		$mul = $j * $k
 		if (IsPalendrome $mul)
 		{
 			if ($mul -gt $greatest)
 			{
 				$greatest = $mul
 				write-host "$j * $k = $mul"
 			}
 		}
 	}
 }
@@ -0,0 +1,8 @@
 module _40
 let positiveIntegerConcat = 
    common.allIntegers
    |> Seq.collect common.numDigits
    |> common.takeIndexes ([1;10;100;1000;10000;100000;1000000] 
    |> List.map (fun d -> d - 1))
    |> Seq.fold (*) 1
@@ -0,0 +1,15 @@
 module _41
 open common
 let panDigital = 
 //    let numListToBigint s =
 //        s 
 //        |> List.map string
 //        |> List.fold (+) ""
 //        |> bigint.Parse
    primeArray 7654321
    |> arrayToRevSeq
    |> Seq.filter isPanDigital
@@ -0,0 +1,20 @@
 module _42
 open System.IO
 let triangleWords =
    let words =
        File.ReadAllLines(@"42_words.txt")
        |> Seq.collect (fun l -> l.Split(','))
        |> Seq.map (fun w -> w.Substring(1, w.Length - 2))
    let triangleNumbers =
        common.allIntegers
        |> Seq.map common.triangleNumber
        |> Seq.takeWhile ((>) 2000I)
    words
    |> Seq.map (fun w -> (w, common.wordValue w |> (fun n -> bigint(n))))
    |> Seq.toArray
    |> Seq.filter (fun wv -> Seq.exists ((=) (snd wv)) triangleNumbers)
    |> Seq.length
@@ -0,0 +1,28 @@
 module _43
 open System
 open common
 let pandigitalDivisible =
    let comb (i : string) (j : string) =
        match i, j with
        | i,j when i.[1] = j.[0] && i.[2] = j.[1] -> Some(String.Concat((string i.[0]), j))
        | _ -> None
    let prMul =
        [17;13;11;7;5;3;2]
        |> List.map 
            (
                multiples
                >> Seq.map string
                >> Seq.skipWhile (String.length >> (>) 3)
                >> Seq.takeWhile (String.length >> (>) 4)
            )
 //    let lnth i l = List.nth l i
 //    let lnthDivs i n l = lnth i l >> (%) n >> (=) 0
 //    [0..9] |> Set.ofSeq |> permutations 
 //    |> Seq.filter (lnth 0 >> (<>) 0)
 //    |> Seq.filter (lnth 3 >> (%) 2 >> (=) 0)
 //    //|> Seq.filter (lnth 5 >> (%) 5 >> (=) 0)
 //    |> Seq.length
@@ -0,0 +1,18 @@
 module _45
 let triPentHex =
    let limit = 100000
    let opDict (op : int -> bigint) =
        [1..limit]
        |> Seq.map (fun n -> (op n, n))
        |> dict
    let p = opDict common.pentagonalNumber
    let h = opDict common.hexagonalNumber
    common.allIntegers 
    |> Seq.skip 284
    |> Seq.map (fun i -> (common.triangleNumber i, i))
    |> Seq.filter (fst >> (fun t -> p.ContainsKey(t) && h.ContainsKey(t)))
    |> Seq.map (fun t -> (snd t, p.Item(fst t), h.Item(fst t), fst t))
    |> Seq.take 2
@@ -0,0 +1,22 @@
 module _46
 let smallestOddCompositeNotSumOfPrimeTwiceSquare =
    let ceiling = 10000
    let composites =
        common.compositeArray ceiling
        |> Seq.filter (fun c -> c % 2 = 1)
        |> Set.ofSeq
    let twiceSquares =
        Seq.unfold (fun state -> Some(2 * state * state, state + 1)) 1
    let primes = common.primeArray ceiling
    let twiceSquareList = twiceSquares |> Seq.take ceiling
    let sumOfPrimceTwiceSquare =
        common.crossMap (+) primes twiceSquareList
        |> Seq.distinct
        |> Set.ofSeq
    Set.difference composites sumOfPrimceTwiceSquare
@@ -0,0 +1,17 @@
 module _47
 let consequtivePrimes =
    let max = 200000
    let count = 4
    let d = common.divisors max
    let p = common.primeArray ((int)(max/2)) |> Set.ofArray
    d
    |> Seq.mapi (fun i ds -> 
        let ds = i::ds |> Set.ofList
        let dp = Set.intersect ds p
        (i, Set.count dp))
    |> Seq.filter (snd >> (=) count)
    |> Seq.map fst
    |> Seq.windowed count
    |> Seq.find (fun ns -> ns.[count - 1] - ns.[0] = count - 1)
@@ -0,0 +1,10 @@
 module _48
 let series n =
    [1..n]
    |> List.map (fun d-> System.Numerics.BigInteger.Pow(bigint d, d))
    |> List.fold (+) 0I
 let seriesEnd =
    series 1000
    |> common.lastDigits 10
@@ -0,0 +1,34 @@
 module _49
 open common
 let rec insertions x = function
    | []             -> [[x]]
    | (y :: ys) as l -> (x::l)::(List.map (fun x -> y::x) (insertions x ys))
 let rec permutations = function
    | []      -> seq [[]]
    | x :: xs -> Seq.concat (Seq.map (insertions x) (permutations xs))
 let primeSequence =
    let primes =
        primeArray 10000 |> Seq.skipWhile ((>) 999) |> Array.ofSeq
    let isPrime = isPrimeFunByArray primes
    primes
    |> Seq.map (
            numDigits >> List.ofArray >> 
            permutations >>
            Seq.map (Array.ofList >> digitsNum) >>
            Seq.filter isPrime >>
            Seq.distinct >>
            Seq.sort >>
            Seq.toArray
        )
    |> Seq.distinct
    |> Seq.collect (List.ofSeq >> combinations 3)
    |> Seq.filter (fun a -> a.[2] - a.[1] = a.[1] - a.[0])
    |> Seq.map (List.rev >> List.map (numDigits >> Array.map (string) >> Array.fold (+) "") >> List.fold (+) "")
    //|> Seq.toArray
@@ -0,0 +1,21 @@
 [int64]$num = 20
 $i = $num
 $answer = 0
 while ($answer -eq 0)
 {
 	$answer = $i
 	for ($j=$num; $j -gt 1; $j--)
 	{
 		if ($i%$j -ne 0)
 		{
 			$answer = 0
 			break
 		}
 	}
 	if ($j -lt $num*.75)
 	{
 		write-host $i
 	}
 	$i += $num
 }
 $answer
@@ -0,0 +1,24 @@
 module _50
 let sumOfConsequitivePrimes =
    let ceiling = 1000000
    let primes = common.primeArray ceiling
    let isPrime = common.isPrimeFunByArray primes
    let primeSumUnderCeilingIndex =
        primes
        |> Seq.scan (fun state p -> p + state) 0
        |> Seq.findIndex (fun s -> s > ceiling)
        |> (+) -1
    let indiciesOfDecendingLength max =
        seq {
            for l in max .. -1 .. 0 do
                for o in 0 .. (max - l) do
                    yield (o, l)
        }
    indiciesOfDecendingLength primeSumUnderCeilingIndex
    |> Seq.map (fun (start,len) -> Array.sub primes start len |> Array.sum)
    |> Seq.find isPrime
@@ -0,0 +1,24 @@
 module _52
 open System
 let findSameDigits =
    // todo: optimize with combination of available digits
    let powerOfTenNums pow = 
        let b = Math.Pow(10.0, float pow) |> int
        seq {1..(b-1)} |> Seq.map ((+) b)
    let multiples num =
        seq {num*2..num..(num*6) }
    let numSet num =
        Set (common.numDigits num)
    let rec sd pow =
        powerOfTenNums pow
        |> Seq.filter ( fun n ->
            let nDigits = numSet n
            multiples n
            |> Seq.map (fun m -> numSet m)
            |> Seq.forall (fun mDigits -> nDigits = mDigits)
            )
        |> Seq.map (fun n -> (n, multiples n |> Seq.toArray))
    sd 5
@@ -0,0 +1,15 @@
 module _53
 let combinationGt1M =
    let f =
        [|0..100|] |> Array.map (fun n -> bigint n) |> Array.map common.factorialI
    let combinations (n, r) =
        f.[n] /  ( f.[r] * f.[n - r] )
    [100..-1..0]
    |> Seq.sumBy (fun n ->
        seq { 1 .. n }
        |> Seq.filter (fun r -> combinations (n,r) > 1000000I )
        |> Seq.length
    )
@@ -0,0 +1,200 @@
 module _54
 type Suit =
    Diamonds | Clubs | Hearts | Spades
 type Card =
    Jack of Suit | Queen of Suit | King of Suit | Ace of Suit | Value of int * Suit
 type Rank =
    | HighCard of Card
    | OnePair of List<Card>
    | TwoPair of List<Card>
    | ThreeKind of List<Card>
    | Straight of List<Card>
    | Flush of List<Card>
    | FullHouse of List<Card>
    | StraightFlush of List<Card>
    | RoyalFlush of List<Card>
 let pokerWinner =
    let cardValue = function
        | Value(v,_) -> v
        | Jack(_) -> 11
        | Queen(_) -> 12
        | King(_) -> 13
        | Ace(_) -> 14
    let cardSuit = function Value(_,s) | Jack(s) | Queen(s) | King(s) | Ace(s) -> s
    let values cards =
        cards
        |> Seq.groupBy cardValue
    let isFlush cards =
        cards |> Seq.groupBy cardSuit |> Seq.length = 1
    let isStraight cards =
        cards |> Seq.map cardValue |> Seq.distinct |> Seq.toArray
        |> (fun vs -> Array.length vs = 5 && Array.max vs - Array.min vs = 4)
    let isStraightFlush cards =
        isStraight cards && isFlush cards
    let highCard cards =
        cards |> Seq.sortBy cardValue |> Seq.toList |> List.rev |> Seq.nth 0
    let isRoyalFlush cards =
        let hasAce cards =
            cards |> Seq.exists (function | Ace(_) -> true | _ -> false)
        isStraightFlush cards && hasAce cards
    let multiples cards =
        cards 
        |> Seq.groupBy cardValue |> Seq.map snd
        |> Seq.sortBy Seq.length |> Seq.toList |> List.rev
        //|> Seq.filter (Seq.length >> ((<) 1))
    let rankCards cards =
        let multiplesLength cards =
            multiples cards 
            |> List.map Seq.length
            |> List.filter ((<) 1)
        let flattenMultiples =
            multiples cards
            |> Seq.collect (fun c -> c)
            |> Seq.toList
        match cards, multiplesLength cards with
        | c,_ when isRoyalFlush c -> RoyalFlush cards
        | c,_ when isStraightFlush c -> StraightFlush cards
        | _,[3;2] -> FullHouse cards
        | c,_ when isFlush c -> Flush cards
        | c,_ when isStraight c -> Straight cards
        | _,[3] -> ThreeKind flattenMultiples 
        | _,[2;2] -> TwoPair flattenMultiples
        | _,[2] -> OnePair flattenMultiples
        | _,_ -> HighCard (highCard cards)
    let rankTwoHands (c1,c2) =
        (rankCards c1, rankCards c2)
    let compareRanks (r1, r2) =
        let highCardValue = highCard >> cardValue
        let compareHighCard (c1,c2) =
            compare (highCardValue c1) (highCardValue c2)
        let compareMultiples (c1,c2) =
            let rec cm (m1, m2) =
                match m1, m2 with
                | [],[] -> 0
                | h1::_, h2::_ when Seq.length h1 <> Seq.length h2 -> compare (Seq.length h1) (Seq.length h2)
                | h1::_, h2::_ when compareHighCard (h1, h2) <> 0 -> compareHighCard (h1, h2)
                | _::t1, _::t2 -> cm(t1,t2)
                | _,_ -> failwith "huh"
            cm (multiples c1, multiples c2)
        let r1win, r2win = compare 1 0, compare 0 1
        match r1, r2 with
        | RoyalFlush(_), RoyalFlush(_) -> 0
        | StraightFlush(c1), StraightFlush(c2)
        | Flush(c1), Flush(c2)
        | Straight(c1), Straight(c2)
            -> compareHighCard (c1,c2)
        | FullHouse(c1), FullHouse(c2)
        | TwoPair(c1), TwoPair(c2)
        | OnePair(c1), OnePair(c2)
        | ThreeKind(c1), ThreeKind(c2)
            -> compareMultiples (c1,c2)
        | RoyalFlush(_), _ -> r1win
        | _, RoyalFlush(_) -> r2win
        | StraightFlush(_), _ -> r1win
        | _, StraightFlush(_) -> r2win
        | FullHouse(_), _ -> r1win
        | _, FullHouse(_) -> r2win
        | Flush(_), _ -> r1win
        | _, Flush(_) -> r2win
        | Straight(_), _ -> r1win
        | _, Straight(_) -> r2win
        | ThreeKind(_), _ -> r1win
        | _, ThreeKind(_) -> r2win
        | TwoPair(_), _ -> r1win
        | _, TwoPair(_) -> r2win
        | OnePair(_), _ -> r1win
        | _, OnePair(_) -> r2win
        | HighCard(c1), HighCard(c2) -> compare (cardValue c1) (cardValue c2)
    let parseCard s =
        let parseSuit = function
            | 'H' -> Hearts
            | 'D' -> Diamonds
            | 'C' -> Clubs
            | 'S' -> Spades
            | _ -> failwith "unknown suit"
        if String.length s <> 2 then failwith "wrong length"
        let charVal (c:char) = int c - 48
        let validVal v = v >= 2 && v <= 9
        let suit = parseSuit s.[1]
        match s.[0] with
        | v when (charVal >> validVal) v -> Value(charVal v, suit)
        | 'T' -> Value(10, suit)
        | 'J' -> Jack(suit)
        | 'Q' -> Queen(suit)
        | 'K' -> King(suit)
        | 'A' -> Ace(suit)
        | _ -> failwith ("unknownCard " + s)
    let parseCards (s:string) =
        s.Split(' ') |> Array.map parseCard
    let parseTwoHands s =
        let c = parseCards s
        (c.[..4] |> List.ofArray, c.[5..] |> List.ofArray)
 //    ["5H 5C 6S 7S KD 2C 3S 8S 8D TD";
 //     "5D 8C 9S JS AC 2C 5C 7D 8S QH";
 //     "2D 9C AS AH AC 3D 6D 7D TD QD";
 //     "4D 6S 9H QH QC 3D 6D 7H QD QS";
 //     "2H 2D 4C 4D 4S 3C 3D 3S 9S 9D"
 //    ]
    System.IO.File.ReadAllLines(@"54_poker.txt")
    |> Seq.map (parseTwoHands >> rankTwoHands >> compareRanks) |> Array.ofSeq
    |> Seq.filter ((<) 0)
    |> Seq.length
 //
 //    ["KD QD JD TD AD"; // royal flush
 //     "2D 6D 3D 4D 5D"; // straight flush
 //     "8D TD QD JD 7D"; // flush
 //     "3D 3S 3H 5D 5H"; // full house
 //     "KS QD JD TD AD"; // straight
 //     "3D 3S 3H 5D 6H"; // 3 kind
 //     "3D 3S 4H 5D 5H"; // 2 pair
 //     "3D 3S 4H 5D 6H"; // 1 pair
 //     "KD 3S 4H 5D 6H"; // 1 pair
 //    ]
 //    |> Seq.map (parseCards >> Array.toList >> rankCards)
 //    |> common.crossSelfMapList
 //    |> Seq.map (
 //        fun (r1, r2) ->
 //            let cr = compareRanks (r1, r2)
 //            sprintf "%A %i %A" r1 cr r2
 //        )
 //    |> Array.ofSeq
 //    |> Seq.map (
 //        fun c -> 
 //            let pc = parseCards c
 //            let rf = isRoyalFlush pc
 //            let s = isStraight pc
 //            let f = isFlush pc
 //            let sf = isStraightFlush pc
 //            let hc = sprintf "%A" (highCard pc)
 //            let rank = pc |> List.ofArray |> rankCards 
 //            //sprintf "%s RF:%b SF:%b F:%b S:%b HC:%s" c rf sf f s hc
 //            rank
 //        )
 //    |> Seq.toArray
@@ -0,0 +1,23 @@
 module _55
 open System.Numerics
 let lynchrels =
    let isLynchrel n =
        let revInt (n:bigint) =
            n
            |> (string)
            |> common.revString
            |> (fun s -> BigInteger.TryParse(s) |> snd)
        let rec isLynchrelRec (n:bigint,d) =
            match (n + (revInt n)), d with
            | _,0 -> true
            | n,_ when ((string) >> common.isPalindrome) n -> false
            | n,d -> isLynchrelRec (n, d-1)
        isLynchrelRec (n,50)
    [|1I..10000I|]
    |> Array.filter isLynchrel
    |> Array.length
@@ -0,0 +1,15 @@
 module _56
 open System.Numerics
 let exponentialDigitSum =
    let powDigitSum (a, b) =
        BigInteger.Pow(a,b)
        |> common.numDigits
        |> Seq.sum
    let third (_, _, c) = c
    common.crossMap (fun a b -> (a,b)) [2I..100I] [2..10]
    |> Seq.map (fun (a,b) -> (a,b,powDigitSum (a,b)))
    |> Seq.maxBy third
@@ -0,0 +1,23 @@
 module _57
 open common
 open Fraction
 open System
 open System.Numerics
 let sqrtTwoDigits =
    let sqrtTwoConvergent d =
        let rec sqrtTwo = function
            | 1 -> (2I,1I)
            | d -> addI (2I,1I) (reciprocalI(sqrtTwo (d - 1)))
        addI (1I,1I) (reciprocalI(sqrtTwo d))
    let digitCount n =
        let d = BigInteger.Log10(n)
        Math.Floor d + 1.0 |> int
    [1..1000]
    |> List.map sqrtTwoConvergent
    |> List.map (fun (n,d) -> (digitCount n, digitCount d))
    |> List.mapi (fun i (n,d) -> i + 1, n > d)
    |> List.filter (snd >> ((=) true))
@@ -0,0 +1,33 @@
 module _58
 open common
 let primeDiagonals =
    let isPrime n =
        let limit = System.Math.Ceiling(sqrt (float n)) |> int
        let rec check i =
            i > n/limit || (n % i <> 0 && check (i + 1))
        check 2
 //    let isPrime = isPrimeW [2I;3I]
    let sideLengthPrimeCount l = 1 + (l - 1) * 2
    let sideLengths =
        (2,2) |> Seq.unfold(
            fun (l, r) ->
                match r with
                | 0 -> Some(l, (l + 2, 3))
                | _ -> Some(l, (l, r - 1))
            )
    sideLengths
    |> Seq.scan (fun (c,_) l -> (c + (l), l + 1)) (3,3) 
    |> Seq.scan (fun (p,_) (d,l) -> 
            let r = isPrime (d)
            match r with
            | true -> (p + 1, l)
            | false -> (p, l)
        ) (0,0) |> Seq.skip 1
    |> Seq.skipWhile (fun (p,l) -> (float p)/(float (sideLengthPrimeCount l)) >= 0.1)
    |> Seq.nth 1
@@ -0,0 +1,56 @@
 module _59
 open System
 open System.IO
 let cypher = 
    let encrypted = 
        File.ReadAllLines(@"59_cipher1.txt") 
        |> Array.collect (fun line -> line.Split(',') |> Array.map uint16)
    let decrypt f message key =
        let repeatedKey = seq { while true do yield! key }
        Seq.map2 f message repeatedKey
    let decryptXor = decrypt (^^^)
    let decriptMessage = decryptXor encrypted
    let de = encrypted |> Seq.distinct |> Seq.toArray
    let filteri f s =
        seq {
            for i in 0..((s |> Seq.length) - 1) do
                let si = Seq.nth i s
                if f i si then yield si
        }
    let validKeys encryptedSymbols = 
        let lowercase = [97us..122us] |> List.toArray
        let validSymbols = [32us..122us] |> List.toArray
        let isValidChar i =
            Array.exists ((=) i) validSymbols
        [0..2]
        |> List.map (fun offset ->
            lowercase
            |> Seq.filter (fun lc ->
                encryptedSymbols 
                |> filteri (fun i e -> i % 3 = offset)
                |> Seq.forall (fun e -> (e ^^^ lc) |> isValidChar))
            )
    let messageToText message =
        message
        |> Seq.map (char >> string)
        |> Seq.fold (fun acc e -> acc + e) ""
    validKeys encrypted
    |> common.slottedPermutations
    |> Seq.map (fun p -> (p, (decriptMessage >> messageToText) p))
    |> Seq.find (fun p -> (snd p).Contains(" the "))
    |> (fst >> decriptMessage)
    |> Seq.map (int)
    |> Seq.sum
@@ -0,0 +1 @@
 79,59,12,2,79,35,8,28,20,2,3,68,8,9,68,45,0,12,9,67,68,4,7,5,23,27,1,21,79,85,78,79,85,71,38,10,71,27,12,2,79,6,2,8,13,9,1,13,9,8,68,19,7,1,71,56,11,21,11,68,6,3,22,2,14,0,30,79,1,31,6,23,19,10,0,73,79,44,2,79,19,6,28,68,16,6,16,15,79,35,8,11,72,71,14,10,3,79,12,2,79,19,6,28,68,32,0,0,73,79,86,71,39,1,71,24,5,20,79,13,9,79,16,15,10,68,5,10,3,14,1,10,14,1,3,71,24,13,19,7,68,32,0,0,73,79,87,71,39,1,71,12,22,2,14,16,2,11,68,2,25,1,21,22,16,15,6,10,0,79,16,15,10,22,2,79,13,20,65,68,41,0,16,15,6,10,0,79,1,31,6,23,19,28,68,19,7,5,19,79,12,2,79,0,14,11,10,64,27,68,10,14,15,2,65,68,83,79,40,14,9,1,71,6,16,20,10,8,1,79,19,6,28,68,14,1,68,15,6,9,75,79,5,9,11,68,19,7,13,20,79,8,14,9,1,71,8,13,17,10,23,71,3,13,0,7,16,71,27,11,71,10,18,2,29,29,8,1,1,73,79,81,71,59,12,2,79,8,14,8,12,19,79,23,15,6,10,2,28,68,19,7,22,8,26,3,15,79,16,15,10,68,3,14,22,12,1,1,20,28,72,71,14,10,3,79,16,15,10,68,3,14,22,12,1,1,20,28,68,4,14,10,71,1,1,17,10,22,71,10,28,19,6,10,0,26,13,20,7,68,14,27,74,71,89,68,32,0,0,71,28,1,9,27,68,45,0,12,9,79,16,15,10,68,37,14,20,19,6,23,19,79,83,71,27,11,71,27,1,11,3,68,2,25,1,21,22,11,9,10,68,6,13,11,18,27,68,19,7,1,71,3,13,0,7,16,71,28,11,71,27,12,6,27,68,2,25,1,21,22,11,9,10,68,10,6,3,15,27,68,5,10,8,14,10,18,2,79,6,2,12,5,18,28,1,71,0,2,71,7,13,20,79,16,2,28,16,14,2,11,9,22,74,71,87,68,45,0,12,9,79,12,14,2,23,2,3,2,71,24,5,20,79,10,8,27,68,19,7,1,71,3,13,0,7,16,92,79,12,2,79,19,6,28,68,8,1,8,30,79,5,71,24,13,19,1,1,20,28,68,19,0,68,19,7,1,71,3,13,0,7,16,73,79,93,71,59,12,2,79,11,9,10,68,16,7,11,71,6,23,71,27,12,2,79,16,21,26,1,71,3,13,0,7,16,75,79,19,15,0,68,0,6,18,2,28,68,11,6,3,15,27,68,19,0,68,2,25,1,21,22,11,9,10,72,71,24,5,20,79,3,8,6,10,0,79,16,8,79,7,8,2,1,71,6,10,19,0,68,19,7,1,71,24,11,21,3,0,73,79,85,87,79,38,18,27,68,6,3,16,15,0,17,0,7,68,19,7,1,71,24,11,21,3,0,71,24,5,20,79,9,6,11,1,71,27,12,21,0,17,0,7,68,15,6,9,75,79,16,15,10,68,16,0,22,11,11,68,3,6,0,9,72,16,71,29,1,4,0,3,9,6,30,2,79,12,14,2,68,16,7,1,9,79,12,2,79,7,6,2,1,73,79,85,86,79,33,17,10,10,71,6,10,71,7,13,20,79,11,16,1,68,11,14,10,3,79,5,9,11,68,6,2,11,9,8,68,15,6,23,71,0,19,9,79,20,2,0,20,11,10,72,71,7,1,71,24,5,20,79,10,8,27,68,6,12,7,2,31,16,2,11,74,71,94,86,71,45,17,19,79,16,8,79,5,11,3,68,16,7,11,71,13,1,11,6,1,17,10,0,71,7,13,10,79,5,9,11,68,6,12,7,2,31,16,2,11,68,15,6,9,75,79,12,2,79,3,6,25,1,71,27,12,2,79,22,14,8,12,19,79,16,8,79,6,2,12,11,10,10,68,4,7,13,11,11,22,2,1,68,8,9,68,32,0,0,73,79,85,84,79,48,15,10,29,71,14,22,2,79,22,2,13,11,21,1,69,71,59,12,14,28,68,14,28,68,9,0,16,71,14,68,23,7,29,20,6,7,6,3,68,5,6,22,19,7,68,21,10,23,18,3,16,14,1,3,71,9,22,8,2,68,15,26,9,6,1,68,23,14,23,20,6,11,9,79,11,21,79,20,11,14,10,75,79,16,15,6,23,71,29,1,5,6,22,19,7,68,4,0,9,2,28,68,1,29,11,10,79,35,8,11,74,86,91,68,52,0,68,19,7,1,71,56,11,21,11,68,5,10,7,6,2,1,71,7,17,10,14,10,71,14,10,3,79,8,14,25,1,3,79,12,2,29,1,71,0,10,71,10,5,21,27,12,71,14,9,8,1,3,71,26,23,73,79,44,2,79,19,6,28,68,1,26,8,11,79,11,1,79,17,9,9,5,14,3,13,9,8,68,11,0,18,2,79,5,9,11,68,1,14,13,19,7,2,18,3,10,2,28,23,73,79,37,9,11,68,16,10,68,15,14,18,2,79,23,2,10,10,71,7,13,20,79,3,11,0,22,30,67,68,19,7,1,71,8,8,8,29,29,71,0,2,71,27,12,2,79,11,9,3,29,71,60,11,9,79,11,1,79,16,15,10,68,33,14,16,15,10,22,73
@@ -0,0 +1,23 @@
 module _63
 open System
 open common
 let powerDigits =
    let powDigitCount e n =
        let d = Math.Log10(float n) * float e
        Math.Floor d + 1.0 |> int
    let findNthPowerDigits e =
        let pdc = powDigitCount e
        allIntegers
        |> Seq.map (fun i -> (i, pdc i))
        |> Seq.skipWhile (fun (_,n) -> n < e)
        |> Seq.takeWhile (fun (_,n) -> n <= e)
        |> Seq.toArray
    allIntegers |> Seq.skip 1
    |> Seq.map findNthPowerDigits
    |> Seq.takeWhile (Seq.isEmpty >> not)
    |> Seq.collect (fun p -> p)
    |> Seq.length
@@ -0,0 +1,26 @@
 module _69
 open common
 let relativePrimeFunc =
    let primeDivisorArrayByMax max =
        let isPrime = isPrimeFunByMax (int (System.Math.Ceiling(sqrt (float max))))
        divisorsInclSelf max |> Array.map (List.filter isPrime)
    let totientArrayByMax max =
        let pd = primeDivisorArrayByMax max
        let productFormula n primes =
            let pFunc prime = 1.0 - 1.0/(float prime)
            primes 
            |> List.fold (fun p prime -> p * (pFunc prime)) (float n)
        pd
        |> Array.mapi productFormula
    let indexArray = Array.mapi (fun i e -> (i,e))
    totientArrayByMax 1000000
    |> indexArray
    |> Seq.skip 1
    |> Seq.map (fun (i,t) -> (i, (float i)/t))
    |> Seq.maxBy snd
@@ -0,0 +1,20 @@
 $arr = New-Object bool[] 500000
 $arr[0] = $arr[1] = $TRUE
 $count = 0
 for ($i=2; $i -lt $arr.Length; $i++)
 {
 	if ($arr[$i] -eq $TRUE)
 	{
 		continue
 	}
 	for ($j=$i*2; $j -lt $arr.Length; $j += $i)
 	{
 		$arr[$j] = $TRUE
 	}
 	$count ++
 	write-host "$i is $count"
 	if ($count -eq 10001)
 	{
 		break
 	}
 }
@@ -0,0 +1,33 @@
 module _79
 open System.IO
 let findPasscode =
    let logins = 
        File.ReadAllLines(@"79_keylog.txt") 
    let preceeds = 
        logins 
        |> Seq.collect (fun login -> seq { yield (login.[0], login.[1]); yield (login.[1], login.[2]) })
        |> Seq.distinct
    let collectTuple (a,b) =
        seq { yield a; yield b }
    // topographical sort kinda
    let rec orderGraph g =
        seq {
            if Seq.length g = 1 then 
                yield (collectTuple (Seq.nth 0 g)) |> Seq.toList
            else
                let allNodes = g |> Seq.collect collectTuple |> Seq.distinct |> Set.ofSeq
                let sndNodes = g |> Seq.map snd |> Seq.distinct |> Set.ofSeq
                let noPreceedingNodes = allNodes - sndNodes
                for n in noPreceedingNodes do
                    let gMinusN = g |> Seq.filter (fun gi -> not(fst gi = n))
                    for s in orderGraph gMinusN do
                        yield n :: s
        }
    preceeds
    |> orderGraph
    |> Seq.toArray
@@ -0,0 +1,50 @@
 319
 680
 180
 690
 129
 620
 762
 689
 762
 318
 368
 710
 720
 710
 629
 168
 160
 689
 716
 731
 736
 729
 316
 729
 729
 710
 769
 290
 719
 680
 318
 389
 162
 289
 162
 718
 729
 319
 790
 680
 890
 362
 319
 760
 316
 729
 380
 319
 728
 716
@@ -0,0 +1,24 @@
 $num = gc 8.txt
 function product() {
 	BEGIN {
 		[int]$prod = 1
 	}
 	PROCESS {
 		#write-host 'prod ' $prod
 		$prod *= [int][string]$_
 		#write-host $_ $prod
 	}
 	END {
 		$prod
 	}	
 }
 $max = 0
 for ($i=0; $i -lt $num.length - 5; $i++) {
 	$curr = $num[$($i)..$($i+4)] | product
 	if ($curr -gt $max) {
 		$max = $curr
 	}
 }
 $max
@@ -0,0 +1 @@
 7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450
@@ -0,0 +1,71 @@
 module _81
 open common
 open System
 open System.IO
 open System.Collections.Generic
 let testMatrix =
        [|"131,673,234,103,18";
        "201,96,342,965,150";
        "630,803,746,422,111";
        "537,699,497,121,956";
        "805,732,524,37,331"|]
 type Direction =
    | Down | Right | Init
 let coordMod f coord = function
    | Down -> (f (fst coord), snd coord)
    | Right -> (fst coord, f (snd coord))
    | Init -> failwith "Ha"
 let coordDeref = coordMod ((-) 1)
 let coordRef = coordMod ((+) 1)
 let shortestDistance =
    let matrix = 
        //File.ReadAllLines(@"81_matrix.txt")
        array2D (testMatrix |> Array.map strSplitInt)
    let mLen1, mLen2 = Array2D.length1 matrix, Array2D.length2 matrix
    let dist =
        Array2D.create mLen1 mLen2 Int32.MaxValue
 //    let rec listInsert f v l =
 //        match l with
 //        | x::xs when f x -> v::x::xs
 //        | x::xs -> x::listInsert f v xs
 //        | [] -> [v]
    let rec f frontier = 
        let expand coord =
            seq {
                let d, r = coordRef coord Down, coordRef coord Right
                let inMatrix coord =
                    fst coord < mLen1 && snd coord < mLen2
                let incl c = inMatrix c && dist.[fst c, snd c] = Int32.MaxValue 
                if incl d then yield d 
                if incl r then yield r }
        match frontier with
        | [] -> ()
        | (coord,d)::xs -> 
            dist.[fst coord, snd coord] <- d
            xs 
            |> List.filter (fun ((c),_) -> c <> coord)
            |> List.append
                (expand coord
                |> Seq.map (
                    fun f ->
                        let fd = matrix.[fst f, snd f] + d
                        f,fd)
                |> List.ofSeq)
            |> List.sortWith (fun (_,d1) (_,d2) -> d1 - d2)
            |> f
    f [(0,0),matrix.[0,0]]
    dist.[mLen1 - 1, mLen2 - 1]
@@ -0,0 +1,80 @@
 4445,2697,5115,718,2209,2212,654,4348,3079,6821,7668,3276,8874,4190,3785,2752,9473,7817,9137,496,7338,3434,7152,4355,4552,7917,7827,2460,2350,691,3514,5880,3145,7633,7199,3783,5066,7487,3285,1084,8985,760,872,8609,8051,1134,9536,5750,9716,9371,7619,5617,275,9721,2997,2698,1887,8825,6372,3014,2113,7122,7050,6775,5948,2758,1219,3539,348,7989,2735,9862,1263,8089,6401,9462,3168,2758,3748,5870
 1096,20,1318,7586,5167,2642,1443,5741,7621,7030,5526,4244,2348,4641,9827,2448,6918,5883,3737,300,7116,6531,567,5997,3971,6623,820,6148,3287,1874,7981,8424,7672,7575,6797,6717,1078,5008,4051,8795,5820,346,1851,6463,2117,6058,3407,8211,117,4822,1317,4377,4434,5925,8341,4800,1175,4173,690,8978,7470,1295,3799,8724,3509,9849,618,3320,7068,9633,2384,7175,544,6583,1908,9983,481,4187,9353,9377
 9607,7385,521,6084,1364,8983,7623,1585,6935,8551,2574,8267,4781,3834,2764,2084,2669,4656,9343,7709,2203,9328,8004,6192,5856,3555,2260,5118,6504,1839,9227,1259,9451,1388,7909,5733,6968,8519,9973,1663,5315,7571,3035,4325,4283,2304,6438,3815,9213,9806,9536,196,5542,6907,2475,1159,5820,9075,9470,2179,9248,1828,4592,9167,3713,4640,47,3637,309,7344,6955,346,378,9044,8635,7466,5036,9515,6385,9230
 7206,3114,7760,1094,6150,5182,7358,7387,4497,955,101,1478,7777,6966,7010,8417,6453,4955,3496,107,449,8271,131,2948,6185,784,5937,8001,6104,8282,4165,3642,710,2390,575,715,3089,6964,4217,192,5949,7006,715,3328,1152,66,8044,4319,1735,146,4818,5456,6451,4113,1063,4781,6799,602,1504,6245,6550,1417,1343,2363,3785,5448,4545,9371,5420,5068,4613,4882,4241,5043,7873,8042,8434,3939,9256,2187
 3620,8024,577,9997,7377,7682,1314,1158,6282,6310,1896,2509,5436,1732,9480,706,496,101,6232,7375,2207,2306,110,6772,3433,2878,8140,5933,8688,1399,2210,7332,6172,6403,7333,4044,2291,1790,2446,7390,8698,5723,3678,7104,1825,2040,140,3982,4905,4160,2200,5041,2512,1488,2268,1175,7588,8321,8078,7312,977,5257,8465,5068,3453,3096,1651,7906,253,9250,6021,8791,8109,6651,3412,345,4778,5152,4883,7505
 1074,5438,9008,2679,5397,5429,2652,3403,770,9188,4248,2493,4361,8327,9587,707,9525,5913,93,1899,328,2876,3604,673,8576,6908,7659,2544,3359,3883,5273,6587,3065,1749,3223,604,9925,6941,2823,8767,7039,3290,3214,1787,7904,3421,7137,9560,8451,2669,9219,6332,1576,5477,6755,8348,4164,4307,2984,4012,6629,1044,2874,6541,4942,903,1404,9125,5160,8836,4345,2581,460,8438,1538,5507,668,3352,2678,6942
 4295,1176,5596,1521,3061,9868,7037,7129,8933,6659,5947,5063,3653,9447,9245,2679,767,714,116,8558,163,3927,8779,158,5093,2447,5782,3967,1716,931,7772,8164,1117,9244,5783,7776,3846,8862,6014,2330,6947,1777,3112,6008,3491,1906,5952,314,4602,8994,5919,9214,3995,5026,7688,6809,5003,3128,2509,7477,110,8971,3982,8539,2980,4689,6343,5411,2992,5270,5247,9260,2269,7474,1042,7162,5206,1232,4556,4757
 510,3556,5377,1406,5721,4946,2635,7847,4251,8293,8281,6351,4912,287,2870,3380,3948,5322,3840,4738,9563,1906,6298,3234,8959,1562,6297,8835,7861,239,6618,1322,2553,2213,5053,5446,4402,6500,5182,8585,6900,5756,9661,903,5186,7687,5998,7997,8081,8955,4835,6069,2621,1581,732,9564,1082,1853,5442,1342,520,1737,3703,5321,4793,2776,1508,1647,9101,2499,6891,4336,7012,3329,3212,1442,9993,3988,4930,7706
 9444,3401,5891,9716,1228,7107,109,3563,2700,6161,5039,4992,2242,8541,7372,2067,1294,3058,1306,320,8881,5756,9326,411,8650,8824,5495,8282,8397,2000,1228,7817,2099,6473,3571,5994,4447,1299,5991,543,7874,2297,1651,101,2093,3463,9189,6872,6118,872,1008,1779,2805,9084,4048,2123,5877,55,3075,1737,9459,4535,6453,3644,108,5982,4437,5213,1340,6967,9943,5815,669,8074,1838,6979,9132,9315,715,5048
 3327,4030,7177,6336,9933,5296,2621,4785,2755,4832,2512,2118,2244,4407,2170,499,7532,9742,5051,7687,970,6924,3527,4694,5145,1306,2165,5940,2425,8910,3513,1909,6983,346,6377,4304,9330,7203,6605,3709,3346,970,369,9737,5811,4427,9939,3693,8436,5566,1977,3728,2399,3985,8303,2492,5366,9802,9193,7296,1033,5060,9144,2766,1151,7629,5169,5995,58,7619,7565,4208,1713,6279,3209,4908,9224,7409,1325,8540
 6882,1265,1775,3648,4690,959,5837,4520,5394,1378,9485,1360,4018,578,9174,2932,9890,3696,116,1723,1178,9355,7063,1594,1918,8574,7594,7942,1547,6166,7888,354,6932,4651,1010,7759,6905,661,7689,6092,9292,3845,9605,8443,443,8275,5163,7720,7265,6356,7779,1798,1754,5225,6661,1180,8024,5666,88,9153,1840,3508,1193,4445,2648,3538,6243,6375,8107,5902,5423,2520,1122,5015,6113,8859,9370,966,8673,2442
 7338,3423,4723,6533,848,8041,7921,8277,4094,5368,7252,8852,9166,2250,2801,6125,8093,5738,4038,9808,7359,9494,601,9116,4946,2702,5573,2921,9862,1462,1269,2410,4171,2709,7508,6241,7522,615,2407,8200,4189,5492,5649,7353,2590,5203,4274,710,7329,9063,956,8371,3722,4253,4785,1194,4828,4717,4548,940,983,2575,4511,2938,1827,2027,2700,1236,841,5760,1680,6260,2373,3851,1841,4968,1172,5179,7175,3509
 4420,1327,3560,2376,6260,2988,9537,4064,4829,8872,9598,3228,1792,7118,9962,9336,4368,9189,6857,1829,9863,6287,7303,7769,2707,8257,2391,2009,3975,4993,3068,9835,3427,341,8412,2134,4034,8511,6421,3041,9012,2983,7289,100,1355,7904,9186,6920,5856,2008,6545,8331,3655,5011,839,8041,9255,6524,3862,8788,62,7455,3513,5003,8413,3918,2076,7960,6108,3638,6999,3436,1441,4858,4181,1866,8731,7745,3744,1000
 356,8296,8325,1058,1277,4743,3850,2388,6079,6462,2815,5620,8495,5378,75,4324,3441,9870,1113,165,1544,1179,2834,562,6176,2313,6836,8839,2986,9454,5199,6888,1927,5866,8760,320,1792,8296,7898,6121,7241,5886,5814,2815,8336,1576,4314,3109,2572,6011,2086,9061,9403,3947,5487,9731,7281,3159,1819,1334,3181,5844,5114,9898,4634,2531,4412,6430,4262,8482,4546,4555,6804,2607,9421,686,8649,8860,7794,6672
 9870,152,1558,4963,8750,4754,6521,6256,8818,5208,5691,9659,8377,9725,5050,5343,2539,6101,1844,9700,7750,8114,5357,3001,8830,4438,199,9545,8496,43,2078,327,9397,106,6090,8181,8646,6414,7499,5450,4850,6273,5014,4131,7639,3913,6571,8534,9703,4391,7618,445,1320,5,1894,6771,7383,9191,4708,9706,6939,7937,8726,9382,5216,3685,2247,9029,8154,1738,9984,2626,9438,4167,6351,5060,29,1218,1239,4785
 192,5213,8297,8974,4032,6966,5717,1179,6523,4679,9513,1481,3041,5355,9303,9154,1389,8702,6589,7818,6336,3539,5538,3094,6646,6702,6266,2759,4608,4452,617,9406,8064,6379,444,5602,4950,1810,8391,1536,316,8714,1178,5182,5863,5110,5372,4954,1978,2971,5680,4863,2255,4630,5723,2168,538,1692,1319,7540,440,6430,6266,7712,7385,5702,620,641,3136,7350,1478,3155,2820,9109,6261,1122,4470,14,8493,2095
 1046,4301,6082,474,4974,7822,2102,5161,5172,6946,8074,9716,6586,9962,9749,5015,2217,995,5388,4402,7652,6399,6539,1349,8101,3677,1328,9612,7922,2879,231,5887,2655,508,4357,4964,3554,5930,6236,7384,4614,280,3093,9600,2110,7863,2631,6626,6620,68,1311,7198,7561,1768,5139,1431,221,230,2940,968,5283,6517,2146,1646,869,9402,7068,8645,7058,1765,9690,4152,2926,9504,2939,7504,6074,2944,6470,7859
 4659,736,4951,9344,1927,6271,8837,8711,3241,6579,7660,5499,5616,3743,5801,4682,9748,8796,779,1833,4549,8138,4026,775,4170,2432,4174,3741,7540,8017,2833,4027,396,811,2871,1150,9809,2719,9199,8504,1224,540,2051,3519,7982,7367,2761,308,3358,6505,2050,4836,5090,7864,805,2566,2409,6876,3361,8622,5572,5895,3280,441,7893,8105,1634,2929,274,3926,7786,6123,8233,9921,2674,5340,1445,203,4585,3837
 5759,338,7444,7968,7742,3755,1591,4839,1705,650,7061,2461,9230,9391,9373,2413,1213,431,7801,4994,2380,2703,6161,6878,8331,2538,6093,1275,5065,5062,2839,582,1014,8109,3525,1544,1569,8622,7944,2905,6120,1564,1839,5570,7579,1318,2677,5257,4418,5601,7935,7656,5192,1864,5886,6083,5580,6202,8869,1636,7907,4759,9082,5854,3185,7631,6854,5872,5632,5280,1431,2077,9717,7431,4256,8261,9680,4487,4752,4286
 1571,1428,8599,1230,7772,4221,8523,9049,4042,8726,7567,6736,9033,2104,4879,4967,6334,6716,3994,1269,8995,6539,3610,7667,6560,6065,874,848,4597,1711,7161,4811,6734,5723,6356,6026,9183,2586,5636,1092,7779,7923,8747,6887,7505,9909,1792,3233,4526,3176,1508,8043,720,5212,6046,4988,709,5277,8256,3642,1391,5803,1468,2145,3970,6301,7767,2359,8487,9771,8785,7520,856,1605,8972,2402,2386,991,1383,5963
 1822,4824,5957,6511,9868,4113,301,9353,6228,2881,2966,6956,9124,9574,9233,1601,7340,973,9396,540,4747,8590,9535,3650,7333,7583,4806,3593,2738,8157,5215,8472,2284,9473,3906,6982,5505,6053,7936,6074,7179,6688,1564,1103,6860,5839,2022,8490,910,7551,7805,881,7024,1855,9448,4790,1274,3672,2810,774,7623,4223,4850,6071,9975,4935,1915,9771,6690,3846,517,463,7624,4511,614,6394,3661,7409,1395,8127
 8738,3850,9555,3695,4383,2378,87,6256,6740,7682,9546,4255,6105,2000,1851,4073,8957,9022,6547,5189,2487,303,9602,7833,1628,4163,6678,3144,8589,7096,8913,5823,4890,7679,1212,9294,5884,2972,3012,3359,7794,7428,1579,4350,7246,4301,7779,7790,3294,9547,4367,3549,1958,8237,6758,3497,3250,3456,6318,1663,708,7714,6143,6890,3428,6853,9334,7992,591,6449,9786,1412,8500,722,5468,1371,108,3939,4199,2535
 7047,4323,1934,5163,4166,461,3544,2767,6554,203,6098,2265,9078,2075,4644,6641,8412,9183,487,101,7566,5622,1975,5726,2920,5374,7779,5631,3753,3725,2672,3621,4280,1162,5812,345,8173,9785,1525,955,5603,2215,2580,5261,2765,2990,5979,389,3907,2484,1232,5933,5871,3304,1138,1616,5114,9199,5072,7442,7245,6472,4760,6359,9053,7876,2564,9404,3043,9026,2261,3374,4460,7306,2326,966,828,3274,1712,3446
 3975,4565,8131,5800,4570,2306,8838,4392,9147,11,3911,7118,9645,4994,2028,6062,5431,2279,8752,2658,7836,994,7316,5336,7185,3289,1898,9689,2331,5737,3403,1124,2679,3241,7748,16,2724,5441,6640,9368,9081,5618,858,4969,17,2103,6035,8043,7475,2181,939,415,1617,8500,8253,2155,7843,7974,7859,1746,6336,3193,2617,8736,4079,6324,6645,8891,9396,5522,6103,1857,8979,3835,2475,1310,7422,610,8345,7615
 9248,5397,5686,2988,3446,4359,6634,9141,497,9176,6773,7448,1907,8454,916,1596,2241,1626,1384,2741,3649,5362,8791,7170,2903,2475,5325,6451,924,3328,522,90,4813,9737,9557,691,2388,1383,4021,1609,9206,4707,5200,7107,8104,4333,9860,5013,1224,6959,8527,1877,4545,7772,6268,621,4915,9349,5970,706,9583,3071,4127,780,8231,3017,9114,3836,7503,2383,1977,4870,8035,2379,9704,1037,3992,3642,1016,4303
 5093,138,4639,6609,1146,5565,95,7521,9077,2272,974,4388,2465,2650,722,4998,3567,3047,921,2736,7855,173,2065,4238,1048,5,6847,9548,8632,9194,5942,4777,7910,8971,6279,7253,2516,1555,1833,3184,9453,9053,6897,7808,8629,4877,1871,8055,4881,7639,1537,7701,2508,7564,5845,5023,2304,5396,3193,2955,1088,3801,6203,1748,3737,1276,13,4120,7715,8552,3047,2921,106,7508,304,1280,7140,2567,9135,5266
 6237,4607,7527,9047,522,7371,4883,2540,5867,6366,5301,1570,421,276,3361,527,6637,4861,2401,7522,5808,9371,5298,2045,5096,5447,7755,5115,7060,8529,4078,1943,1697,1764,5453,7085,960,2405,739,2100,5800,728,9737,5704,5693,1431,8979,6428,673,7540,6,7773,5857,6823,150,5869,8486,684,5816,9626,7451,5579,8260,3397,5322,6920,1879,2127,2884,5478,4977,9016,6165,6292,3062,5671,5968,78,4619,4763
 9905,7127,9390,5185,6923,3721,9164,9705,4341,1031,1046,5127,7376,6528,3248,4941,1178,7889,3364,4486,5358,9402,9158,8600,1025,874,1839,1783,309,9030,1843,845,8398,1433,7118,70,8071,2877,3904,8866,6722,4299,10,1929,5897,4188,600,1889,3325,2485,6473,4474,7444,6992,4846,6166,4441,2283,2629,4352,7775,1101,2214,9985,215,8270,9750,2740,8361,7103,5930,8664,9690,8302,9267,344,2077,1372,1880,9550
 5825,8517,7769,2405,8204,1060,3603,7025,478,8334,1997,3692,7433,9101,7294,7498,9415,5452,3850,3508,6857,9213,6807,4412,7310,854,5384,686,4978,892,8651,3241,2743,3801,3813,8588,6701,4416,6990,6490,3197,6838,6503,114,8343,5844,8646,8694,65,791,5979,2687,2621,2019,8097,1423,3644,9764,4921,3266,3662,5561,2476,8271,8138,6147,1168,3340,1998,9874,6572,9873,6659,5609,2711,3931,9567,4143,7833,8887
 6223,2099,2700,589,4716,8333,1362,5007,2753,2848,4441,8397,7192,8191,4916,9955,6076,3370,6396,6971,3156,248,3911,2488,4930,2458,7183,5455,170,6809,6417,3390,1956,7188,577,7526,2203,968,8164,479,8699,7915,507,6393,4632,1597,7534,3604,618,3280,6061,9793,9238,8347,568,9645,2070,5198,6482,5000,9212,6655,5961,7513,1323,3872,6170,3812,4146,2736,67,3151,5548,2781,9679,7564,5043,8587,1893,4531
 5826,3690,6724,2121,9308,6986,8106,6659,2142,1642,7170,2877,5757,6494,8026,6571,8387,9961,6043,9758,9607,6450,8631,8334,7359,5256,8523,2225,7487,1977,9555,8048,5763,2414,4948,4265,2427,8978,8088,8841,9208,9601,5810,9398,8866,9138,4176,5875,7212,3272,6759,5678,7649,4922,5422,1343,8197,3154,3600,687,1028,4579,2084,9467,4492,7262,7296,6538,7657,7134,2077,1505,7332,6890,8964,4879,7603,7400,5973,739
 1861,1613,4879,1884,7334,966,2000,7489,2123,4287,1472,3263,4726,9203,1040,4103,6075,6049,330,9253,4062,4268,1635,9960,577,1320,3195,9628,1030,4092,4979,6474,6393,2799,6967,8687,7724,7392,9927,2085,3200,6466,8702,265,7646,8665,7986,7266,4574,6587,612,2724,704,3191,8323,9523,3002,704,5064,3960,8209,2027,2758,8393,4875,4641,9584,6401,7883,7014,768,443,5490,7506,1852,2005,8850,5776,4487,4269
 4052,6687,4705,7260,6645,6715,3706,5504,8672,2853,1136,8187,8203,4016,871,1809,1366,4952,9294,5339,6872,2645,6083,7874,3056,5218,7485,8796,7401,3348,2103,426,8572,4163,9171,3176,948,7654,9344,3217,1650,5580,7971,2622,76,2874,880,2034,9929,1546,2659,5811,3754,7096,7436,9694,9960,7415,2164,953,2360,4194,2397,1047,2196,6827,575,784,2675,8821,6802,7972,5996,6699,2134,7577,2887,1412,4349,4380
 4629,2234,6240,8132,7592,3181,6389,1214,266,1910,2451,8784,2790,1127,6932,1447,8986,2492,5476,397,889,3027,7641,5083,5776,4022,185,3364,5701,2442,2840,4160,9525,4828,6602,2614,7447,3711,4505,7745,8034,6514,4907,2605,7753,6958,7270,6936,3006,8968,439,2326,4652,3085,3425,9863,5049,5361,8688,297,7580,8777,7916,6687,8683,7141,306,9569,2384,1500,3346,4601,7329,9040,6097,2727,6314,4501,4974,2829
 8316,4072,2025,6884,3027,1808,5714,7624,7880,8528,4205,8686,7587,3230,1139,7273,6163,6986,3914,9309,1464,9359,4474,7095,2212,7302,2583,9462,7532,6567,1606,4436,8981,5612,6796,4385,5076,2007,6072,3678,8331,1338,3299,8845,4783,8613,4071,1232,6028,2176,3990,2148,3748,103,9453,538,6745,9110,926,3125,473,5970,8728,7072,9062,1404,1317,5139,9862,6496,6062,3338,464,1600,2532,1088,8232,7739,8274,3873
 2341,523,7096,8397,8301,6541,9844,244,4993,2280,7689,4025,4196,5522,7904,6048,2623,9258,2149,9461,6448,8087,7245,1917,8340,7127,8466,5725,6996,3421,5313,512,9164,9837,9794,8369,4185,1488,7210,1524,1016,4620,9435,2478,7765,8035,697,6677,3724,6988,5853,7662,3895,9593,1185,4727,6025,5734,7665,3070,138,8469,6748,6459,561,7935,8646,2378,462,7755,3115,9690,8877,3946,2728,8793,244,6323,8666,4271
 6430,2406,8994,56,1267,3826,9443,7079,7579,5232,6691,3435,6718,5698,4144,7028,592,2627,217,734,6194,8156,9118,58,2640,8069,4127,3285,694,3197,3377,4143,4802,3324,8134,6953,7625,3598,3584,4289,7065,3434,2106,7132,5802,7920,9060,7531,3321,1725,1067,3751,444,5503,6785,7937,6365,4803,198,6266,8177,1470,6390,1606,2904,7555,9834,8667,2033,1723,5167,1666,8546,8152,473,4475,6451,7947,3062,3281
 2810,3042,7759,1741,2275,2609,7676,8640,4117,1958,7500,8048,1757,3954,9270,1971,4796,2912,660,5511,3553,1012,5757,4525,6084,7198,8352,5775,7726,8591,7710,9589,3122,4392,6856,5016,749,2285,3356,7482,9956,7348,2599,8944,495,3462,3578,551,4543,7207,7169,7796,1247,4278,6916,8176,3742,8385,2310,1345,8692,2667,4568,1770,8319,3585,4920,3890,4928,7343,5385,9772,7947,8786,2056,9266,3454,2807,877,2660
 6206,8252,5928,5837,4177,4333,207,7934,5581,9526,8906,1498,8411,2984,5198,5134,2464,8435,8514,8674,3876,599,5327,826,2152,4084,2433,9327,9697,4800,2728,3608,3849,3861,3498,9943,1407,3991,7191,9110,5666,8434,4704,6545,5944,2357,1163,4995,9619,6754,4200,9682,6654,4862,4744,5953,6632,1054,293,9439,8286,2255,696,8709,1533,1844,6441,430,1999,6063,9431,7018,8057,2920,6266,6799,356,3597,4024,6665
 3847,6356,8541,7225,2325,2946,5199,469,5450,7508,2197,9915,8284,7983,6341,3276,3321,16,1321,7608,5015,3362,8491,6968,6818,797,156,2575,706,9516,5344,5457,9210,5051,8099,1617,9951,7663,8253,9683,2670,1261,4710,1068,8753,4799,1228,2621,3275,6188,4699,1791,9518,8701,5932,4275,6011,9877,2933,4182,6059,2930,6687,6682,9771,654,9437,3169,8596,1827,5471,8909,2352,123,4394,3208,8756,5513,6917,2056
 5458,8173,3138,3290,4570,4892,3317,4251,9699,7973,1163,1935,5477,6648,9614,5655,9592,975,9118,2194,7322,8248,8413,3462,8560,1907,7810,6650,7355,2939,4973,6894,3933,3784,3200,2419,9234,4747,2208,2207,1945,2899,1407,6145,8023,3484,5688,7686,2737,3828,3704,9004,5190,9740,8643,8650,5358,4426,1522,1707,3613,9887,6956,2447,2762,833,1449,9489,2573,1080,4167,3456,6809,2466,227,7125,2759,6250,6472,8089
 3266,7025,9756,3914,1265,9116,7723,9788,6805,5493,2092,8688,6592,9173,4431,4028,6007,7131,4446,4815,3648,6701,759,3312,8355,4485,4187,5188,8746,7759,3528,2177,5243,8379,3838,7233,4607,9187,7216,2190,6967,2920,6082,7910,5354,3609,8958,6949,7731,494,8753,8707,1523,4426,3543,7085,647,6771,9847,646,5049,824,8417,5260,2730,5702,2513,9275,4279,2767,8684,1165,9903,4518,55,9682,8963,6005,2102,6523
 1998,8731,936,1479,5259,7064,4085,91,7745,7136,3773,3810,730,8255,2705,2653,9790,6807,2342,355,9344,2668,3690,2028,9679,8102,574,4318,6481,9175,5423,8062,2867,9657,7553,3442,3920,7430,3945,7639,3714,3392,2525,4995,4850,2867,7951,9667,486,9506,9888,781,8866,1702,3795,90,356,1483,4200,2131,6969,5931,486,6880,4404,1084,5169,4910,6567,8335,4686,5043,2614,3352,2667,4513,6472,7471,5720,1616
 8878,1613,1716,868,1906,2681,564,665,5995,2474,7496,3432,9491,9087,8850,8287,669,823,347,6194,2264,2592,7871,7616,8508,4827,760,2676,4660,4881,7572,3811,9032,939,4384,929,7525,8419,5556,9063,662,8887,7026,8534,3111,1454,2082,7598,5726,6687,9647,7608,73,3014,5063,670,5461,5631,3367,9796,8475,7908,5073,1565,5008,5295,4457,1274,4788,1728,338,600,8415,8535,9351,7750,6887,5845,1741,125
 3637,6489,9634,9464,9055,2413,7824,9517,7532,3577,7050,6186,6980,9365,9782,191,870,2497,8498,2218,2757,5420,6468,586,3320,9230,1034,1393,9886,5072,9391,1178,8464,8042,6869,2075,8275,3601,7715,9470,8786,6475,8373,2159,9237,2066,3264,5000,679,355,3069,4073,494,2308,5512,4334,9438,8786,8637,9774,1169,1949,6594,6072,4270,9158,7916,5752,6794,9391,6301,5842,3285,2141,3898,8027,4310,8821,7079,1307
 8497,6681,4732,7151,7060,5204,9030,7157,833,5014,8723,3207,9796,9286,4913,119,5118,7650,9335,809,3675,2597,5144,3945,5090,8384,187,4102,1260,2445,2792,4422,8389,9290,50,1765,1521,6921,8586,4368,1565,5727,7855,2003,4834,9897,5911,8630,5070,1330,7692,7557,7980,6028,5805,9090,8265,3019,3802,698,9149,5748,1965,9658,4417,5994,5584,8226,2937,272,5743,1278,5698,8736,2595,6475,5342,6596,1149,6920
 8188,8009,9546,6310,8772,2500,9846,6592,6872,3857,1307,8125,7042,1544,6159,2330,643,4604,7899,6848,371,8067,2062,3200,7295,1857,9505,6936,384,2193,2190,301,8535,5503,1462,7380,5114,4824,8833,1763,4974,8711,9262,6698,3999,2645,6937,7747,1128,2933,3556,7943,2885,3122,9105,5447,418,2899,5148,3699,9021,9501,597,4084,175,1621,1,1079,6067,5812,4326,9914,6633,5394,4233,6728,9084,1864,5863,1225
 9935,8793,9117,1825,9542,8246,8437,3331,9128,9675,6086,7075,319,1334,7932,3583,7167,4178,1726,7720,695,8277,7887,6359,5912,1719,2780,8529,1359,2013,4498,8072,1129,9998,1147,8804,9405,6255,1619,2165,7491,1,8882,7378,3337,503,5758,4109,3577,985,3200,7615,8058,5032,1080,6410,6873,5496,1466,2412,9885,5904,4406,3605,8770,4361,6205,9193,1537,9959,214,7260,9566,1685,100,4920,7138,9819,5637,976
 3466,9854,985,1078,7222,8888,5466,5379,3578,4540,6853,8690,3728,6351,7147,3134,6921,9692,857,3307,4998,2172,5783,3931,9417,2541,6299,13,787,2099,9131,9494,896,8600,1643,8419,7248,2660,2609,8579,91,6663,5506,7675,1947,6165,4286,1972,9645,3805,1663,1456,8853,5705,9889,7489,1107,383,4044,2969,3343,152,7805,4980,9929,5033,1737,9953,7197,9158,4071,1324,473,9676,3984,9680,3606,8160,7384,5432
 1005,4512,5186,3953,2164,3372,4097,3247,8697,3022,9896,4101,3871,6791,3219,2742,4630,6967,7829,5991,6134,1197,1414,8923,8787,1394,8852,5019,7768,5147,8004,8825,5062,9625,7988,1110,3992,7984,9966,6516,6251,8270,421,3723,1432,4830,6935,8095,9059,2214,6483,6846,3120,1587,6201,6691,9096,9627,6671,4002,3495,9939,7708,7465,5879,6959,6634,3241,3401,2355,9061,2611,7830,3941,2177,2146,5089,7079,519,6351
 7280,8586,4261,2831,7217,3141,9994,9940,5462,2189,4005,6942,9848,5350,8060,6665,7519,4324,7684,657,9453,9296,2944,6843,7499,7847,1728,9681,3906,6353,5529,2822,3355,3897,7724,4257,7489,8672,4356,3983,1948,6892,7415,4153,5893,4190,621,1736,4045,9532,7701,3671,1211,1622,3176,4524,9317,7800,5638,6644,6943,5463,3531,2821,1347,5958,3436,1438,2999,994,850,4131,2616,1549,3465,5946,690,9273,6954,7991
 9517,399,3249,2596,7736,2142,1322,968,7350,1614,468,3346,3265,7222,6086,1661,5317,2582,7959,4685,2807,2917,1037,5698,1529,3972,8716,2634,3301,3412,8621,743,8001,4734,888,7744,8092,3671,8941,1487,5658,7099,2781,99,1932,4443,4756,4652,9328,1581,7855,4312,5976,7255,6480,3996,2748,1973,9731,4530,2790,9417,7186,5303,3557,351,7182,9428,1342,9020,7599,1392,8304,2070,9138,7215,2008,9937,1106,7110
 7444,769,9688,632,1571,6820,8743,4338,337,3366,3073,1946,8219,104,4210,6986,249,5061,8693,7960,6546,1004,8857,5997,9352,4338,6105,5008,2556,6518,6694,4345,3727,7956,20,3954,8652,4424,9387,2035,8358,5962,5304,5194,8650,8282,1256,1103,2138,6679,1985,3653,2770,2433,4278,615,2863,1715,242,3790,2636,6998,3088,1671,2239,957,5411,4595,6282,2881,9974,2401,875,7574,2987,4587,3147,6766,9885,2965
 3287,3016,3619,6818,9073,6120,5423,557,2900,2015,8111,3873,1314,4189,1846,4399,7041,7583,2427,2864,3525,5002,2069,748,1948,6015,2684,438,770,8367,1663,7887,7759,1885,157,7770,4520,4878,3857,1137,3525,3050,6276,5569,7649,904,4533,7843,2199,5648,7628,9075,9441,3600,7231,2388,5640,9096,958,3058,584,5899,8150,1181,9616,1098,8162,6819,8171,1519,1140,7665,8801,2632,1299,9192,707,9955,2710,7314
 1772,2963,7578,3541,3095,1488,7026,2634,6015,4633,4370,2762,1650,2174,909,8158,2922,8467,4198,4280,9092,8856,8835,5457,2790,8574,9742,5054,9547,4156,7940,8126,9824,7340,8840,6574,3547,1477,3014,6798,7134,435,9484,9859,3031,4,1502,4133,1738,1807,4825,463,6343,9701,8506,9822,9555,8688,8168,3467,3234,6318,1787,5591,419,6593,7974,8486,9861,6381,6758,194,3061,4315,2863,4665,3789,2201,1492,4416
 126,8927,6608,5682,8986,6867,1715,6076,3159,788,3140,4744,830,9253,5812,5021,7616,8534,1546,9590,1101,9012,9821,8132,7857,4086,1069,7491,2988,1579,2442,4321,2149,7642,6108,250,6086,3167,24,9528,7663,2685,1220,9196,1397,5776,1577,1730,5481,977,6115,199,6326,2183,3767,5928,5586,7561,663,8649,9688,949,5913,9160,1870,5764,9887,4477,6703,1413,4995,5494,7131,2192,8969,7138,3997,8697,646,1028
 8074,1731,8245,624,4601,8706,155,8891,309,2552,8208,8452,2954,3124,3469,4246,3352,1105,4509,8677,9901,4416,8191,9283,5625,7120,2952,8881,7693,830,4580,8228,9459,8611,4499,1179,4988,1394,550,2336,6089,6872,269,7213,1848,917,6672,4890,656,1478,6536,3165,4743,4990,1176,6211,7207,5284,9730,4738,1549,4986,4942,8645,3698,9429,1439,2175,6549,3058,6513,1574,6988,8333,3406,5245,5431,7140,7085,6407
 7845,4694,2530,8249,290,5948,5509,1588,5940,4495,5866,5021,4626,3979,3296,7589,4854,1998,5627,3926,8346,6512,9608,1918,7070,4747,4182,2858,2766,4606,6269,4107,8982,8568,9053,4244,5604,102,2756,727,5887,2566,7922,44,5986,621,1202,374,6988,4130,3627,6744,9443,4568,1398,8679,397,3928,9159,367,2917,6127,5788,3304,8129,911,2669,1463,9749,264,4478,8940,1109,7309,2462,117,4692,7724,225,2312
 4164,3637,2000,941,8903,39,3443,7172,1031,3687,4901,8082,4945,4515,7204,9310,9349,9535,9940,218,1788,9245,2237,1541,5670,6538,6047,5553,9807,8101,1925,8714,445,8332,7309,6830,5786,5736,7306,2710,3034,1838,7969,6318,7912,2584,2080,7437,6705,2254,7428,820,782,9861,7596,3842,3631,8063,5240,6666,394,4565,7865,4895,9890,6028,6117,4724,9156,4473,4552,602,470,6191,4927,5387,884,3146,1978,3000
 4258,6880,1696,3582,5793,4923,2119,1155,9056,9698,6603,3768,5514,9927,9609,6166,6566,4536,4985,4934,8076,9062,6741,6163,7399,4562,2337,5600,2919,9012,8459,1308,6072,1225,9306,8818,5886,7243,7365,8792,6007,9256,6699,7171,4230,7002,8720,7839,4533,1671,478,7774,1607,2317,5437,4705,7886,4760,6760,7271,3081,2997,3088,7675,6208,3101,6821,6840,122,9633,4900,2067,8546,4549,2091,7188,5605,8599,6758,5229
 7854,5243,9155,3556,8812,7047,2202,1541,5993,4600,4760,713,434,7911,7426,7414,8729,322,803,7960,7563,4908,6285,6291,736,3389,9339,4132,8701,7534,5287,3646,592,3065,7582,2592,8755,6068,8597,1982,5782,1894,2900,6236,4039,6569,3037,5837,7698,700,7815,2491,7272,5878,3083,6778,6639,3589,5010,8313,2581,6617,5869,8402,6808,2951,2321,5195,497,2190,6187,1342,1316,4453,7740,4154,2959,1781,1482,8256
 7178,2046,4419,744,8312,5356,6855,8839,319,2962,5662,47,6307,8662,68,4813,567,2712,9931,1678,3101,8227,6533,4933,6656,92,5846,4780,6256,6361,4323,9985,1231,2175,7178,3034,9744,6155,9165,7787,5836,9318,7860,9644,8941,6480,9443,8188,5928,161,6979,2352,5628,6991,1198,8067,5867,6620,3778,8426,2994,3122,3124,6335,3918,8897,2655,9670,634,1088,1576,8935,7255,474,8166,7417,9547,2886,5560,3842
 6957,3111,26,7530,7143,1295,1744,6057,3009,1854,8098,5405,2234,4874,9447,2620,9303,27,7410,969,40,2966,5648,7596,8637,4238,3143,3679,7187,690,9980,7085,7714,9373,5632,7526,6707,3951,9734,4216,2146,3602,5371,6029,3039,4433,4855,4151,1449,3376,8009,7240,7027,4602,2947,9081,4045,8424,9352,8742,923,2705,4266,3232,2264,6761,363,2651,3383,7770,6730,7856,7340,9679,2158,610,4471,4608,910,6241
 4417,6756,1013,8797,658,8809,5032,8703,7541,846,3357,2920,9817,1745,9980,7593,4667,3087,779,3218,6233,5568,4296,2289,2654,7898,5021,9461,5593,8214,9173,4203,2271,7980,2983,5952,9992,8399,3468,1776,3188,9314,1720,6523,2933,621,8685,5483,8986,6163,3444,9539,4320,155,3992,2828,2150,6071,524,2895,5468,8063,1210,3348,9071,4862,483,9017,4097,6186,9815,3610,5048,1644,1003,9865,9332,2145,1944,2213
 9284,3803,4920,1927,6706,4344,7383,4786,9890,2010,5228,1224,3158,6967,8580,8990,8883,5213,76,8306,2031,4980,5639,9519,7184,5645,7769,3259,8077,9130,1317,3096,9624,3818,1770,695,2454,947,6029,3474,9938,3527,5696,4760,7724,7738,2848,6442,5767,6845,8323,4131,2859,7595,2500,4815,3660,9130,8580,7016,8231,4391,8369,3444,4069,4021,556,6154,627,2778,1496,4206,6356,8434,8491,3816,8231,3190,5575,1015
 3787,7572,1788,6803,5641,6844,1961,4811,8535,9914,9999,1450,8857,738,4662,8569,6679,2225,7839,8618,286,2648,5342,2294,3205,4546,176,8705,3741,6134,8324,8021,7004,5205,7032,6637,9442,5539,5584,4819,5874,5807,8589,6871,9016,983,1758,3786,1519,6241,185,8398,495,3370,9133,3051,4549,9674,7311,9738,3316,9383,2658,2776,9481,7558,619,3943,3324,6491,4933,153,9738,4623,912,3595,7771,7939,1219,4405
 2650,3883,4154,5809,315,7756,4430,1788,4451,1631,6461,7230,6017,5751,138,588,5282,2442,9110,9035,6349,2515,1570,6122,4192,4174,3530,1933,4186,4420,4609,5739,4135,2963,6308,1161,8809,8619,2796,3819,6971,8228,4188,1492,909,8048,2328,6772,8467,7671,9068,2226,7579,6422,7056,8042,3296,2272,3006,2196,7320,3238,3490,3102,37,1293,3212,4767,5041,8773,5794,4456,6174,7279,7054,2835,7053,9088,790,6640
 3101,1057,7057,3826,6077,1025,2955,1224,1114,6729,5902,4698,6239,7203,9423,1804,4417,6686,1426,6941,8071,1029,4985,9010,6122,6597,1622,1574,3513,1684,7086,5505,3244,411,9638,4150,907,9135,829,981,1707,5359,8781,9751,5,9131,3973,7159,1340,6955,7514,7993,6964,8198,1933,2797,877,3993,4453,8020,9349,8646,2779,8679,2961,3547,3374,3510,1129,3568,2241,2625,9138,5974,8206,7669,7678,1833,8700,4480
 4865,9912,8038,8238,782,3095,8199,1127,4501,7280,2112,2487,3626,2790,9432,1475,6312,8277,4827,2218,5806,7132,8752,1468,7471,6386,739,8762,8323,8120,5169,9078,9058,3370,9560,7987,8585,8531,5347,9312,1058,4271,1159,5286,5404,6925,8606,9204,7361,2415,560,586,4002,2644,1927,2824,768,4409,2942,3345,1002,808,4941,6267,7979,5140,8643,7553,9438,7320,4938,2666,4609,2778,8158,6730,3748,3867,1866,7181
 171,3771,7134,8927,4778,2913,3326,2004,3089,7853,1378,1729,4777,2706,9578,1360,5693,3036,1851,7248,2403,2273,8536,6501,9216,613,9671,7131,7719,6425,773,717,8803,160,1114,7554,7197,753,4513,4322,8499,4533,2609,4226,8710,6627,644,9666,6260,4870,5744,7385,6542,6203,7703,6130,8944,5589,2262,6803,6381,7414,6888,5123,7320,9392,9061,6780,322,8975,7050,5089,1061,2260,3199,1150,1865,5386,9699,6501
 3744,8454,6885,8277,919,1923,4001,6864,7854,5519,2491,6057,8794,9645,1776,5714,9786,9281,7538,6916,3215,395,2501,9618,4835,8846,9708,2813,3303,1794,8309,7176,2206,1602,1838,236,4593,2245,8993,4017,10,8215,6921,5206,4023,5932,6997,7801,262,7640,3107,8275,4938,7822,2425,3223,3886,2105,8700,9526,2088,8662,8034,7004,5710,2124,7164,3574,6630,9980,4242,2901,9471,1491,2117,4562,1130,9086,4117,6698
 2810,2280,2331,1170,4554,4071,8387,1215,2274,9848,6738,1604,7281,8805,439,1298,8318,7834,9426,8603,6092,7944,1309,8828,303,3157,4638,4439,9175,1921,4695,7716,1494,1015,1772,5913,1127,1952,1950,8905,4064,9890,385,9357,7945,5035,7082,5369,4093,6546,5187,5637,2041,8946,1758,7111,6566,1027,1049,5148,7224,7248,296,6169,375,1656,7993,2816,3717,4279,4675,1609,3317,42,6201,3100,3144,163,9530,4531
 7096,6070,1009,4988,3538,5801,7149,3063,2324,2912,7911,7002,4338,7880,2481,7368,3516,2016,7556,2193,1388,3865,8125,4637,4096,8114,750,3144,1938,7002,9343,4095,1392,4220,3455,6969,9647,1321,9048,1996,1640,6626,1788,314,9578,6630,2813,6626,4981,9908,7024,4355,3201,3521,3864,3303,464,1923,595,9801,3391,8366,8084,9374,1041,8807,9085,1892,9431,8317,9016,9221,8574,9981,9240,5395,2009,6310,2854,9255
 8830,3145,2960,9615,8220,6061,3452,2918,6481,9278,2297,3385,6565,7066,7316,5682,107,7646,4466,68,1952,9603,8615,54,7191,791,6833,2560,693,9733,4168,570,9127,9537,1925,8287,5508,4297,8452,8795,6213,7994,2420,4208,524,5915,8602,8330,2651,8547,6156,1812,6271,7991,9407,9804,1553,6866,1128,2119,4691,9711,8315,5879,9935,6900,482,682,4126,1041,428,6247,3720,5882,7526,2582,4327,7725,3503,2631
 2738,9323,721,7434,1453,6294,2957,3786,5722,6019,8685,4386,3066,9057,6860,499,5315,3045,5194,7111,3137,9104,941,586,3066,755,4177,8819,7040,5309,3583,3897,4428,7788,4721,7249,6559,7324,825,7311,3760,6064,6070,9672,4882,584,1365,9739,9331,5783,2624,7889,1604,1303,1555,7125,8312,425,8936,3233,7724,1480,403,7440,1784,1754,4721,1569,652,3893,4574,5692,9730,4813,9844,8291,9199,7101,3391,8914
 6044,2928,9332,3328,8588,447,3830,1176,3523,2705,8365,6136,5442,9049,5526,8575,8869,9031,7280,706,2794,8814,5767,4241,7696,78,6570,556,5083,1426,4502,3336,9518,2292,1885,3740,3153,9348,9331,8051,2759,5407,9028,7840,9255,831,515,2612,9747,7435,8964,4971,2048,4900,5967,8271,1719,9670,2810,6777,1594,6367,6259,8316,3815,1689,6840,9437,4361,822,9619,3065,83,6344,7486,8657,8228,9635,6932,4864
 8478,4777,6334,4678,7476,4963,6735,3096,5860,1405,5127,7269,7793,4738,227,9168,2996,8928,765,733,1276,7677,6258,1528,9558,3329,302,8901,1422,8277,6340,645,9125,8869,5952,141,8141,1816,9635,4025,4184,3093,83,2344,2747,9352,7966,1206,1126,1826,218,7939,2957,2729,810,8752,5247,4174,4038,8884,7899,9567,301,5265,5752,7524,4381,1669,3106,8270,6228,6373,754,2547,4240,2313,5514,3022,1040,9738
 2265,8192,1763,1369,8469,8789,4836,52,1212,6690,5257,8918,6723,6319,378,4039,2421,8555,8184,9577,1432,7139,8078,5452,9628,7579,4161,7490,5159,8559,1011,81,478,5840,1964,1334,6875,8670,9900,739,1514,8692,522,9316,6955,1345,8132,2277,3193,9773,3923,4177,2183,1236,6747,6575,4874,6003,6409,8187,745,8776,9440,7543,9825,2582,7381,8147,7236,5185,7564,6125,218,7991,6394,391,7659,7456,5128,5294
 2132,8992,8160,5782,4420,3371,3798,5054,552,5631,7546,4716,1332,6486,7892,7441,4370,6231,4579,2121,8615,1145,9391,1524,1385,2400,9437,2454,7896,7467,2928,8400,3299,4025,7458,4703,7206,6358,792,6200,725,4275,4136,7390,5984,4502,7929,5085,8176,4600,119,3568,76,9363,6943,2248,9077,9731,6213,5817,6729,4190,3092,6910,759,2682,8380,1254,9604,3011,9291,5329,9453,9746,2739,6522,3765,5634,1113,5789
 5304,5499,564,2801,679,2653,1783,3608,7359,7797,3284,796,3222,437,7185,6135,8571,2778,7488,5746,678,6140,861,7750,803,9859,9918,2425,3734,2698,9005,4864,9818,6743,2475,132,9486,3825,5472,919,292,4411,7213,7699,6435,9019,6769,1388,802,2124,1345,8493,9487,8558,7061,8777,8833,2427,2238,5409,4957,8503,3171,7622,5779,6145,2417,5873,5563,5693,9574,9491,1937,7384,4563,6842,5432,2751,3406,7981
@@ -0,0 +1,9 @@
 for ($a = 1; $a -lt 1000; $a++) {
 	for ($b = $a + 1; $b -lt 1000; $b++) {
 		$c = [math]::sqrt($a * $a + $b * $b)
 		if ($c -eq [math]::floor($c) -and $a + $b + $c -eq 1000) {
 			$a, $b, $c
 		}
 	}
 }
@@ -0,0 +1,22 @@
 module _92
 open common
 let squareChainLoop =
    let squareDigits d =
        let square n = n * n
        d |> numDigits |> Seq.map square |> Seq.sum
    let chainDict = new System.Collections.Generic.Dictionary<int,int>()
    let rec chainCache = function
        | x when chainDict.ContainsKey(x) -> chainDict.[x]
        | 1 -> 1
        | 89 -> 89
        | x -> chainDict.[x] <- chainCache (squareDigits x); chainDict.[x]
    allIntegers |> Seq.skip 1 |> Seq.takeWhile ((>) 10000000)
    |> Seq.map chainCache
    |> Seq.filter ((=) 89)
    |> Seq.length
@@ -0,0 +1,12 @@
 module _97
 open System.Numerics
 let multiplyLastDigitsFun d =
    let l = System.Math.Pow(10.0,float(d))
    fun (n, m) -> (n * m) % l
 let bigPrime =
    let f = multiplyLastDigitsFun 10
    let p = [1..7830457] |> Seq.fold (fun s i -> f(s,2.0)) 1.0
    (28433.0,p) |> f |> (+) 1.0
@@ -0,0 +1,90 @@
 module _98
 open System.IO
 open common
 let anagramSquares =
    let words =
        File.ReadAllLines(@"98_words.txt") 
        |> Array.collect (fun line -> line.Split(','))
        |> Array.map (fun w -> w.Replace("\"", "").ToLower())
    let groupAnagrams =
        let concatCharArray (cs:char array) = new string(cs)
        // sort by characters in each string and then glue them back together
        Seq.groupBy (Array.ofSeq >> Array.sort >> (fun cs -> new string(cs)))
        >> Seq.map snd
        >> Seq.filter (fun l -> Seq.length l > 1)
        >> Seq.map Array.ofSeq
    let pairwiseTuples =
        Seq.collect (
            combinations 2
            >> Seq.map (fun l -> l.[0], l.[1])
        )
    let wordAnagrams =
        words
        |> groupAnagrams
        |> pairwiseTuples
    let squares  =
        allSquares
        |> Seq.takeWhile (digitCount >> ((>) 10))
        |> Seq.groupBy digitCount
        |> Seq.map (fun (dc,sqs) -> (dc, sqs |> Seq.map string |> Array.ofSeq))
        |> Map.ofSeq
    let hasReplacementDictionary (s1, s2) (t1, t2) =
        let rec hasReplacementDictionary (sToT, tToS) (source, target) =
            match source, target with
            // have already seen this exact mapping -> skip it
            | s::ss, t::tt when Map.containsKey s sToT && (Map.find s sToT) = t 
                -> hasReplacementDictionary (sToT, tToS) (ss, tt)
            // have a mapping for the source, but it's not the target -> failure
            | s::_, _ when Map.containsKey s sToT
                -> false
            // have a mapping for the target, but it's not the source -> failure
            | _::_, t::_ when Map.containsKey t tToS 
                -> false
            // never before seen mapping -> add it
            | s::ss, t::tt
                -> hasReplacementDictionary (Map.add s t sToT, Map.add t s tToS) (ss, tt)
            // end of the line - a successful translation!
            | [], [] -> true
            | _ -> raise(System.ArgumentException("words not equal length"))
        let los = List.ofSeq
        let s = List.append (los s1) (los s2)
        let t = List.append (los t1) (los t2)
        hasReplacementDictionary (Map.empty, Map.empty) (s, t)
    let tupleSeqAddReverse =
        Seq.collect (fun (i,j) -> seq {yield (i,j); yield (j,i)})
    let squareAnagrams =
        squares
        |> Map.map (fun _ s ->
                    s
                    |> groupAnagrams
                    |> pairwiseTuples
                    |> tupleSeqAddReverse
                    )
    wordAnagrams
    |> Seq.collect (fun wordAnagram ->
        let wordLen = wordAnagram |> fst |> String.length
        Map.find wordLen squareAnagrams 
        |> Seq.collect (fun squareAnagram ->
            seq {
                if hasReplacementDictionary wordAnagram squareAnagram then
                    yield (wordAnagram, squareAnagram)
                }
            )
        )
    |> Seq.toArray
    |> Seq.map (fun (_,(i,j)) -> System.Math.Max(int i,int j))
    |> Seq.max    
@@ -0,0 +1,14 @@
 module _99
 open System.IO
 let biggestNum =
    let baseExp = 
        File.ReadAllLines(@"99_base_exp.txt") 
        |> Array.map (fun line -> line.Split(',') |> Array.map float |> (fun a -> (a.[0], a.[1])))
    baseExp
    |> Array.mapi (fun i (b,e) -> (i + 1, e * System.Math.Log10(b)))
    |> Array.sortBy snd |> Array.rev
@@ -0,0 +1,30 @@
 module Fraction
 open common
 let reduce (n,d) =
    let g = gcd(n,d)
    (n/g,d/g)
 let mul (n1,d1) (n2,d2) =
    (n1 * n2, d1 * d2)
 let reciprocal (n,d) = (d,n)
 let add (n1,d1) (n2,d2) =
    let f = (n1*d2 + n2*d1, d2*d1)
    reduce f
 let reduceI (n:bigint,d:bigint) =
    let g = gcdI(n,d)
    (n/g,d/g)
 let mulI (n1:bigint,d1:bigint) (n2:bigint,d2:bigint) =
    reduceI (n1 * n2, d1 * d2)
 let reciprocalI (n:bigint,d:bigint) = (d,n)
 let addI (n1:bigint,d1:bigint) (n2,d2) =
    let f = (n1*d2 + n2*d1, d2*d1)
    f
    //reduceI f
@@ -0,0 +1,2 @@
 $assemblyName = gci .\Oyster.IntX.dll | % {$_.FullName }
 [System.Reflection.Assembly]::LoadFile($assemblyName)
@@ -0,0 +1,232 @@
 module common
 let allIntegers = Seq.unfold(fun i -> Some(i, i + 1)) 0
 let allSquares = Seq.unfold(fun (square,odd) -> Some(square, (square+odd, odd+2))) (0,1)
 let multiples n =
    let rec m ns =
        seq { 
            yield ns
            yield! m (ns + n)
        }
    m n
 let divisorsWithRule rule len = 
    let d = Array.create (len + 1) [] // stores the divisors for each number by index
    seq {1..len} |> Seq.iter (fun i -> 
        seq { i .. i .. len } |> Seq.iter ( fun j ->
            if rule i j then d.[j] <- i :: d.[j]
            )
        )
    d
 let divisors = divisorsWithRule (<>)
 let divisorsInclSelf = divisorsWithRule (fun _ _ -> true)
 let rec gcd(a,b) =
    if b > a then gcd (b,a) else
    match b with
    | 0 -> a
    | b -> gcd (b, a%b)
 let rec gcdI(a:bigint,b:bigint) =
    if b > a then gcdI (b,a) else
    match b with
    | b when b = 0I -> a
    | b -> gcdI (b, a%b)
 let primeArray max = 
    let d = Array.init (max + 1) (fun i -> i)
    seq {2..(max/2)} |> Seq.iter (fun i -> 
        seq { 0 .. i .. max } |> Seq.iter ( fun j ->
            if i <> j && j <> 0 then d.[j] <- -1
            )
        )
    d |> Array.filter ((<) 1)
 let isPrimeFunByArray primes =
    let primeLookup =
        primes |> Array.map (fun p -> (p, true)) |> dict
    (fun n -> primeLookup.ContainsKey(n))
 let isPrimeFunByMax max =
    primeArray max |> isPrimeFunByArray
 let isPrimeI n =
    if n < 2I then false
    else
        let limit = float n |> sqrt |> fun x -> x + 1. |> (fun n -> bigint n)
        let rec loop d =
            match d with
            | limit -> true
            | d when n % d = 0I -> false
            | _ -> loop (d + 1I)
        loop 2I
 let compositeArray max =
    let primes = primeArray max
    primes
    |> Seq.pairwise
    |> Seq.collect (fun (p1, p2) -> 
        seq { (p1+1) .. (p2 - 1) }
    )
 let coprimeArray len =
    let c = Array.create (len + 1) []
    let d = divisors len
    d.[1] <- [1]
    let set1 = Set [1]
    for i in 2 .. len do
        let dis = Set d.[i]
        for j in 1 .. (i - 1) do
            //if not (Set.contains j dis) then
                let djs = Set d.[j]
                if Set.intersect dis djs = set1 then
                    c.[i] <- j :: c.[i]
    c
 let crossMapList l1 l2 =
  seq { for el1 in l1 do
          for el2 in l2 do
            yield (el1, el2) }
 let crossSelfMapList l =
  crossMapList l l
 let crossMap f l1 l2 =
    crossMapList l1 l2 |> Seq.map (fun (el1, el2) -> f el1 el2)
 let crossSelfMap f l =
  crossMap f l l
 let rec permutations set =
    seq { 
        if Set.empty = set then yield [] else
        for s in set do
            let remaining = set |> Set.remove s
            for perm in (permutations remaining) do
                yield s :: perm
    }
 let rec slottedPermutations slots =
    seq { 
        if List.empty = slots then yield [] else
        let set = List.head slots
        for s in set do
            for perm in (slottedPermutations (List.tail slots)) do
                yield s :: perm
    }
 let combinations size set = 
    let rec combinations acc size set = seq {
        match size, set with 
        | n, x::xs -> 
            if n > 0 then yield! combinations (x::acc) (n - 1) xs
            if n >= 0 then yield! combinations acc n xs 
        | 0, [] -> yield acc 
        | _, [] -> () }
    combinations [] size (set |> List.ofSeq)
 let fibinoci =
    let rec f (c, p) =
        seq { 
            yield c
            yield! f (c + p, c)
        }
    f (1I,0I)
 let digitCount n =
    int (System.Math.Floor(System.Math.Log10 (float n)) + 1.0)
 let mapChars f n =
    (string n).ToCharArray()
    |> Array.map f
 let joinStrings =
    Array.map string
    >> Array.fold (fun acc i -> i + acc) ""
 let numDigits =
    mapChars (string >> int)
 let digitsNum (ds:int[]) =
    ds
    |> joinStrings
    |> int
 let lastDigits d n =
    let s = string n
    s.Substring(s.Length - d)
 let rec factorial n =
    match n with
    | 0 
    | 1 -> 1
    | _ -> n * factorial (n - 1)
 let rec factorialI n =
    match n with
    | n when n = 0I -> 1I
    | n when n = 1I -> 1I
    | _ -> n * factorialI (n - 1I)
 let takeIndexes ns input = 
    // Take only elements that we need to access (sequence could be infinite)
    let arr = input |> Seq.take (1 + Seq.max ns) |> Array.ofSeq
    // Simply pick elements at the specified indices from the array
    seq { for index in ns -> arr.[index] }
 let arrayToRevSeq a =
    let len = (Array.length a) - 1
    seq {
        for i in len .. -1 .. 0  do
            yield a.[i]
    }
 let array2DFromNested a =
    Array2D.init (Array.length a) (Array.length a.[0]) (fun i j -> a.[i].[j])
 let strSplit t (str:string) = str.Split(',') |> Array.map t
 let strSplitInt = strSplit int
 let strSplitFloat = strSplit float
 let isPanDigitalD digits =
    let len = Seq.length digits
    let range = Seq.forall (fun d -> d <= len && d > 0) digits
    let unique = Set.count (Set digits) = len
    range && unique
 let isPanDigital n =
    isPanDigitalD (numDigits n)
 let isPanDigitalGroup s =
    Seq.collect numDigits s |> isPanDigitalD
 let letterValue (c:char) =
    int c - 64
 let wordValue (w:string) =
    w.ToUpper()
    |> Seq.map letterValue
    |> Seq.sum
 let floatWrap f n =
    let n = float n
    f n |> int64 |> (fun n -> bigint n)
 let triangleNumber n =
    n |> floatWrap (fun n -> n / 2.0 * (n + 1.0))
 let pentagonalNumber n =
    n |> floatWrap (fun n -> n / 2.0 * (3.0 * n - 1.0))
 let hexagonalNumber n =
    n |> floatWrap (fun n -> n * (2.0 * n - 1.0))
 let revString s =
    new string (s |> Seq.toArray |> Array.rev)
 let isPalindrome s =
    s = revString s
@@ -0,0 +1,64 @@
 module millerRabinPrimality
 // [snippet: Miller-Rabin primality test]
 open System.Numerics
 ///See: http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
 let millerRabinPrimality n a =
    ///This implementation is based on the Miller-Rabin Haskell implementation 
    ///from http://www.haskell.org/haskellwiki/Testing_primality
    let pow' mul sq x' n' = 
        let rec f x n y = 
            if n = 1I then
                mul x y
            else
                let (q,r) = BigInteger.DivRem(n, 2I)
                let x2 = sq x
                if r = 0I then
                    f x2 q y
                else
                    f x2 q (mul x y)
        f x' n' 1I
    let mulMod (a :bigint) b c = (b * c) % a
    let squareMod (a :bigint) b = (b * b) % a
    let powMod m = pow' (mulMod m) (squareMod m)
    let iterate f = Seq.unfold(fun x -> let fx = f x in Some(x,fx))
    let find2km n = 
        let rec f k m = 
            let (q,r) = BigInteger.DivRem(m, 2I)
            if r = 1I then
                (k,m)
            else
                f (k+1I) q
        f 0I n
    let n' = n - 1I
    let iter = Seq.tryPick(fun x -> if x = 1I then Some(false) elif x = n' then Some(true) else None)
    let (k,m) = find2km n'
    let b0 = powMod n a m
    match (a,n) with
    | _ when a <= 1I && a >= n' -> 
        failwith (sprintf "millerRabinPrimality: a out of range (%A for %A)" a n)
    | _ when b0 = 1I || b0 = n' -> true
    | _  -> b0 
                |> iterate (squareMod n) 
                |> Seq.take(int k)
                |> Seq.skip 1 
                |> iter 
                |> Option.exists id 
 ///For Miller-Rabin the witnesses need to be selected at random from the interval [2, n - 2]. 
 ///More witnesses => better accuracy of the test.
 ///Also, remember that if Miller-Rabin returns true, then the number is _probable_ prime. 
 ///If it returns false the number is composite.
 let isPrimeW witnesses n = 
    match n with
    | n when n < 2I -> false
    | n when n = 2I -> true
    | n when n = 3I -> true
    | n when n % 2I = 0I -> false
    | n -> witnesses |> Seq.forall(millerRabinPrimality n)
@@ -0,0 +1,32 @@
 module npr_sundaypuzzle_20120422
 open common
 open System.IO
 open System.Text.RegularExpressions
 let puzzle =
    let loadNames fn =
        File.ReadAllLines(fn) 
        |> Seq.map (fun l -> Regex.Replace(l, "(\w+).*", "$1").ToLower() )
        |> Seq.filter (fun n -> n.Length = 4)
    let maleNames = 
        loadNames @"dist.male.first.txt"
    let femaleNames = 
        loadNames @"dist.female.first.txt"
    let rotateChar (c:char) =
        c |> int |> (fun n -> (n + 13 - 97) % 26 + 97) |> char
    let rotateName name =
        name
        |> mapChars rotateChar
        |> Array.map string
        |> Array.fold (fun acc i -> acc + i) ""
    maleNames
    |> Seq.map (fun n -> (n, rotateName n))
    |> Seq.filter (fun (_,mn) -> Seq.exists ((=) mn) femaleNames)
    |> Seq.toArray
@@ -0,0 +1,87 @@
 module program
 open System
 open System.Windows.Forms
 [<EntryPoint>]
 let main args =
    let sprintfA f = sprintf "%A" f
    let funize f = fun () -> f
    let myFunc () = 
        printfn "Evaluating myFunc"
        "myFunc Result"
    let sprintfFunc f = fun () -> sprintf "%A" f
    let r = sprintfFunc myFunc
    printfn "%s" (r())
    let problems = [
        11, fun () -> sprintfA _11.maxProduct;
        12, fun () -> sprintfA _12.fiveDivisorTriangle;
        13, fun () -> sprintfA _13.getSum;
        14, fun () -> sprintfA _14.getLongestChain;
        17, fun () -> sprintfA _17.getNumberWords;
        18, fun () -> sprintfA _18.getTriangleMaxTotal;
        19, fun () -> sprintfA _19.firstSaturdays;
        20, fun () -> sprintfA _20.getSum;
        21, fun () -> sprintfA _21.amicalbleSum;
        22, fun () -> sprintfA _22.nameScores;
        23, fun () -> sprintfA _23.sumNotAbundant;
        24, fun () -> sprintfA _24.run;
        25, fun () -> sprintfA _25.find1000;
        26, fun () -> sprintfA _26.longestRecurringCycle;
        27, fun () -> sprintfA _27.quadraticConsecutivePrimes;
        28, fun () -> sprintfA _28.sumNum;
        29, fun () -> sprintfA _29.getDistinctTerms;
        30, fun () -> sprintfA _30.sumOfSumOfFifthNumbers;
        31, fun () -> sprintfA _31.getCurrencyCombos;
        32, fun () -> sprintfA _32.panDigitalProduct;
        33, fun () -> sprintfA _33.cancelling;
        34, fun () -> sprintfA _34.numSumDigitFactorials;
        35, fun () -> sprintfA _35.circularPrime;
        36, fun () -> sprintfA _36.palindromicBase10and2Sum;
        37, fun () -> sprintfA _37.truncatablePrimes;
        39, fun () -> sprintfA _39.rightTriPerimeter;
        40, fun () -> sprintfA _40.positiveIntegerConcat;
        41, fun () -> sprintfA _41.panDigital;
        42, fun () -> sprintfA _42.triangleWords;
        43, fun () -> sprintfA _43.pandigitalDivisible;
        45, fun () -> sprintfA _45.triPentHex;
        46, fun () -> sprintfA _46.smallestOddCompositeNotSumOfPrimeTwiceSquare;
        47, fun () -> sprintfA _47.consequtivePrimes;
        48, fun () -> sprintfA _48.seriesEnd;
        49, fun () -> sprintfA _49.primeSequence;
        50, fun () -> sprintfA _50.sumOfConsequitivePrimes;
        52, fun () -> sprintfA _52.findSameDigits;
        53, fun () -> sprintfA _53.combinationGt1M;
        54, fun () -> sprintfA _54.pokerWinner;
        55, fun () -> sprintfA _55.lynchrels;
        56, fun () -> sprintfA _56.exponentialDigitSum;
        57, fun () -> sprintfA _57.sqrtTwoDigits;
        58, fun () -> sprintfA _58.primeDiagonals;
        59, fun () -> sprintfA _59.cypher;
        63, fun () -> sprintfA _63.powerDigits;
        69, fun () -> sprintfA _69.relativePrimeFunc;
        79, fun () -> sprintfA _79.findPasscode;
        81, fun () -> sprintfA _81.shortestDistance;
        92, fun () -> sprintfA _92.squareChainLoop;
        97, fun () -> sprintfA _97.bigPrime;
        98, fun () -> sprintfA _98.anagramSquares;
        99, fun () -> sprintfA _99.biggestNum;
        101, fun () -> sprintfA _101.sumOfFITsOfBOPs;
        112, fun () -> sprintfA _112.bouncy90;
        ]
    let problemDict = dict problems
    let sw = new System.Diagnostics.Stopwatch()
    printfn "starting"
    sw.Start()
    let result = problemDict.[43]()
    sw.Stop()
    printfn "%s" result
    printfn "done in %A" sw.Elapsed
    //Clipboard.SetText(result)
    Console.ReadKey() |> ignore
    0
@@ -0,0 +1,161 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProductVersion>8.0.30703</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{afd5b730-9ec9-4ef7-8ddb-95b36a0d1317}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>projecteuler</RootNamespace>
    <AssemblyName>projecteuler</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
    <Name>projecteuler</Name>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <Tailcalls>false</Tailcalls>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <WarningLevel>3</WarningLevel>
    <PlatformTarget>x86</PlatformTarget>
    <DocumentationFile>bin\Debug\projecteuler.XML</DocumentationFile>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <Tailcalls>true</Tailcalls>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <WarningLevel>3</WarningLevel>
    <PlatformTarget>x86</PlatformTarget>
    <DocumentationFile>bin\Release\projecteuler.XML</DocumentationFile>
  </PropertyGroup>
  <PropertyGroup>
    <MinimumVisualStudioVersion Condition="'$(MinimumVisualStudioVersion)' == ''">11</MinimumVisualStudioVersion>
  </PropertyGroup>
  <Import Project="$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets" Condition="Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')" />
  <Import Project="$(MSBuildExtensionsPath32)\..\Microsoft F#\v4.0\Microsoft.FSharp.Targets" Condition="(!Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')) And (Exists('$(MSBuildExtensionsPath32)\..\Microsoft F#\v4.0\Microsoft.FSharp.Targets'))" />
  <Import Project="$(MSBuildExtensionsPath32)\FSharp\1.0\Microsoft.FSharp.Targets" Condition="(!Exists('$(MSBuildExtensionsPath32)\..\Microsoft SDKs\F#\3.0\Framework\v4.0\Microsoft.FSharp.Targets')) And (!Exists('$(MSBuildExtensionsPath32)\..\Microsoft F#\v4.0\Microsoft.FSharp.Targets')) And (Exists('$(MSBuildExtensionsPath32)\FSharp\1.0\Microsoft.FSharp.Targets'))" />
  <ItemGroup>
    <Compile Include="common.fs" />
    <Compile Include="millerRabinPrimality.fs" />
    <Compile Include="Fraction.fs" />
    <Compile Include="11.fs" />
    <Content Include="11.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="12.fs" />
    <Compile Include="13.fs" />
    <Content Include="13.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="14.fs" />
    <Compile Include="17.fs" />
    <Compile Include="18.fs" />
    <Content Include="18.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Content Include="18_67.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="19_saturdays.fs" />
    <Compile Include="20.fs" />
    <Compile Include="21.fs" />
    <Compile Include="22.fs" />
    <Content Include="22_names.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="23.fs" />
    <Compile Include="24.fs" />
    <Compile Include="25.fs" />
    <Compile Include="26.fs" />
    <Compile Include="27.fs" />
    <Compile Include="28.fs" />
    <Compile Include="29.fs" />
    <Compile Include="30.fs" />
    <Compile Include="31.fs" />
    <Compile Include="32.fs" />
    <Compile Include="33_cancelling.fs" />
    <Compile Include="34.fs" />
    <Compile Include="35.fs" />
    <Compile Include="36.fs" />
    <Compile Include="37.fs" />
    <Compile Include="39.fs" />
    <Compile Include="40.fs" />
    <Compile Include="41.fs" />
    <Compile Include="42.fs" />
    <Content Include="42_words.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="43.fs" />
    <Compile Include="45.fs" />
    <Compile Include="46.fs" />
    <Compile Include="47.fs" />
    <Compile Include="48.fs" />
    <Compile Include="49.fs" />
    <Compile Include="50.fs" />
    <Compile Include="52.fs" />
    <Compile Include="53.fs" />
    <Compile Include="54.fs" />
    <Content Include="54_poker.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="55.fs" />
    <Compile Include="56.fs" />
    <Compile Include="57.fs" />
    <Compile Include="58.fs" />
    <Compile Include="59.fs" />
    <Content Include="59_cipher1.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="69.fs" />
    <Compile Include="63_power_digits.fs" />
    <Compile Include="79.fs" />
    <Content Include="79_keylog.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="81.fs" />
    <Content Include="81_matrix.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="92.fs" />
    <Compile Include="97.fs" />
    <Compile Include="98.fs" />
    <Content Include="98_words.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="99.fs" />
    <Content Include="99_base_exp.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="101.fs" />
    <Compile Include="112.fs" />
    <Compile Include="npr_sundaypuzzle_20120422.fs" />
    <Content Include="dist.female.first.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Content Include="dist.male.first.txt">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Compile Include="program.fs" />
  </ItemGroup>
  <ItemGroup>
    <Reference Include="mscorlib" />
    <Reference Include="FSharp.Core" />
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Numerics" />
    <Reference Include="System.Windows.Forms" />
  </ItemGroup>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
 	     Other similar extension points exist, see Microsoft.Common.targets.
 	<Target Name="BeforeBuild">
 	</Target>
 	<Target Name="AfterBuild">
 	</Target>
 	-->
 </Project>
@@ -0,0 +1,20 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2012
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "projecteuler", "projecteuler.fsproj", "{AFD5B730-9EC9-4EF7-8DDB-95B36A0D1317}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x86 = Debug|x86
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{AFD5B730-9EC9-4EF7-8DDB-95B36A0D1317}.Debug|x86.ActiveCfg = Debug|x86
 		{AFD5B730-9EC9-4EF7-8DDB-95B36A0D1317}.Debug|x86.Build.0 = Debug|x86
 		{AFD5B730-9EC9-4EF7-8DDB-95B36A0D1317}.Release|x86.ActiveCfg = Release|x86
 		{AFD5B730-9EC9-4EF7-8DDB-95B36A0D1317}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 EndGlobal
		`@@ -0,0 +1,3 @@`
							`$file = gc 11.txt`

							`$arr = New-Object int[][] 2000000`
		`@@ -0,0 +1 @@`
							79,59,12,2,79,35,8,28,20,2,3,68,8,9,68,45,0,12,9,67,68,4,7,5,23,27,1,21,79,85,78,79,85,71,38,10,71,27,12,2,79,6,2,8,13,9,1,13,9,8,68,19,7,1,71,56,11,21,11,68,6,3,22,2,14,0,30,79,1,31,6,23,19,10,0,73,79,44,2,79,19,6,28,68,16,6,16,15,79,35,8,11,72,71,14,10,3,79,12,2,79,19,6,28,68,32,0,0,73,79,86,71,39,1,71,24,5,20,79,13,9,79,16,15,10,68,5,10,3,14,1,10,14,1,3,71,24,13,19,7,68,32,0,0,73,79,87,71,39,1,71,12,22,2,14,16,2,11,68,2,25,1,21,22,16,15,6,10,0,79,16,15,10,22,2,79,13,20,65,68,41,0,16,15,6,10,0,79,1,31,6,23,19,28,68,19,7,5,19,79,12,2,79,0,14,11,10,64,27,68,10,14,15,2,65,68,83,79,40,14,9,1,71,6,16,20,10,8,1,79,19,6,28,68,14,1,68,15,6,9,75,79,5,9,11,68,19,7,13,20,79,8,14,9,1,71,8,13,17,10,23,71,3,13,0,7,16,71,27,11,71,10,18,2,29,29,8,1,1,73,79,81,71,59,12,2,79,8,14,8,12,19,79,23,15,6,10,2,28,68,19,7,22,8,26,3,15,79,16,15,10,68,3,14,22,12,1,1,20,28,72,71,14,10,3,79,16,15,10,68,3,14,22,12,1,1,20,28,68,4,14,10,71,1,1,17,10,22,71,10,28,19,6,10,0,26,13,20,7,68,14,27,74,71,89,68,32,0,0,71,28,1,9,27,68,45,0,12,9,79,16,15,10,68,37,14,20,19,6,23,19,79,83,71,27,11,71,27,1,11,3,68,2,25,1,21,22,11,9,10,68,6,13,11,18,27,68,19,7,1,71,3,13,0,7,16,71,28,11,71,27,12,6,27,68,2,25,1,21,22,11,9,10,68,10,6,3,15,27,68,5,10,8,14,10,18,2,79,6,2,12,5,18,28,1,71,0,2,71,7,13,20,79,16,2,28,16,14,2,11,9,22,74,71,87,68,45,0,12,9,79,12,14,2,23,2,3,2,71,24,5,20,79,10,8,27,68,19,7,1,71,3,13,0,7,16,92,79,12,2,79,19,6,28,68,8,1,8,30,79,5,71,24,13,19,1,1,20,28,68,19,0,68,19,7,1,71,3,13,0,7,16,73,79,93,71,59,12,2,79,11,9,10,68,16,7,11,71,6,23,71,27,12,2,79,16,21,26,1,71,3,13,0,7,16,75,79,19,15,0,68,0,6,18,2,28,68,11,6,3,15,27,68,19,0,68,2,25,1,21,22,11,9,10,72,71,24,5,20,79,3,8,6,10,0,79,16,8,79,7,8,2,1,71,6,10,19,0,68,19,7,1,71,24,11,21,3,0,73,79,85,87,79,38,18,27,68,6,3,16,15,0,17,0,7,68,19,7,1,71,24,11,21,3,0,71,24,5,20,79,9,6,11,1,71,27,12,21,0,17,0,7,68,15,6,9,75,79,16,15,10,68,16,0,22,11,11,68,3,6,0,9,72,16,71,29,1,4,0,3,9,6,30,2,79,12,14,2,68,16,7,1,9,79,12,2,79,7,6,2,1,73,79,85,86,79,33,17,10,10,71,6,10,71,7,13,20,79,11,16,1,68,11,14,10,3,79,5,9,11,68,6,2,11,9,8,68,15,6,23,71,0,19,9,79,20,2,0,20,11,10,72,71,7,1,71,24,5,20,79,10,8,27,68,6,12,7,2,31,16,2,11,74,71,94,86,71,45,17,19,79,16,8,79,5,11,3,68,16,7,11,71,13,1,11,6,1,17,10,0,71,7,13,10,79,5,9,11,68,6,12,7,2,31,16,2,11,68,15,6,9,75,79,12,2,79,3,6,25,1,71,27,12,2,79,22,14,8,12,19,79,16,8,79,6,2,12,11,10,10,68,4,7,13,11,11,22,2,1,68,8,9,68,32,0,0,73,79,85,84,79,48,15,10,29,71,14,22,2,79,22,2,13,11,21,1,69,71,59,12,14,28,68,14,28,68,9,0,16,71,14,68,23,7,29,20,6,7,6,3,68,5,6,22,19,7,68,21,10,23,18,3,16,14,1,3,71,9,22,8,2,68,15,26,9,6,1,68,23,14,23,20,6,11,9,79,11,21,79,20,11,14,10,75,79,16,15,6,23,71,29,1,5,6,22,19,7,68,4,0,9,2,28,68,1,29,11,10,79,35,8,11,74,86,91,68,52,0,68,19,7,1,71,56,11,21,11,68,5,10,7,6,2,1,71,7,17,10,14,10,71,14,10,3,79,8,14,25,1,3,79,12,2,29,1,71,0,10,71,10,5,21,27,12,71,14,9,8,1,3,71,26,23,73,79,44,2,79,19,6,28,68,1,26,8,11,79,11,1,79,17,9,9,5,14,3,13,9,8,68,11,0,18,2,79,5,9,11,68,1,14,13,19,7,2,18,3,10,2,28,23,73,79,37,9,11,68,16,10,68,15,14,18,2,79,23,2,10,10,71,7,13,20,79,3,11,0,22,30,67,68,19,7,1,71,8,8,8,29,29,71,0,2,71,27,12,2,79,11,9,3,29,71,60,11,9,79,11,1,79,16,15,10,68,33,14,16,15,10,22,73
		`@@ -0,0 +1,50 @@`
							`319`
							`680`
							`180`
							`690`
							`129`
							`620`
							`762`
							`689`
							`762`
							`318`
							`368`
							`710`
							`720`
							`710`
							`629`
							`168`
							`160`
							`689`
							`716`
							`731`
							`736`
							`729`
							`316`
							`729`
							`729`
							`710`
							`769`
							`290`
							`719`
							`680`
							`318`
							`389`
							`162`
							`289`
							`162`
							`718`
							`729`
							`319`
							`790`
							`680`
							`890`
							`362`
							`319`
							`760`
							`316`
							`729`
							`380`
							`319`
							`728`
							`716`
		`@@ -0,0 +1 @@`
							7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450
		`@@ -0,0 +1,2 @@`
							`$assemblyName = gci .\Oyster.IntX.dll \| % {$_.FullName }`
							`[System.Reflection.Assembly]::LoadFile($assemblyName)`