algorithm - 在 F# 中计算排列

Question

受此问题和答案的启发，如何在 F# 中创建通用排列算法？谷歌没有给出任何有用的答案。

编辑：我在下面提供了我的最佳答案，但我怀疑托马斯的更好（当然更短！）

Answer 1

你也可以这样写：

let rec permutations list taken = 
  seq { if Set.count taken = List.length list then yield [] else
        for l in list do
          if not (Set.contains l taken) then 
            for perm in permutations list (Set.add l taken)  do
              yield l::perm }

'list' 参数包含您想要置换的所有数字，而 'taken' 是一个包含已使用数字的集合。当所有数字都取完时，该函数返回空列表。否则，它会遍历所有仍然可用的数字，获取剩余数字的所有可能排列（递归地使用“排列”）并在返回之前将当前数字附加到每个数字（l::perm）。

要运行它，您将给它一个空集，因为开头没有使用数字：

permutations [1;2;3] Set.empty;;

Answer 2

我喜欢这个实现（但不记得它的来源）：

let rec insertions x = function
    | []             -> [[x]]
    | (y :: ys) as l -> (x::l)::(List.map (fun x -> y::x) (insertions x ys))

let rec permutations = function
    | []      -> seq [ [] ]
    | x :: xs -> Seq.concat (Seq.map (insertions x) (permutations xs))

Answer 3

Tomas 的解决方案非常优雅：它很短，纯粹是功能性的，而且很懒惰。我认为它甚至可能是尾递归的。此外，它还按字典顺序产生排列。但是，我们可以在内部使用命令式解决方案将性能提高两倍，同时仍然在外部公开功能接口。

该函数permutations采用通用序列e和通用比较函数f : ('a -> 'a -> int)，并按字典顺序懒惰地产生不可变的排列。比较函数允许我们生成不一定的元素排列comparable以及轻松指定反向或自定义排序。

