Разделяне на списък с елементи на два списъка с нечетни и четни индексирани елементи

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

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