Разделение списка элементов на два списка нечетных и четных проиндексированных элементов

Реализация без переполнения стека:

let splitList list = List.foldBack (fun x (l,r) -> x::r, l) list ([],[])

Если вы имеете в виду нечетные и четные значения для позиций элементов, вот решение (без хвостовой рекурсии):

let rec splitList = function
    | [] -> [], []
    | [x]-> [x], []
    | x1::x2::xs -> let xs1, xs2 = splitList xs
                    x1::xs1, x2::xs2

Вот простое нерекурсивное решение:

let splitList ll =
    ll
    |> List.mapi (fun i x -> (i % 2 = 0, x))
    |> List.partition fst
    |> fun (odd,even) -> [List.map snd odd, List.map snd even];;

val splitList : 'a list -> 'a list list

Применив его к вашему образцу, он дает именно то, что вы хотели:

splitList [1;2;4;6;7;9];;

val it : int list list = [[1; 4; 7]; [2; 6; 9]]

Похоже, что это то, к чему вы стремились, и это действительно хороший способ сделать это, поскольку он хвостовой рекурсивный.

let splitList items =
  let rec splitOdd odds evens = function
    | [] -> odds, evens
    | h::t -> splitEven (h::odds) evens t
  and splitEven odds evens = function
    | [] -> odds, evens
    | h::t -> splitOdd odds (h::evens) t
  let odds, evens = splitOdd [] [] items
  List.rev odds, List.rev evens

Другой (менее эффективный) вариант

let splitList xs = 
    let odd, even =
        xs
        |> List.zip [ 1 .. (List.length xs) ]
        |> List.partition (fun (i, _) -> i % 2 <> 0)
    [ odd |> List.map snd; even |> List.map snd ]

Если вы не хотите создавать временные списки, рассмотрите возможность использования последовательностей:

let splitListSeq xs =
    xs
    |> Seq.mapi (fun i x -> (i % 2 = 0, x))
    |> Seq.groupBy (fun (b, _) -> b)
    |> Seq.map snd
    |> Seq.map ((Seq.map snd) >> Seq.toList)
    |> Seq.toList

Еще одна, похожая на версию Даниила:

let splitListRec xs =
    let rec loop l r = function
        | []      -> [l; r]
        | x::[]   -> [x::l; r]
        | x::y::t -> loop (x::l) (y::r) t
    loop [] [] xs |> List.map List.rev

Похоже, вы хотите List.partition ‹'T> (http://msdn.microsoft.com/en-us/library/ee353782.aspx). Эта функция принимает предикат и список и возвращает пару (2-кортеж), где первый элемент - это все элементы, прошедшие ваш тест, а второй - все элементы, которые не прошли тест. Итак, вы можете классифицировать шансы и эвенты с помощью:

List.partition odd [1;2;4;6;7;9]

Если вам действительно нужен список, вы можете использовать fst и snd, чтобы извлечь элементы из кортежа и поместить их в список.

Удачи!

Мои 2 ¢ в OCaml, так как баунти еще открыт.

Может быть, вы могли бы намекнуть, что вы хотите. Элегантность? FP? Рекурсия хвоста? Представление?

Изменить:

Я удалил более длинный раствор. Для работы List.partition отсутствовал предикат. Вот:

let so_split lst = 
  let flag = ref false in
  List.partition (fun e -> flag := not !flag; !flag) lst

Доработок какие-нибудь? Тестирование решения:

# so_split [1;2;4;6;7;9];;
- : int list * int list = ([1; 4; 7], [2; 6; 9])

Для полноты картины приведу скучное и более настоятельное решение:

let splitList (list:int list) =
    let odds = [for i in 0..list.Length-1 do
                  if i%2=1 then
                    yield list.[i]]
    let evens = [for i in 0..list.Length-1 do
                    if i%2=0 then
                        yield list.[i]]
    odds,evens