Question

我需要根据条件快速确定数组中元素的可能uniq组合。

他们有以下结构：

[[id,parent_id]]

我对小型阵列没有任何问题。如果所有parent_id都是uniq。例如：

a = (1..6).to_a.map{ |a| [a,a] }                                                
=> [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6]]
a.combination(3).size # => 20

立即回答。

如果我有重复发生的parent_id的id，我仍然可以使用组合并遍历所有组合。

a = (1..7).to_a.map{ |a| [a,a] };a[6] = [7,6]
=> [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 6]]
a.combination(3).size # => 35
valid_combos = a.combination(3).to_a.select { |c| c.map(&:last).uniq.size == c.size }.size # => 30

在小阵列上仍然很快。但是如果数组有33个条目，其中1个重复发生的parent_id，我将不得不检查1166803110组合。这很慢。当然。

欢迎任何关于如何快速有效地解决这个问题的想法或提示。

我喜欢Array类的组合方法。但我也会使用哈希或设置。

也可能有以下数组：

 a = [[1, 1], [2, 1], [3, 1], [4, 2], [5, 2], [6, 2], [7, 3], [8, 3]]
 a.combination(3).size #=> 56

但只有18个“有效”。

感谢任何帮助。

编辑：

有效输入没有重复出现的parent_id：

[[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]]

有效输出，每组合4个（5个uniq组合）：

[[[1, 1], [2, 2], [3, 3], [4, 4]], [[1, 1], [2, 2], [3, 3], [5, 5]], [[1, 1], [2, 2], [4, 4], [5, 5]], [[1, 1], [3, 3], [4, 4], [5, 5]], [[2, 2], [3, 3], [4, 4], [5, 5]]]

有效输入1重复出现的parent_id：

[[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6,5]]

有效输出，每组合4个（9个uniq组合）：

[[[1, 1], [2, 2], [3, 3], [4, 4]], [[1, 1], [2, 2], [3, 3], [5, 5]], [[1, 1], [2, 2], [3, 3], [6, 5]], [[1, 1], [2, 2], [4, 4], [5, 5]], [[1, 1], [2, 2], [4, 4], [6, 5]], [[1, 1], [3, 3], [4, 4], [5, 5]], [[1, 1], [3, 3], [4, 4], [6, 5]], [[2, 2], [3, 3], [4, 4], [5, 5]], [[2, 2], [3, 3], [4, 4], [6, 5]]]

这些是无效的组合[5,5]和[6,5]是不允许的：

[[[1, 1], [2, 2], [5, 5], [6, 5]], [[1, 1], [3, 3], [5, 5], [6, 5]], [[1, 1], [4, 4], [5, 5], [6, 5]], [[2, 2], [3, 3], [5, 5], [6, 5]], [[2, 2], [4, 4], [5, 5], [6, 5]], [[3, 3], [4, 4], [5, 5], [6, 5]]]

Answer 1

如果我理解正确，您需要所有可能的ID组合，其中ID不会共享父ID。我有一些不同的东西，只是为了好玩，没有真正的想法，如果性能会提高。

x = [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6,5]]

首先，让我们翻一番。

hash = x.reduce({}) {|hash, pair| (hash[pair.last] ||= []).push pair.first}
#=> {1=>[1], 2=>[2], 3=>[3], 4=>[4], 5=>[5, 6]}

现在我们获得父ID的所有可能组合。

parents = hash.keys.combination(4).to_a
#=> [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 4, 5], [1, 3, 4, 5], [2, 3, 4, 5]]

现在我们将每个父ID映射到它的子ID。

children = parents.map do |array|
  array.map {|parent| hash[parent]}
end
#=>  [[[1], [2], [3], [4]], [[1], [2], [3], [5, 6]], [[1], [2], [4], [5, 6]], [[1], [3], [4], [5, 6]], [[2], [3], [4], [5, 6]]]

此时我们已经深入了解阵列。现在，我们采用每个子阵列的产品来获得所有可能的组合，我们甚至不需要将它们统一起来。

children.map {|array| array.first.product *array.drop(1)}.flatten(1)
#=> [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 3, 6], [1, 2, 4, 5], [1, 2, 4, 6], [1, 3, 4, 5], [1, 3, 4, 6], [2, 3, 4, 5], [2, 3, 4, 6]]

现在你拥有了所有的id组合，并且可以使用它们来查找父ID，如果你仍然需要它们使用hash表的反面。

性能怎么样？我通过运行this file进行基准测试。

有50个条目，25个重复，以及4个组合：

3957124
Original:   8.719000   0.110000   8.829000 (  8.860909)
3957124
Simons:     4.875000   0.094000   4.969000 (  6.458309)

因此理论上看起来更快。但是，有125个条目，25个重复，以及4个组合：

9811174
Original:  22.875000   0.281000  23.156000 ( 23.213483)
9811174
Simons:    20.703000   0.391000  21.094000 ( 21.232167)

哪个速度不快。这是因为对于如此多的组合，Ruby花费了大部分时间进行内存分配（尝试在任务管理器或top中观看），这在Ruby中是 dog-slow 。没有任何有用的方法可以预先分配内存，所以超出某一点就可以达到硬限制。

