fork download

copy

open System
open System.Collections.Generic 
 
let recip =
  let cache = Dictionary<_, _>()
  fun n m ->
      if cache.ContainsKey( (n, m) ) then cache.[ (n, m) ]
      else 
        let res = List.find (fun a -> n * a % m = 1) [1..(m - 1)]
        cache.[ (n, m) ] <- res
        res
 
let rec binomialMod n k m  =
  if k = 1 then n % m
  else 
    let prev = binomialMod (n - 1) (k - 1) m
    prev * n * (recip k m) % m
 
let isPrime n =
  List.exists (fun i -> n % i = 0) [2..(n - 1)]
 
let primes = List.filter isPrime [1000..5000]
let binomials = List.map (fun m -> binomialMod (int (1000000000000L % (int64 m))) 1000000000) primes
 
let solution =
  let rec recSolution (binomials:(int' list)) product chosen =
    seq {
      if binomials.IsEmpty then 0
      else if chosen = 3 then yield product
      else 
        yield! recSolution binomials.Tail product chosen
        yield recSolution binomials.Tail (product * binomials.Head) (chosen + 1)
    }
  Seq.sum(recSolution binomials 1 0)
 
Console.WriteLine solution
 

/home/Vm3v7k/prog.fs(26,35): error FS0039: The type 'int'' is not defined

/home/Vm3v7k/prog.fs(26,35): error FS0039: The type 'int'' is not defined

/home/Vm3v7k/prog.fs(28,10): error FS0072: Lookup on object of indeterminate type based on information prior to this program point. A type annotation may be needed prior to this program point to constrain the type of the object. This may allow the lookup to be resolved.

/home/Vm3v7k/prog.fs(28,33): warning FS0020: This expression should have type 'unit', but has type 'int'. Use 'ignore' to discard the result of the expression, or 'let' to bind the result to a name.

/home/Vm3v7k/prog.fs(31,28): error FS0072: Lookup on object of indeterminate type based on information prior to this program point. A type annotation may be needed prior to this program point to constrain the type of the object. This may allow the lookup to be resolved.

/home/Vm3v7k/prog.fs(32,15): error FS0001: Type mismatch. Expecting a
    'a    
but given a
    seq<'a>    
The resulting type would be infinite when unifying ''a' and 'seq<'a>'

Standard output is empty