将项目列表拆分为奇数和偶数索引项目的两个列表

Question

我想做一个函数，它接受一个列表并返回两个列表：第一个包含所有奇数项，第二个包含每个偶数项。

例如，给定[1;2;4;6;7;9]，我想返回[ [1;4;7] ; [2;6;9] ]。

到目前为止，我已经写了这篇文章，但我不知道如何进步。

let splitList list =
    let rec splitOdd oList list1 list2 =
        match oList with
        | [] -> []
        | head :: tail -> splitEven tail (list1::head) list2
    and splitEven oList list1 list2 =
        match oList with
        | [] -> []
        | head :: tail -> splitOdd tail list1 (list2::head)
    splitOdd list [] []

Answer 1

不堆栈溢出的实现：

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

Answer 2

如果您指的是项目位置的奇数和偶数值，这是一个（非尾递归）解决方案：

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

Answer 3

这是一个简单的非递归解决方案：

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]]

Answer 4

看起来这就是你想要的，这确实是一种很好的方法，因为它是尾递归的。

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

Answer 5

另一个（效率较低的）选项

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

Answer 6

我在 OCaml 中的 2 美分，因为仍有悬赏。

也许你可以给我们一个提示你想要什么。优雅？ 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])

Answer 7

听起来你想要 List.partition (http://msdn.microsoft.com/en-us/library/ee353782.aspx)。此函数接受一个谓词和一个列表，并将返回一个对（2 元组），其中第一个元素是所有通过测试的元素，第二个是所有未通过测试的元素。因此，您可以使用以下方式对赔率和偶数进行分类：

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

如果您真的想要一个列表，您可以使用fst 和snd 从元组中提取元素并将它们放入列表中。

祝你好运！

Answer 8

为了完整起见，这里是一个无聊的、更命令式的解决方案：

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