我将从一个例子开始；给定 n = 1 和 m = 100 以及一个列表 [1, 2, 3] 生成所有包含一位数和两位数的数字等等，但在这种情况下它们需要小于 100。

输出:

- 1, 2, 3, 11, 12, 13, 21, 22, 23, 31, 32, 33

然后我们停止，因为下一个数字将超过 100，例如:

- 111, 112, 113, 121, 122, 123, 131, 132, 133, 21..,. 22..., 23..., 31, 32, 33

正如您所注意到的，我将 1, 2, 3, 4 附加到之前创建的数字，为此我使用了一个递归函数，该函数在 for 循环中为我的列表，它们会一直运行，直到生成的数字大于我的限制。

def x(str, finish, d, c) 
  return if d >= finish
  [1, 2, 3, 4].each do |e|
    x(str, end, d*c+e)
  end

  # do something if d >= str
end

如果我需要从 1 开始，这很好用，但如果我的起始数字大很多，我仍然需要开始创建这个序列。

有人可以帮我提供一个可以产生相同序列的解决方案，但是从任何起点而不是 1 开始，所以如果例如起点是 100 并且结束点是 200，则输出将是:

111、112、113、114、121、122、123、124、131、132、132 [...]

任何编程语言的解决方案都很好，但请不要内置核心库。

最佳答案

代码

def generate_em(minimum, maximum, list)
  digits_min = minimum.to_s.size
  digits_min += 1 if minimum > (list.max.to_s*digits_min).to_i
  digits_max = maximum.to_s.size
  digits_max -= 1 if maximum < (list.min.to_s*digits_max).to_i
  (digits_min..digits_max).each_with_object([]) { |n,arr|
    arr.concat(list.repeated_permutation(n).to_a.map { |a| a.join.to_i }) }.
      uniq.
      select { |n| (minimum..maximum).cover?(n) }
end

示例

#1

minimum =   1
maximum = 100
list = [1, 2, 3]

generate_em(minimum, maximum, list)
  #=> [1, 2, 3, 11, 12, 13, 21, 22, 23, 31, 32, 33] 

#2

minimum = 78
maximum = 3332
list = [3, 4, 5, 6, 7]

generate_em(minimum, maximum, list)
  #=> [333, 334, 335, 336, 337, 343, 344, 345, 346, 347, 353, 354, 355, 356,
  #    357, 363, 364, 365, 366, 367, 373, 374, 375, 376, 377, 433, 434, 435,
  #    436, 437, 443, 444, 445, 446, 447, 453, 454, 455, 456, 457, 463, 464,
  #    465, 466, 467, 473, 474, 475, 476, 477, 533, 534, 535, 536, 537, 543,
  #    544, 545, 546, 547, 553, 554, 555, 556, 557, 563, 564, 565, 566, 567,
  #    573, 574, 575, 576, 577, 633, 634, 635, 636, 637, 643, 644, 645, 646,
  #    647, 653, 654, 655, 656, 657, 663, 664, 665, 666, 667, 673, 674, 675,
  #    676, 677, 733, 734, 735, 736, 737, 743, 744, 745, 746, 747, 753, 754,
  #    755, 756, 757, 763, 764, 765, 766, 767, 773, 774, 775, 776, 777] 

#3

minimum = 0
maximum = 100
list = [0, 1, 2]

generate_em(minimum, maximum, list)
  #=> [0, 1, 2, 10, 11, 12, 20, 21, 22, 100]

解释

示例 #1

上面第一个例子的步骤如下。

digits_min = minimum.to_s.size
  #=> 1 

如果 mimum 大于 list 中最大的 digits_min 位数，则将 digits_min 增加一。

digits_min += 1 if minimum > (list.max.to_s*digits_min).to_i
digits_min
  #=> 1 

digits_max = maximum.to_s.size
  #=> 3 

如果 maximum 小于 list 中最小的 digits_max 数字，则将 digits_max 减一。

digits_max -= 1 if maximum < (list.min.to_s*digits_max).to_i
digits_max
  #=> 2

我们通过将 digits_max 从 3 减少到 2 来提高效率

c = digits_min..digits_max
  #=> 1..2 
d = c.each_with_object([])
  #=> #<Enumerator: 1..2:each_with_object([])> 

我们可以通过调用 Enumerable#entries (或 Enumerable#to_a )来查看此枚举器将生成​​的元素。

d.entries
  #=> [[1, []], [2, []]]

n, arr = d.next
  #=> [1, []] 
n #=> 1 
arr
  #=> [] 
e = list.permutation(n)
  #=> #<Enumerator: [1, 2, 3]:permutation(2)>
f = e.to_a
  #=> [[1], [2], [3]] 
arr.concat f
  #=> [[1], [2], [3]] 
n, arr = d.next
  #=> [2, [[1], [2], [3]]] 
n #=> 2 
arr
  #=> [[1], [2], [3]] 
e = list.permutation(n)
  #=> #<Enumerator: [1, 2, 3]:permutation(2)> 
f = e.to_a
  #=> [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]] 
arr.concat f
  #=> [[1], [2], [3], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]] 

arr 由 each_with_object 的 block 返回。

g = arr.map { |a| a.join.to_i }
  #=> [1, 2, 3, 12, 13, 21, 23, 31, 32]
h = g.uniq
  #=> [1, 2, 3, 12, 13, 21, 23, 31, 32]
h.select { |n| (minimum..maximum).cover?(n) }
  #=> [1, 2, 3, 12, 13, 21, 23, 31, 32]

示例 #2

在第二个示例中，没有生成两位数组合，因为

78 > (list.max.to_s*2).to_i
  #=> 78 > 77 => true

并且没有生成四位数组合，因为

3332 < (list.min.to_s*4).to_i
  #=> 3332 < 3333 => true 

示例 #3

如果没有 uniq，该方法将返回重复值:

[0, 1, 2, 0, 1, 2, 10, 11, 12, 20, 21, 22, 0, 1, 2, 10, 11, 12, 20, 21, 22, 100]

关于ruby - 从列表中生成从 n 到 m 的数字，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42461971/