let getPrimes n = 
    let p = Array.create (n+1) true
    for i = 2 to int(sqrt(float n)) do
        if p.[i] then
            for k = 2 to n/i do
                p.[k*i] <- false
    [ for i = 2 to n do
        if p.[i] then yield i ]
        
let primes = getPrimes 1000000

let isPrime n = 
    match n with
    |1 -> false
    |n ->
        primes
        |> Seq.takeWhile (fun k -> k*k <= n)
        |> Seq.exists ( fun k -> n%k = 0 )
        |> not

// from Jon Harrop http://stackoverflow.com/questions/1526046/f-permutations

let rec distribute e = function
  | [] -> [[e]]
  | x::xs' as xs -> (e::xs)::[for xs in distribute e xs' -> x::xs]

let rec permute = function
  | [] -> [[]]
  | e::xs -> List.collect (distribute e) (permute xs)
  
let rec loop k =
    permute [1 .. k]
    |> List.map (fun lst -> lst |> List.map (string) |> String.Concat) 
    |> List.map int
    |> List.filter isPrime
    |> function
       | [] -> loop (k-1)
       | lst -> List.max lst
    
loop 9

open System.IO
open System.Text.RegularExpressions

let file = __SOURCE_DIRECTORY__ + "/txt/p042.txt"

let text = File.ReadAllText(file)

let score (s:string) =
    s |> Seq.toArray
      |> Array.sumBy (fun c -> int c - 64)

let triNumbers = 
    Seq.initInfinite (fun n -> n*(n+1)/2)
    |> Seq.skip 1

let isTri n =
    triNumbers
    |> Seq.find (fun k -> k>=n)
    |> (=) n

[for w in Regex.Matches(text, "[A-Z]+") -> w.Value]
|> List.map score
|> List.filter isTri
|> List.length

let rec distribute e = function
  | [] -> [[e]]
  | x::xs' as xs -> (e::xs)::[for xs in distribute e xs' -> x::xs]

let rec permute = function
  | [] -> [[]]
  | e::xs -> List.collect (distribute e) (permute xs)

let test (n:string) =
    n.[0] <> '0' &&
    int (n.[1..3]) % 2 = 0 &&
    int (n.[2..4]) % 3 = 0 &&
    int (n.[3..5]) % 5 = 0 &&
    int (n.[4..6]) % 7 = 0 &&
    int (n.[5..7]) % 11 = 0 &&
    int (n.[6..8]) % 13 = 0 &&
    int (n.[7..9]) % 17 = 0 

[ 0 .. 9 ]
|> List.map string
|> permute
|> List.map (String.Concat)
|> List.filter test
|> List.sumBy (int64)

let pentagonals = 
    Seq.initInfinite (fun i -> int64 i*(3L*int64 i-1L)/2L) 
    |> Seq.skip 1 
    |> Seq.takeWhile (fun n -> n < 10000000L) 
    |> set

// assuming that pj and pk are under 10M

pentagonals 
|> Seq.collect (fun j -> pentagonals |> Seq.map (fun k -> (j,k)))
|> Seq.filter (fun (j,k) -> pentagonals |> Set.contains (j+k))
|> Seq.filter (fun (j,k) -> pentagonals |> Set.contains (k-j))
|> Seq.map (fun (j,k) -> k-j)
|> Seq.min

let maxN = 10000000000L

let hexs = 
    Seq.initInfinite (fun i -> int64 i*(2L*int64 i-1L)) 
    |> Seq.skipWhile (fun n -> n <= 40755L) 
    |> Seq.takeWhile (fun n -> n < maxN) 
    |> set
let pents = 
    Seq.initInfinite (fun i -> int64 i*(3L*int64 i-1L)/2L) 
    |> Seq.skipWhile (fun n -> n <= 40755L) 
    |> Seq.takeWhile (fun n -> n < maxN) 
    |> set
let tris = 
    Seq.initInfinite (fun i -> int64 i*(int64 i+1L)/2L) 
    |> Seq.skipWhile (fun n -> n <= 40755L) 
    |> Seq.takeWhile (fun n -> n < maxN) 
    |> set

hexs
|> Set.intersect pents
|> Set.intersect tris
|> Seq.head

let isSquare n = 
    let t = int (sqrt (float n))
    n = t * t
    
let getPrimes n = 
    let p = Array.create (n+1) true
    for i = 2 to int(sqrt(float n)) do
        if p.[i] then
            for k = 2 to n/i do
                p.[k*i] <- false
    [ for i = 2 to n do
        if p.[i] then yield i ]
        
