The second problem from the Recursive subdomain is printing Pascal's Triangle for given n.

Pascal's triangle is named after famous French mathematician from XVII century, Blaise Pascal. His findings on the properties of this numerical construction were published in this book, in 1665. Year before Great Fire of London.

The first row of the triangle is just one. (N+1)th row is constructed from Nth row by prepending and appending the sums of pairs from the Nth row with 1s:

row(0) =     1
row(1) =    1 1
row(2) =   1 2 1
row(3) =  1 3 3 1
row(4) = 1 4 6 4 1
row(n+1) = 1 (row(n)[0]+row(n)[1]) (row(n)[1]+row(n)[2]) ... 1

The k-th element of the n-th row can be calculated by n!/(k! (n-k)!) so the straightforward solution is just a single for with a factorial routine:

let rec f n =
    match n with | 0 | 1 -> 1 | _ -> n * f (n-1)
let line n =
  seq { for k in 0..n do yield ((f n) / ((f k) * f (n-k))) }

This solution works well for the test data but it is a bit inefficient (to be precise, its complexity O(n^2)) Multiplication is quite heavy and there is definitely room for improvements. For example, calculating the factorials can be replaced with lookup from pre-build table.

open System

let buildFactorialTable n =
  let rec build v i =
    seq { if i <= n then
            yield (i * v)
            yield! build (i * v) (i + 1) }
  (1 :: (build 1 1 |> Seq.toList)) |> List.toArray

let line (ft : int array) n =
  seq { for k in 0..n do yield (ft.[n] / ((ft.[k]) * (ft.[n-k]))) }

[<EntryPoint>]
let main argv =
  let n = Console.ReadLine() |> int
  let factorialTable = buildFactorialTable n
  for i in 0..(n-1) do
    printfn "%s"  (String.Join (" ", line factorialTable i |> Seq.map string))
  0 // return an integer exit code

Although it also works well, it only can calculate a few lines of the triangle. This is due to fact that factorial grows very quickly.

So the best solution is to generate next line directly from the previous:

open System

let lines n =
  let rec build (prev : int list) i =
    [ if i < n then
        let line = [ yield 1
                     for p in Seq.pairwise prev do
                       yield (fst p) + (snd p)
                     yield 1 ]
        yield line
        yield! build line (i+1) ]
  [ yield [1]; yield! build [1] 1 ]

[<EntryPoint>]
let main argv =
  let n = Console.ReadLine() |> int
  lines n
  |> Seq.iter (fun line -> printfn "%s" (String.Join (" ", line |> Seq.map string)))
  0 // return an integer exit code