Question

I want to solve this excercise: http://code.google.com/codejam/contest/351101/dashboard#s=p0 using F#.

I am new to functional programming and F# but I like the concept and the language a lot. And I love the codejam excercise too it looks so easy but real life. Could somebody point me out a solution?

At the moment I have written this code which is just plain imperative and looks ugly from the functional perspective:

(*
    C - Credit
    L - Items
    I - List of Integer, wher P is single integer

    How does the data look like inside file
    N
    [...
    * Money
    * Items in store
    ...]
*)

    let lines = System.IO.File.ReadAllLines("../../../../data/A-small-practice.in")
    let CBounds c = c >= 5 && c <= 1000
    let PBounds p = p >= 1 && p <= 1000

    let entries = int(lines.[0]) - 1
    let mutable index = 1   (* First index is how many entries*)
    let mutable case = 1

    for i = 0 to entries do
        let index = (i*3) + 1
        let C = int(lines.[index])
        let L = int(lines.[index+1])
        let I = lines.[index+2]    
        let items = I.Split([|' '|]) |> Array.map int    
        // C must be the sum of some items

        // Ugly imperative way which contains duplicates
        let mutable nIndex = 0
        for n in items do
            nIndex <- nIndex + 1
            let mutable mIndex = nIndex
            for m in items.[nIndex..] do            
                mIndex <- mIndex + 1
                if n + m = C then do
                    printfn "Case #%A: %A %A" case nIndex mIndex
                    case <- case + 1

I would like to find out items which add up to C value but not in a usual imperative way – I want functional approach.

Answer 1

You don’t specify how you would solve the problem, so it’s hard to give advices.

Regarding reading inputs, you can express it as a series of transformation on Seq. High-order functions from Seq module are very handy:

let data = 
   "../../../../data/A-small-practice.in"
   |> System.IO.File.ReadLines
   |> Seq.skip 1
   |> Seq.windowed 3
   |> Seq.map (fun lines -> let C = int(lines.[0])
                            let L = int(lines.[1])
                            let items = lines.[2].Split([|' '|]) |> Array.map int
                            (C, L, items))

UPDATE:

For the rest of your example, you could use sequence expression. It is functional enough and easy to express nested computations:

 let results = 
     seq { 
          for (C, _, items) in data do
            for j in 1..items.Length-1 do
              for i in 0..j-1 do
                if items.[j] + items.[i] = C then yield (i, j)
     }

 Seq.iteri (fun case (i, j) -> printfn "Case #%A: %A %A" case i j) results