let primes = getPrimes 1000000

let isPrime n = 
    match n with
    |1 -> false
    |n ->
        primes
        |> Seq.takeWhile (fun k -> k*k <= n)
        |> Seq.exists ( fun k -> n%k = 0 )
        |> not
        
let valid n =
    primes
    |> Seq.takeWhile (fun k -> k < n)
    |> Seq.tryFind (fun k -> (n - k) / 2 |> isSquare)
    |> fun k -> k.IsSome

Seq.initInfinite (fun k -> k*2+9)
|> Seq.filter (fun k -> not(isPrime k))
|> Seq.find (fun k -> not (valid k))

let factors n = Euler.FactorInteger n |> List.length

let len = 4

let rec loop (n:int64) (prior: bool list) =
    let r = 
        (factors n = len) :: prior
        |> Seq.take len
    if r |> Seq.forall (fun t -> t=true) then
        n - int64 len + 1L
    else
       loop (n+1L) (r |> Seq.toList)
       
loop 644L (List.init len (fun _ -> false))

[ 1 .. 1000 ]
|> Seq.sumBy (fun i -> pown (bigint i) i)
|> fun n -> n%(pown 10I 10)

open System.Collections
 
let rec distribute e = function
    | [] -> [[e]]
    | x::xs' as xs -> (e::xs)::[for xs in distribute e xs' -> x::xs]
 
let rec permute = function
    | [] -> [[]]
    | e::xs -> List.collect (distribute e) (permute xs)
 
let rec comb n l =
    match n, l with
    | 0, _ -> [[]]
    | _, [] -> []
    | k, (x::xs) -> List.map ((@) [x]) (comb (k-1) xs) @ comb k xs
 
let getPrimes n = 
    let p = Array.create (n+1) true
    for i = 2 to int(sqrt(float n)) do
        if p.[i] then
            for k = 2 to n/i do
                p.[k*i] <- false
    [ for i = 2 to n do
        if p.[i] then yield i ]
        
let primes = getPrimes 10000

let isPrime n = 
    match n with
    |1 -> false
    |n ->
        primes
        |> Seq.takeWhile (fun k -> k*k <= n)
        |> Seq.exists ( fun k -> n%k = 0 )
        |> not
 
// define function to get the 4-digit prime permutations of a number
let getPrimePermutations n =
    let digitsStr = string n |> Seq.toArray |> Array.map string
    Array.toList digitsStr
    |> permute
    |> Seq.distinct
    |> Seq.map (fun chars -> int(chars |> List.reduce (+)))
    |> Seq.filter (fun x -> x >= 1000 && isPrime x)
    |> Seq.sort
    |> Seq.toList
 
primeNumbers
|> List.map getPrimePermutations
|> List.filter (fun l -> l |> List.length >= 3)
|> Seq.distinct
|> Seq.toList
|> List.map (fun l -> comb 3 l |> List.filter (fun x -> x.[1] - x.[0] = x.[2] - x.[1]))
|> List.filter (fun l -> l |> List.length > 0)
|> Seq.nth 1 // skip the first result (known)
|> List.map (String.Concat)
|> Seq.nth 0

let getPrimes n = 
    let p = Array.create (n+1) true
    for i = 2 to int(sqrt(float n)) do
        if p.[i] then
            for k = 2 to n/i do
                p.[k*i] <- false
    [ for i = 2 to n do
        if p.[i] then yield i ]
        
let primes = getPrimes 1000000

let isPrime n = 
    match n with
    |1 -> false
    |n ->
        primes
        |> Seq.takeWhile (fun k -> k*k <= n)
        |> Seq.exists ( fun k -> n%k = 0 )
        |> not
        
let maxPrime skip =
    primes
    |> Seq.skip skip
    |> Seq.scan (fun state n -> ((1 + fst state), (n + snd state))) (0,0)
    |> Seq.takeWhile (fun n -> (snd n)<1000000)
    |> Seq.filter (fun n -> isPrime(snd n))
    |> Seq.maxBy fst
    
let rec loop k result =
    let test = 
        primes
        |> Seq.skip k
        |> Seq.take (fst result)
        |> Seq.sum
    if test > 1000000 then
        snd result
    else
        [ maxPrime k; result ]
        |> List.maxBy fst
        |> fun r -> loop (k+1) r
    
loop 1 (maxPrime 0)