Question

我需要生成N个数字的所有可能组合，包括重复。

问题输入：我有N个单元格，我可以在每个单元格的0到9区间内输入一个数字。

错误的解决方案（N = 4）：

(0 to: 3) permutationsDo: [ : each | Transcript cr; show: each printString].

不包括＃（0 0 0 0），＃（1 1 1 1），＃（2 2 2 2）等。

预期输出（为简洁起见，N = 2，范围1-4）：

#(1 1)
#(2 2)
#(3 3)
#(4 4)
#(2 1)
#(3 2)
#(4 3)
#(1 4)
#(3 1)
#(4 2)
#(1 3)
#(2 4)
#(4 1)
#(1 2)
#(2 3)
#(3 4)

Answer 1

为了简单起见，让我在SequenceableCollection中实现这一点：

nextCombination09
    | j |
    j := self findLast: [:ai | ai < 9] ifAbsent: [^nil].
    j + 1 to: self size do: [:i | self at: i put: 0].
    self at: j put: (self at: j) + 1

这个想法如下：使用词典顺序对所有组合进行排序。换句话说：

(a1, ..., an) < (b1, ..., bn)

如果ai = bi低于某个索引i j以下的所有aj < bj。

使用此订单，第一个组合为(0, ..., 0)，最后一个组合为(9, ..., 9)。

此外，给定组合(a1, ..., an)，此顺序中的下一个是将1添加到最低卓越索引的组合，这是j的最后一个aj < 9 (2, 3, 8, 9) }。例如，(2, 3, 9, 9)的旁边是(9, ..., 9)，因为它们之间不存在任何内容。

一旦我们到达nil，我们就完成了，并以copy回答。

请注意，上述方法会修改接收器，这就是为什么我们必须在下面的脚本中n。

以下是生成所有组合的脚本（N是您的n := <whatever> array := Array new: n withAll: 0. combinations := OrderedCollection new: (10 raisedTo: n). [ combinations add: array copy. array nextCombination09 notNil] whileTrue. ^combinations）

$this -> Affiliate -> find('all', array('contain' => 'Payout'))

<强>附录

相同的技术可用于类似性质的other problems。

Answer 2

以下是一些可以扩展SequenceableCollection的选择器。这是permutationsDo:定义的类，最终由Interval类继承。

类别＆＃34;枚举＆＃34;：

enumerationsDo: aBlock
   | anArray |
   anArray := Array new: self size.
   self enumerateWithSize: (self size) in: anArray do: [ :each | aBlock value: each ]

类别＆＃34;私人＆＃34;：

enumerateWithSize: aSize in: anArray do: aBlock
   (aSize = 1)
      ifTrue: [
         self do: [ :each |
            aBlock value: (anArray at: (self size - aSize + 1) put: each ; yourself) ] ]
      ifFalse: [
         self do: [ :each |
            self enumerateWithSize: (aSize - 1) in: anArray do: [ :eachArray |
               aBlock value: (eachArray at: (self size - aSize + 1) put: each ; yourself) ] ] ]

现在你可以这样做：

(0 to: 2) enumerationsDo: [ :each | Transcript show: each printString ; cr ]

哪个收益率：

#(0 0 0)
#(0 0 1)
#(0 0 2)
#(0 1 0)
#(0 1 1)
#(0 1 2)
#(0 2 0)
#(0 2 1)
#(0 2 2)
#(1 0 0)
#(1 0 1)
#(1 0 2)
#(1 1 0)
#(1 1 1)
#(1 1 2)
#(1 2 0)
#(1 2 1)
#(1 2 2)
#(2 0 0)
#(2 0 1)
#(2 0 2)
#(2 1 0)
#(2 1 1)
#(2 1 2)
#(2 2 0)
#(2 2 1)
#(2 2 2)

这个选择器对称地操作＆＃34;就像现有的permutationsDo:选择器一样，结果数组中的元素数（选择数）与集合中的值数相同。

<小时/> 您可以轻松地从那里转到更通用的解决方案：

在＆＃34;枚举＆＃34;：

enumerationsDo: aBlock
    self enumerationsOfSize: (self size) do: aBlock

enumerationsOfSize: aSize do: aBlock
   | anArray |
   anArray := Array new: aSize.
   self enumerateWithSize: aSize subSize: aSize in: anArray do: [ :each | aBlock value: each ]

在＆＃34;私人＆＃34;：

enumerateWithSize: aSize subSize: sSize in: anArray do: aBlock
    (aSize < sSize)
        ifTrue: [ ^self error: 'subSize cannot exceed array size' ].
    (sSize < 1)
        ifTrue: [ ^self error: 'sizes must be positive' ].

    (sSize = 1)
        ifTrue: [
            self do: [ :each |
                aBlock value: (anArray at: (aSize - sSize + 1) put: each ; yourself) ] ]
        ifFalse: [
            self do: [ :each |
                self enumerateWithSize: aSize subSize: (sSize - 1) in: anArray do: [ :eachArray |
                    aBlock value: (eachArray at: (aSize - sSize + 1) put: each ; yourself) ] ] ]

以下是一个例子：

(1 to: 3) enumerationsOfSize: 2 do: [ :e | Transcript show: e printString ; cr ]

哪个收益率：

#(1 1)
#(1 2)
#(1 3)
#(2 1)
#(2 2)
#(2 3)
#(3 1)
#(3 2)
#(3 3)

Smalltalk中重复的组合

2 个答案: