我需要帮助来创建一个算法以从数字列表中返回可能的数字组列表答案

【问题标题】：I need help to create an algorithm to return a list of possible groups of numbers from a list of numbers我需要帮助来创建一个算法以从数字列表中返回可能的数字组列表
【发布时间】：2019-05-27 14:36:33
【问题描述】：

我需要开发的搜索算法的一部分包括一个函数，该函数接收整数列表并根据一些规则返回整数列表，这里是规范。

输入列表可以有任意数量的数字，从预先确定的最小值和最大值变化。该函数需要返回输入数字的所有可能组合，这些输入数字是连续的并且大小为 3 或更大。

输出组的顺序并不重要。

举个例子：

min = 1;
max = 10;

input = [1, 2, 3, 4, 6, 7, 8]

output = [ [1, 2, 3], [2, 3, 4], [1, 2, 3, 4], [6, 7, 8] ]

诀窍在于输入列表可以接收任意数量的小丑字符。这些小丑可以假设最小值和最大值内的任何值。

一个使用小丑的例子：

min = 1;
max = 10;

input = [1, 2, 3, 4, 6, 7, 8, J]

output = [ 
    [1, 2, 3], 
    [2, 3, 4], 
    [1, 2, 3, 4], 
    [6, 7, 8], 
    [1, 2, 3, 4, J, 6, 7, 8], 
    [2, 3, 4, J, 6, 7, 8], 
    [3, 4, J, 6, 7, 8],
    [4, J, 6, 7, 8], 
    [J, 6, 7, 8], 
    [6, 7, 8, J], 
    [7, 8, J],
    [1, 2, 3, 4, J, 6, 7], 
    [1, 2, 3, 4, J, 6], 
    [1, 2, 3, 4, J, 6], 
    [1, 2, 3, 4, J] 
]

在输入中处理任何可能数量的小丑时，我无法想出任何可以解决此问题的算法。

你有什么建议或伪代码可以帮助我解决这个问题吗？

【问题讨论】：

这样我就明白了：最小值和最大值定义了整数边界？因此，如果我们使用您上面的最小值和最大值但具有不同的整数列表：[0,1,3,5,11] 0 和 11 不会包含在解决方案的子集中？
当最小值和最大值仅以整数定义时，为什么 J 包含在解决方案中
您可以生成所有形式为 [i, i + 1, i + 2, ..., i + k] 的序列，其中 k >= 2 和 min ie 生成所有连续数字的序列，长度至少为 3，在 [min,max] 区间内），然后检查每个这样的序列，所需的 Joker 的数量是否大于可用 Joker 的数量。
@nmanh 你是对的，但说实话，输入列表不会使用最小值和最大值之外的数字生成
min = 1; max = 10; input = [J, J, J] 的完整预期输出是什么？

标签： algorithm search combinations

【解决方案1】：

这是一个递归，可能需要根据您的需要进行调整。这个想法是从每个可能的起点枚举到每个可能的终点。小丑仅用于不在列表中的数字。由于列表可能是稀疏的，因此一种方法是将每个数字视为图中的一个节点，在仍未看到的起点上执行搜索。

JavaScript 代码：

function f(A, jokerMin, jokerMax, globalMin, globalMax, minSeqLen){
  // Record available elements
  let sansJokers = A.filter(x => x != 'J');
  let numbers = new Set(sansJokers);
  let numJokers = A.length - sansJokers.length;
  let seen = new Set();
    
  // Given a starting point,
  // go as far as possible
  function g(js, n, comb){
    let result = comb.length >= minSeqLen ? [comb] : [];
    
    if (globalMin <= n && n <= globalMax){
      if (numbers.has(n)){
        return result.concat(
          g(js, n + 1, comb.slice().concat(n)));
          
      } else if (js && jokerMin <= n && n <= jokerMax){
        return result.concat(
          g(js - 1, n + 1, comb.slice().concat('J')));

      } else {
        return result;
      }
    
    } else {
      return result;
    }
  }
  
  let result = [];
  
  // Find starting points
  
  // If there are at least minSeqLen
  // jokers, we can start anywhere.
  // Otherwise, look only below
  // existing numbers since a pure
  // joker sequence will have to 
  // connect to a number to be valid
  if (numJokers >= minSeqLen){
    return ['Enough jokers to start anywhere'];
  
  } else {
    for (let n of numbers){
      // search lower
      let tempN = n - 1;
      
      while (!seen.has(tempN) &&
        !numbers.has(tempN) &&
        tempN >= globalMin &&
        tempN >= jokerMin){
        
        seen.add(tempN);
        result = result.concat(
          g(numJokers, tempN, []));
        tempN--;
      }
      
      seen.add(n);
      result = result.concat(
        g(numJokers, n, []));
    }
  }
  
  return result;
}

var jokerMin = 1;
var jokerMax = 10;
var globalMin = 1;
var globalMax = 15;
var minSeqLen = 3;

var input = [1, 2, 3, 4, 7, 8, 'J', 'J']

let str = '';

for (let comb of f(input, jokerMin, jokerMax, globalMin, globalMax, minSeqLen))
  str += JSON.stringify(comb) + '\n';

console.log(str);

【讨论】：