worky.fs

type symbol =  Plus of int * symbol | Minus of int * symbol | Join of int * symbol |End

let merge (i1: int) (i2:int)  = (int)(sprintf "%d%d" i1 i2)

let rec flatten (n: int) (s: symbol) =
    match s with
        | Join (a,t) -> flatten (merge n a) t
        | _ -> (n,s)
let rest (symbol:symbol) = 
    match symbol with
            | Plus (u,v) -> (u,v)  
            | Minus (u,v) -> (-u,v) 
            | End -> (0, End) 
            | _ -> raise (System.Exception "shoud not happen after flatten")

let rec calc (n: int) (s: symbol) : int =
    let (x,t) = flatten n s
    match t with
        | End -> x
        | Plus (a,b) -> x+ calc a b
        | Minus (a,b) -> let (foo,bar) = flatten a b
                         let (baz,boo) = rest bar 
                         x - foo + calc baz boo 
        | Join _ -> raise (System.Exception "shoud not happen after flatten")

let rec genSolutions (s:int) (stopp: int) = seq {
    if s = stopp then yield (s, End)
    else for i in genSolutions (s+1) stopp do
             yield (s, Plus i)
             yield (s, Minus i)
             yield (s, Join i)
}

let rec prettyPrint (i: int, s:symbol) :string =
    match s with
        | End  -> sprintf "%d" i 
        | Join (n,t) -> sprintf "%d" i + prettyPrint (n,t)
        | Plus (n,t) -> sprintf "%d" i + "+" + prettyPrint (n,t)
        | Minus (n,t) -> sprintf "%d" i + "-" + prettyPrint (n,t)

genSolutions 1 9 |> Seq.filter (fun (x,y) -> 100 = calc x y) |> 
    Seq.map((prettyPrint)) |> Seq.distinct |> Seq.toList |> printfn "%A"