tags:

views:

39

answers:

1

I'm trying to make a recursive function to get the transpose of a list of lists, n x p to p x n. But i'm unable to do so. I've been able to make a function to transpose a 3 x n list of lists to an n x 3 one:

let rec drop1 list=
    [(match (List.nth list 0) with [] -> [] | a::b -> b);
     (match (List.nth list 1) with [] -> [] | a::b -> b);
     (match (List.nth list 2) with [] -> [] | a::b -> b);]

let rec transpose list=
    if List.length (List.nth list 0) == 0 then []
    else [(match (List.nth list 0) with [] -> 0 | a::b -> a);
          (match (List.nth list 1) with [] -> 0 | a::b -> a);
          (match (List.nth list 2) with [] -> 0 | a::b -> a)]
         :: transpose (drop1 list)

But I'm not able to generalize it. I'm surely thinking in the wrong direction. Is this generalizable? Is there a better solution? Please help.

+5  A: 
let rec transpose list = match list with
| []             -> []
| []   :: xss    -> transpose xss
| (x::xs) :: xss ->
    (x :: List.map List.hd xss) :: transpose (xs :: List.map List.tl xss)
sepp2k
+1, Wow! I was not aware of List.map function. The manual says its not tail-recursive. What effect can that have if I use this in a bigger code?
lalli
@lalli: For very large lists it can cause a stack overflow. In that case, you should use `List.rev_map` instead and then go through the lists at the end and reverse them. Note however that my definition of `transpose` is also not tail recursive (neither is yours).
sepp2k
You should not worry about tail-recursivity at first; try to have a simple and clear implementation.Using a "transpose" function on ('a list list) with very big lists is probably a very bad idea anyway. If you have lots of data, an other data structure (eg. a matrix indexed by (int * int), which has a constant-time `transpose` function) is probably more appropriate.
gasche