但这只是发生，因为你强迫Ruby一次收集所有数组项。如果您使用特定用例允许您单独处理每个组合，则可以避免大部分内存分配。通过使用每个子数组（this file）调用yield：

9811174
Simons:    8.485000   0.000000   8.485000 (  8.476653)

快得多。您还将观察到内存使用量保持不变。 It's still gonna take a while though。但是，如果您有多个核心，原则上可以并行化，因为一旦您拥有散列，每个组合可以独立于其他组合进行处理。我会留下你试试:)

Answer 2

您可以按照以下方式执行此操作。

<强>代码

def combos(pairs, group_size)
  pairs.group_by(&:last).
        values.
        combination(group_size).
        flat_map { |a| a.shift.product(*a) }
end

<强>实施例

pairs = [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6,5]]

combos(pairs, 4)
   #=> [[[1, 1], [2, 2], [3, 3], [4, 4]],
   #    [[1, 1], [2, 2], [3, 3], [5, 5]],
   #    [[1, 1], [2, 2], [3, 3], [6, 5]],
   #    [[1, 1], [2, 2], [4, 4], [5, 5]],
   #    [[1, 1], [2, 2], [4, 4], [6, 5]],
   #    [[1, 1], [3, 3], [4, 4], [5, 5]],
   #    [[1, 1], [3, 3], [4, 4], [6, 5]],
   #    [[2, 2], [3, 3], [4, 4], [5, 5]],
   #    [[2, 2], [3, 3], [4, 4], [6, 5]]] 
 combos(pairs, 5)
   #=>  [[[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]],
   #     [[1, 1], [2, 2], [3, 3], [4, 4], [6, 5]]] 

 combos(pairs, 1).size #=>  6 
 combos(pairs, 2).size #=> 14 
 combos(pairs, 3).size #=> 16 
 combos(pairs, 4).size #=>  9 
 combos(pairs, 5).size #=>  2

<强>解释

对于示例中使用的数组pairs和

group_size = 4

我们执行以下计算。首先，我们通过每对的最后一个元素（即parent_id）对对的元素进行分组：

h = pairs.group_by(&:last)
  #=> {1=>[[1, 1]], 2=>[[2, 2]], 3=>[[3, 3]], 4=>[[4, 4]], 5=>[[5, 5], [6, 5]]}

我们只需要来自此哈希的值：

b = h.values
  #=> [[[1, 1]], [[2, 2]], [[3, 3]], [[4, 4]], [[5, 5], [6, 5]]]

我们现在获得b：

元素的组合

enum = b.combination(group_size)
  #=> b.combination(4)
  #=> #<Enumerator: [[[1, 1]], [[2, 2]], [[3, 3]], [[4, 4]],
  #                  [[5, 5], [6, 5]]]:combination(4)>

我们可以通过将它转换为数组来查看此枚举器的（5）元素：

enum.to_a
  #=> [[[[1, 1]], [[2, 2]], [[3, 3]], [[4, 4]]],
  #    [[[1, 1]], [[2, 2]], [[3, 3]], [[5, 5], [6, 5]]],
  #    [[[1, 1]], [[2, 2]], [[4, 4]], [[5, 5], [6, 5]]],
  #    [[[1, 1]], [[3, 3]], [[4, 4]], [[5, 5], [6, 5]]],
  #    [[[2, 2]], [[3, 3]], [[4, 4]], [[5, 5], [6, 5]]]]

最后一步是将enum的每个元素映射到其元素的乘积（enum的每个元素都是一对数组）。我们使用Enumerable#flat_map，因此我们不必随后进行任何展平：

enum.flat_map { |a| a.shift.product(*a) }

返回group_size = 4的示例中给出的数组。

让我们更仔细地看一下上一个陈述中发生的事情：

enum1 = enum.flat_map
  #=> #<Enumerator: #<Enumerator: [[[1, 1]], [[2, 2]], [[3, 3]], [[4, 4]],
  #                     [[5, 5], [6, 5]]]:combination(4)>:flat_map>

您可能希望将enum1视为“复合枚举器”。 enum1的元素将被Enumerator#each（将调用Array#each）传递到其块中，并分配给块变量a。让我们看一下传递给块的第二个值。

跳过第一个：

a = enum1.next
  #=> [[[1, 1]], [[2, 2]], [[3, 3]], [[4, 4]]]

传递第二个：

a = enum1.next
  #=> [[[1, 1]], [[2, 2]], [[3, 3]], [[5, 5], [6, 5]]]

我们采用以下四个阵列的产品：

a[0].product(a[1], a[2], a[3])
  #=> [[[1, 1], [2, 2], [3, 3], [5, 5]],
  #    [[1, 1], [2, 2], [3, 3], [6, 5]]]

我们也可以写：

a[0].product(*a[1..-1])

或者，正如我所做的那样：

a.shift.product(*a)

请注意，在最后一个表达式中，a的{{1}}是*a执行后a的剩余部分。

Ruby可能的数组值组合 - 性能

2 个答案: