[英]How do I write a ZipN-like function in F#?
我想创建一个带有签名seq<#seq<'a>> ->seq<seq<'a>>
的函数,它就像一个Zip方法,采用任意数量的输入序列(而不是2或3)如在Zip2和Zip3中那样,并返回一系列序列而不是元组作为结果。
也就是说,给出以下输入:
[[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
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
由于这似乎是在f#中编写zipn
的规范答案,我想添加一个“纯” 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)
| _ -> []
为了处理具有不同长度的子列表,我已经使用选项类型来发现我们是否已经用完了元素。
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),你应该小心。
我意识到这个答案不是很有效,但我确实喜欢它的简洁:
[[1;2;3]; [4;5;6]; [7;8;9]]
|> Seq.collect Seq.indexed
|> Seq.groupBy fst
|> Seq.map (snd >> Seq.map snd);;
另外一个选项:
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)
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.