数组的OCaml zip元素2乘2

我需要检查数组在OCaml中是否正确排序

因此，我想将角色按2-2进行分组，然后进行折叠操作，比较它们

然而，我不知道如何将它们分组

在Scala中，它看起来像这样：

val k = Array(1, 2, 3, 4)
k.zip(k.tail)

# a2pairs [| 1;2;3;4 |];;
- : (int * int) list = [(1, 2); (2, 3); (3, 4)]

---

知道在OCaml中会是什么样子吗？

使用

Array.init

函数创建一个新数组，并用对填充它，例如

let zip xs ys = Array.init (Array.length xs) (fun i -> x.(i),y.(i))

然而，我不推荐这种方法。如果可以使用递归函数轻松地表达算法，则没有理由创建中间数据结构

如果您需要将array

xs

与array

ys

进行比较，那么只需执行

xs=ys

看起来，您不希望创建两个数组的zip，而是从数组中提取连续元素对，下面介绍如何使用

array.init

：

let zip_with_tail xs = match Array.length xs with
  | 0 | 1 -> [| |]
  | n -> Array.init (n-1) (fun i -> xs.(i),xs.(i+1))

将其与不使用中间数据结构的

is_sorted

函数进行比较：

让我们用x排序=
让rec有序i=i=0 | | xs.（i-1）true
|n->已订购（n-1）

decoration/process/undecorate样式可以很好地处理惰性序列，在擅长去叶的编译器中。例如在哈斯克尔。或者使用已经非常慢的语言，不需要麻烦。 我不确定Scala，他们的数组是否懒惰。在任何情况下，OCaml数组都是一个具体的数据结构，OCaml编译器不会对其进行优化（而且不应该——数组的语义不允许这样做）。但是，这种编程风格仍然适用于OCaml。您可以使用

Core

库，它提供了一个名为

Sequence

的惰性容器。使用它，您可以以与Scala相同的方式轻松定义带尾的

zip\u

：

 let zip_with_tail xs = Sequence.(zip xs (drop xs 1))

以下是一个例子：

# let xs = Sequence.of_list [1;2;3;4;5;6];;
val xs : int Core_kernel.Std.Sequence.t = {1, 2, 3, 4, 5, 6}
# zip_with_tail xs;;
- : (int * int) Core_kernel.Std.Sequence.t =
{(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)}

因此，您可以很好地定义排序的

：

let is_sorted xs = zip_with_tail xs |>
                   Sequence.for_all ~f:(fun (x,y) -> x <= y)

let is_sorted xs=zip_with_tail xs>
Sequence.for_all~f:（fun（x，y）->x使用
Array.init
函数创建一个新数组并用对填充，例如

let zip xs ys = Array.init (Array.length xs) (fun i -> x.(i),y.(i))

但是，我不推荐这种方法。如果你能用递归函数轻松地表达你的算法，就没有理由创建一个中间数据结构

如果您需要将array
xs
与array
ys
进行比较，那么只需执行
xs=ys

看起来，您不希望创建两个数组的zip，而是从数组中提取连续元素对，下面介绍如何使用
array.init
：

let zip_with_tail xs = match Array.length xs with
  | 0 | 1 -> [| |]
  | n -> Array.init (n-1) (fun i -> xs.(i),xs.(i+1))

将其与不使用中间数据结构的
is_sorted
函数进行比较：


让我们用x排序=
让rec有序i=i=0 | | xs.（i-1）true
|n->已订购（n-1）

decoration/process/undecorate样式适用于惰性序列，适用于擅长于去叶的编译器。例如，在Haskell中。或者在已经非常慢的语言中，不需要麻烦。
我不确定Scala是否懒惰。在任何情况下，OCaml数组是一个具体的数据结构，OCaml编译器不会对其进行优化（而且不应该——数组的语义不允许这样做）。但是，这种编程风格在OCaml中仍然适用。您可以使用
核心
库，该库提供了一个名为
序列
的惰性容器。使用该容器，您可以用与Scala中相同的方式轻松定义
带尾的压缩包
：

 let zip_with_tail xs = Sequence.(zip xs (drop xs 1))

以下是一个例子：

# let xs = Sequence.of_list [1;2;3;4;5;6];;
val xs : int Core_kernel.Std.Sequence.t = {1, 2, 3, 4, 5, 6}
# zip_with_tail xs;;
- : (int * int) Core_kernel.Std.Sequence.t =
{(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)}

因此，您可以很好地定义排序的
：

let is_sorted xs = zip_with_tail xs |>
                   Sequence.for_all ~f:(fun (x,y) -> x <= y)

let is_sorted xs=zip_with_tail xs>
Sequence.for_all~f:（fun（x，y）->x这将使数组成为相邻元素对的列表：

let a2pairs a =
    let mkpr x (prevo, prs) =
        match prevo with
        | None -> (Some x, [])
        | Some y -> (Some x, (x, y) :: prs)
    in
    snd (Array.fold_right mkpr a (None, []))

它的工作原理如下：

val k = Array(1, 2, 3, 4)
k.zip(k.tail)

# a2pairs [| 1;2;3;4 |];;
- : (int * int) list = [(1, 2); (2, 3); (3, 4)]

但我同意@ivg的观点，即创建这种中间数据结构可能不值得。您可以使用几乎相同的函数来比较相邻元素，并累积一个布尔值，说明它们是否都在正确的顺序中。
这将使数组成为相邻元素对的列表：

let a2pairs a =
    let mkpr x (prevo, prs) =
        match prevo with
        | None -> (Some x, [])
        | Some y -> (Some x, (x, y) :: prs)
    in
    snd (Array.fold_right mkpr a (None, []))

它的工作原理如下：

val k = Array(1, 2, 3, 4)
k.zip(k.tail)

# a2pairs [| 1;2;3;4 |];;
- : (int * int) list = [(1, 2); (2, 3); (3, 4)]

但我同意@ivg的观点，即创建这种中间数据结构可能不值得。您可以使用几乎相同的函数来比较相邻的元素，并累积一个布尔值，表示它们是否都在正确的顺序中。
（我认为只有一个数组，OP希望将每个元素与下一个元素进行比较。）我想你是对的！是的，现在scala代码对我来说是有意义的。我会更新帖子。（我认为只有一个数组，OP想比较每个元素和下一个。）我想你是对的！是的，现在scala代码对我来说是有意义的。我会更新帖子。