内部函数是此处permute描述的算法的命令式实现。转换函数允许我们使用重载，它使用.let comparer f = { new System.Collections.Generic.IComparer<'a> with member self.Compare(x,y) = f x y }System.Array.SortIComparer

let permutations f e =
    ///Advances (mutating) perm to the next lexical permutation.
    let permute (perm:'a[]) (f: 'a->'a->int) (comparer:System.Collections.Generic.IComparer<'a>) : bool =
        try
            //Find the longest "tail" that is ordered in decreasing order ((s+1)..perm.Length-1).
            //will throw an index out of bounds exception if perm is the last permuation,
            //but will not corrupt perm.
            let rec find i =
                if (f perm.[i] perm.[i-1]) >= 0 then i-1
                else find (i-1)
            let s = find (perm.Length-1)
            let s' = perm.[s]

            //Change the number just before the tail (s') to the smallest number bigger than it in the tail (perm.[t]).
            let rec find i imin =
                if i = perm.Length then imin
                elif (f perm.[i] s') > 0 && (f perm.[i] perm.[imin]) < 0 then find (i+1) i
                else find (i+1) imin
            let t = find (s+1) (s+1)

            perm.[s] <- perm.[t]
            perm.[t] <- s'

            //Sort the tail in increasing order.
            System.Array.Sort(perm, s+1, perm.Length - s - 1, comparer)
            true
        with
        | _ -> false

    //permuation sequence expression 
    let c = f |> comparer
    let freeze arr = arr |> Array.copy |> Seq.readonly
    seq { let e' = Seq.toArray e
          yield freeze e'
          while permute e' f c do
              yield freeze e' }

现在为方便起见，我们有以下 where let flip f x y = f y x：

let permutationsAsc e = permutations compare e
let permutationsDesc e = permutations (flip compare) e

Answer 4

我最新的最佳答案

//mini-extension to List for removing 1 element from a list
module List = 
    let remove n lst = List.filter (fun x -> x <> n) lst

//Node type declared outside permutations function allows us to define a pruning filter
type Node<'a> =
    | Branch of ('a * Node<'a> seq)
    | Leaf of 'a

let permutations treefilter lst =
    //Builds a tree representing all possible permutations
    let rec nodeBuilder lst x = //x is the next element to use
        match lst with  //lst is all the remaining elements to be permuted
        | [x] -> seq { yield Leaf(x) }  //only x left in list -> we are at a leaf
        | h ->   //anything else left -> we are at a branch, recurse 
            let ilst = List.remove x lst   //get new list without i, use this to build subnodes of branch
            seq { yield Branch(x, Seq.map_concat (nodeBuilder ilst) ilst) }

    //converts a tree to a list for each leafpath
    let rec pathBuilder pth n = // pth is the accumulated path, n is the current node
        match n with
        | Leaf(i) -> seq { yield List.rev (i :: pth) } //path list is constructed from root to leaf, so have to reverse it
        | Branch(i, nodes) -> Seq.map_concat (pathBuilder (i :: pth)) nodes

    let nodes = 
        lst                                     //using input list
        |> Seq.map_concat (nodeBuilder lst)     //build permutations tree
        |> Seq.choose treefilter                //prune tree if necessary
        |> Seq.map_concat (pathBuilder [])      //convert to seq of path lists

    nodes

permutations 函数通过构造一个表示传入的“事物”列表的所有可能排列的 n 元树来工作，然后遍历树以构造列表列表。使用“Seq”可以显着提高性能，因为它会使一切变得懒惰。

permutations 函数的第二个参数允许调用者在生成路径之前定义一个过滤器来“修剪”树（参见下面的示例，我不想要任何前导零）。

一些示例用法： Node<'a> 是通用的，因此我们可以对“任何东西”进行排列：

let myfilter n = Some(n)  //i.e., don't filter
permutations myfilter ['A';'B';'C';'D'] 

//in this case, I want to 'prune' leading zeros from my list before generating paths
let noLeadingZero n = 
    match n with
    | Branch(0, _) -> None
    | n -> Some(n)

//Curry myself an int-list permutations function with no leading zeros
let noLZperm = permutations noLeadingZero
noLZperm [0..9] 

（特别感谢Tomas Petricek，欢迎提出任何意见）

Answer 5

看看这个：

http://fsharpcode.blogspot.com/2010/04/permutations.html

let length = Seq.length
let take = Seq.take
let skip = Seq.skip
let (++) = Seq.append
let concat = Seq.concat
let map = Seq.map

let (|Empty|Cons|) (xs:seq<'a>) : Choice<Unit, 'a * seq<'a>> =
    if (Seq.isEmpty xs) then Empty else Cons(Seq.head xs, Seq.skip 1 xs)

let interleave x ys =
    seq { for i in [0..length ys] ->
            (take i ys) ++ seq [x] ++ (skip i ys) }

let rec permutations xs =
            match xs with
            | Empty -> seq [seq []]
            | Cons(x,xs) -> concat(map (interleave x) (permutations xs))

Answer 6

如果您需要不同的排列（当原始集合有重复时），您可以使用这个：

let rec insertions pre c post =
    seq {
        if List.length post = 0 then
            yield pre @ [c]
        else
            if List.forall (fun x->x<>c) post then
                yield pre@[c]@post
            yield! insertions (pre@[post.Head]) c post.Tail
        }

let rec permutations l =
    seq {
        if List.length l = 1 then
            yield l
        else
            let subperms = permutations l.Tail
            for sub in subperms do
                yield! insertions [] l.Head sub
        }

这是此C# 代码的直接翻译。我愿意接受有关更实用的外观的建议。

Answer 7

如果您需要重复排列，这是使用 List.indexed 而不是元素比较的“按书本”方法在构造排列时过滤掉元素。

let permutations s =
    let rec perm perms carry rem =
        match rem with
            | [] -> carry::perms
            | l ->
                let li = List.indexed l
                let permutations =
                        seq { for ci in li ->
                                let (i, c) = ci
                                (perm
                                        perms
                                        (c::carry)
                                        (li |> List.filter (fun (index, _) -> i <> index) |> List.map (fun (_, char) -> char))) }

                permutations |> Seq.fold List.append []
    perm [] [] s