Question

我想创建一个带有签名seq<#seq<'a>> ->seq<seq<'a>>的函数，它的作用类似于Zip方法，它采用任意数量的输入序列（而不是Zip2和Zip3中的2或3）并返回一个序列结果是序列而不是元组。

即，给出以下输入：

[[1;2;3];
 [4;5;6];
 [7;8;9]]

它将返回结果： [[1; 4; 7]; [2; 5; 8]; [3; 6; 9]]

除了序列而不是列表。

我对F＃很新，但是我创建了一个能够满足我想要的功能，但我知道它可以改进。这不是尾递归，似乎它可能更简单，但我不知道如何。我还没有找到一种很好的方式来获得我想要的签名（接受，例如，int list list作为输入）而没有第二个功能。

我知道这可以直接使用枚举器来实现，但我有兴趣以功能方式进行。

这是我的代码：

let private Tail seq = Seq.skip 1 seq
let private HasLengthNoMoreThan n = Seq.skip n >> Seq.isEmpty

let rec ZipN_core = function
    | seqs when seqs |> Seq.isEmpty -> Seq.empty
    | seqs when seqs |> Seq.exists Seq.isEmpty -> Seq.empty
    | seqs ->
        let head = seqs |> Seq.map Seq.head
        let tail = seqs |> Seq.map Tail |> ZipN_core
        Seq.append (Seq.singleton head) tail

// Required to change the signature of the parameter from seq<seq<'a> to seq<#seq<'a>>
let ZipN seqs = seqs |> Seq.map (fun x -> x |> Seq.map (fun y -> y)) |> ZipN_core

Answer 1

let zipn items = items |> Matrix.Generic.ofSeq |> Matrix.Generic.transpose

或者，如果你真的想自己写一下：

let zipn items = 
  let rec loop items =
    seq {
      match items with
      | [] -> ()
      | _ -> 
        match zipOne ([], []) items with
        | Some(xs, rest) -> 
          yield xs
          yield! loop rest
        | None -> ()
    }
  and zipOne (acc, rest) = function
    | [] -> Some(List.rev acc, List.rev rest)
    | []::_ -> None
    | (x::xs)::ys -> zipOne (x::acc, xs::rest) ys
  loop items

Answer 2

因为这似乎是在f＃中编写zipn的规范答案，所以我想添加一个＆＃34; pure＆＃34; seq解决方案可以保留懒惰，并且不会像Matrix.transpose函数那样强制我们立即将完整的源序列加载到内存中。有些情况下这非常重要，因为它a）更快，b）适用于包含100 MB数据的序列！

这可能是我在一段时间内编写的最不具有惯用性的f＃代码，但是它完成了工作（嘿，为什么f＃中会有序列表达式，如果你不能使用它们用函数式语言编写程序代码）。

 let seqdata = seq {
  yield Seq.ofList [ 1; 2; 3 ]
  yield Seq.ofList [ 4; 5; 6 ]
  yield Seq.ofList [ 7; 8; 9 ]
}

let zipnSeq (src:seq<seq<'a>>) = seq {
  let enumerators = src |> Seq.map (fun x -> x.GetEnumerator()) |> Seq.toArray
  if (enumerators.Length > 0) then
    try 
      while(enumerators |> Array.forall(fun x -> x.MoveNext())) do 
        yield enumerators |> Array.map( fun x -> x.Current)
    finally 
      enumerators |> Array.iter (fun x -> x.Dispose())
}

zipnSeq seqdata |> Seq.toArray


val it : int [] [] = [|[|1; 4; 7|]; [|2; 5; 8|]; [|3; 6; 9|]|]

顺便说一句，传统的矩阵转置比@ Daniel的答案简洁得多。但是，它需要list或LazyList才能最终在内存中拥有完整的序列。

let rec transpose = 
  function 
  | (_ :: _) :: _ as M -> List.map List.head M :: transpose (List.map List.tail M)
  | _ -> []

Answer 3

为了处理具有不同长度的子列表，我已经使用选项类型来发现我们是否已经用完了元素。

let split = function
    | []    -> None,    []
    | h::t  -> Some(h), t

let rec zipN listOfLists =
    seq { let splitted = listOfLists |> List.map split

          let anyMore = splitted |> Seq.exists (fun (f, _) -> f.IsSome)

          if anyMore then
              yield splitted |> List.map fst
              let rest = splitted |> List.map snd
              yield! rest |> zipN }

这会映射

let ll = [ [ 1; 2; 3 ];
           [ 4; 5; 6 ];
           [ 7; 8; 9 ] ]

到

seq
    [seq [Some 1; Some 4; Some 7]; seq [Some 2; Some 5; Some 8];
     seq [Some 3; Some 6; Some 9]]

和

let ll = [ [ 1; 2; 3 ];
           [ 4; 5; 6 ];
           [ 7; 8 ] ]

到

seq
    [seq [Some 1; Some 4; Some 7]; seq [Some 2; Some 5; Some 8];
     seq [Some 3; Some 6; null]]

这对你的方法采取了不同的方法，但避免使用之前的一些操作（例如Seq.skip，Seq.append），你应该小心。

Answer 4

我意识到这个答案不是很有效，但我确实喜欢它的简洁：

[[1;2;3]; [4;5;6]; [7;8;9]] 
    |> Seq.collect Seq.indexed 
    |> Seq.groupBy fst 
    |> Seq.map (snd >> Seq.map snd);;

Answer 5

另一个选择：

let zipN ls =
    let rec loop (a,b) =
        match b with
        |l when List.head l = [] -> a
        |l ->
            let x1,x2 =
                (([],[]),l)
                ||> List.fold (fun acc elem ->
                    match acc,elem with
                    |(ah,at),eh::et -> ah@[eh],at@[et]
                    |_ -> acc)
            loop (a@[x1],x2)
    loop ([],ls)

如何在F＃中编写类似ZipN的函数？

5 个答案: