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

Question

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

输入列表可以有任意数量的数字，其最小值和最大值是预定值。该函数需要返回顺序的且大小为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] 
]

在输入中使用任意数量的小丑时，我无法提出任何可以解决此问题的算法。

您可以分享任何建议或伪代码来帮助我解决此问题吗？

Answer 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);