递归函数获取两个或多个的所有唯一组合

Question

我需要编写一个函数，从元素数组中获取两个或多个元素的所有唯一组合。我已经为此工作了几天。我最初编写了单独的函数来获得一些不同大小的组合，这有助于我了解它们的相似之处，并且我希望能让我比目前更接近一个可行的解决方案。这就是我目前所拥有的......

function getAll (elements, comboSize, startingIndex) {
  let finalStartingIndex = /*startingIndex + */elements.length - comboSize;
  let finalIndex = finalStartingIndex + 1;
  let tmpStartingIndex = startingIndex;
  let qstrings = [];

  if (finalIndex >= elements.length) {
    finalIndex = finalStartingIndex;
  }

  if (finalStartingIndex < finalIndex) {
    while (tmpStartingIndex <= finalStartingIndex) {
      let nextIndex = tmpStartingIndex + 1;

      while (nextIndex <= finalIndex) {
        let tmpComboSize = comboSize - 1;
        let tmpQstring = '';
        let newQstring = '';

        if (tmpComboSize > 1) {
          tmpQstring = getAll(elements, tmpComboSize, nextIndex);
          console.log('tmpQstring :: ', tmpQstring);
        }

        if (tmpQstring != '') {
          newQstring = elements[tmpStartingIndex] + ', ' + tmpQstring[nextIndex];
          console.log('tmpQstring[nextIndex] :: ', tmpQstring[nextIndex]);
          console.log('newQstring :: ', newQstring);
        }
        let qstring = elements[tmpStartingIndex] + ', ' + elements[nextIndex];
        qstrings.push(qstring);
        nextIndex++;
      }

      /*nextIndex = tmpStartingIndex;

      let tmpComboSize = comboSize - 1;

      if (tmpComboSize > 1) {
        let tmpQstring = getAll(elements, tmpComboSize, nextIndex);

        let stringVal = elements[tmpStartingIndex] + ', ' + tmpQstring[nextIndex];
        qstrings.push(stringVal);
      }*/
      tmpStartingIndex++;
    }
  } else {
    qstrings[finalStartingIndex] = elements[startingIndex] + ', ' + elements[finalStartingIndex];
    console.log(qstrings);
  }

  return qstrings;
}

function getAllTwo (elements, comboSize, startingIndex) {
  let finalStartingIndex = startingIndex + elements.length - comboSize;
  let finalIndex = finalStartingIndex + 1;
  let tmpStartingIndex = startingIndex;
  let qstrings = [];

  while (tmpStartingIndex <= finalStartingIndex) {
    let finalNextIndex = tmpStartingIndex + 1;

    while (finalNextIndex <= finalIndex) {
      let qstring = elements[tmpStartingIndex] + ', ' + elements[finalNextIndex];
      qstrings.push(qstring);
      finalNextIndex++;
    }

    tmpStartingIndex++;
  }

  return qstrings;
}

function getAllThree (elements, comboSize, startingIndex) {
  let finalStartingIndex = startingIndex + elements.length - comboSize;
  let finalFirstNextIndex = finalStartingIndex + 1;
  let finalIndex = finalFirstNextIndex + 1;
  let tmpStartingIndex = startingIndex;
  let qstrings = [];

  while (tmpStartingIndex <= finalStartingIndex) {
    let firstNextIndex = tmpStartingIndex + 1;

    while (firstNextIndex <= finalFirstNextIndex) {
      let finalNextIndex = firstNextIndex + 1;

      while (finalNextIndex <= finalIndex) {
        let qstring = elements[tmpStartingIndex] + ', ' + elements[firstNextIndex] + ', ' + elements[finalNextIndex];
        qstrings.push(qstring);
        finalNextIndex++;
      }

      firstNextIndex++;
    }

    tmpStartingIndex++;
  }

  return qstrings;
}

function getAllFour (elements, comboSize, startingIndex) {
  let finalStartingIndex = startingIndex + elements.length - comboSize;
  let finalFirstNextIndex = finalStartingIndex + 1;
  let finalSecondNextIndex = finalFirstNextIndex + 1;
  let finalIndex = finalSecondNextIndex + 1;
  let tmpStartingIndex = startingIndex;
  let qstrings = [];

  while (tmpStartingIndex <= finalStartingIndex) {
    let firstNextIndex = tmpStartingIndex + 1;

    while (firstNextIndex <= finalFirstNextIndex) {
      let secondNextIndex = firstNextIndex + 1;

      while (secondNextIndex <= finalSecondNextIndex) {
        let finalNextIndex = secondNextIndex + 1;

        while (finalNextIndex <= finalIndex) {
          let qstring = elements[tmpStartingIndex] + ', ' + elements[firstNextIndex] + ', ' + elements[secondNextIndex] + ', ' + elements[finalNextIndex];
          qstrings.push(qstring);
          finalNextIndex++;
        }

        secondNextIndex++;
      }

      firstNextIndex++;
    }

    tmpStartingIndex++;
  }

  return qstrings;
}

function getAllFive (elements, comboSize, startingIndex) {
  let finalStartingIndex = startingIndex + elements.length - comboSize;
  let firstFinalIndex = finalStartingIndex + 1;
  let secondFinalIndex = firstFinalIndex + 1;
  let thirdFinalIndex = secondFinalIndex + 1;
  let finalIndex = thirdFinalIndex + 1;
  let tmpStartingIndex = startingIndex;
  let qstrings = [];

  while (tmpStartingIndex <= finalStartingIndex) {
    let firstIndex = tmpStartingIndex + 1;

    while (firstIndex <= firstFinalIndex) {
      let secondIndex = firstIndex + 1;

      while (secondIndex <= secondFinalIndex) {
        let thirdIndex = secondIndex + 1;

        while (thirdIndex <= thirdFinalIndex) {
          let finalNextIndex = thirdIndex + 1;

          while (finalNextIndex <= finalIndex) {
            let qstring = elements[tmpStartingIndex] + ', ' + elements[firstIndex] + ', ' + elements[secondIndex] + ', ' + elements[thirdIndex] + ', ' + elements[finalNextIndex];
            qstrings.push(qstring);
            console.log('qstrings being built: ', qstrings);
            finalNextIndex++;
          }

          thirdIndex++;
        }

        secondIndex++;
      }

      firstIndex++;
    }

    tmpStartingIndex++;
  }

  return qstrings;
}

let finalStrings = [];
let elements = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

for (let comboSize = 2; comboSize <= elements.length; comboSize++) {
  let finalString = [];
  let tstFinalString = [];

  switch (comboSize) {
    case 2:
      tstFinalString = getAll(elements, comboSize, 0);
      //console.log('tstFinalString, comboSize 2 :: ', tstFinalString);
      //finalString = getAllTwo(elements, comboSize, 0);
      break;

    case 3:
      tstFinalString = getAll(elements, comboSize, 0);
      console.log('tstFinalString, comboSize 3 :: ', tstFinalString);
      //finalString = getAllThree(elements, comboSize, 0);
      break;

    /*case 4:
      finalString = getAllFour(elements, comboSize, 0);
      break;

    case 5:
      finalString = getAllFive(elements, comboSize, 0);
      console.log(finalString);
      break;*/

    default:
      break;
  }

  finalStrings.push(finalString);
}

第一个功能是我尝试正确递归。目前，它可以得到所有两个元素的组合，但不能超越。我觉得我缺少一些简单的东西，我只是看不到它。我编写了其他函数来帮助我思考逻辑并确保我得到了我期望的数据。这些功能确实有效，但显然它不可扩展。您可以提供任何帮助指出我所缺少的内容，我们将不胜感激。

哦，如果这很重要的话，这目前是用 Javascript 编写的。

Answer 1

我认为这或多或少是k 大小组合的规范方式。

// return n choose k combinations
function choose(arr, k, prefix=[], i=0){
  // if the remainder of the array will complete the
  // combination length exactly, combine it with
  // the current prefix and add to results
  if (prefix.length + arr.length - i == k){
    return [prefix.concat(arr.slice(i))];

  // if the prefix is long enough, add it to the results
  } else if (prefix.length == k){
    return [prefix];

  // otherwise, push combinations with and without
  // the current element
  } else {
    return choose(arr, k, prefix.concat(arr[i]), i + 1)
      .concat(choose(arr, k, prefix, i + 1));
  }
}

let arr = ["A","B","C","D","E"];
console.log('Input: ' + JSON.stringify(arr) + '\n');
let cs = choose(arr, 3);
console.log('\nOutput:');
for (let c of cs)
  console.log(JSON.stringify(c));

为了得到所有，我们可以这样做：

function powerset(arr, prefix=[], i=0){
  if (i == arr.length)
    return [prefix];

  return powerset(arr, prefix.concat(arr[i]), i + 1)
    .concat(powerset(arr, prefix, i + 1));
}

let arr = ['a', 'b', 'c', 'd', 'e'];
let ps = powerset(arr);
for (let s of ps)
  console.log(JSON.stringify(s));

Answer 2

这是使用生成器的另一种方式。这种方法的优点是组合是惰性生成的。根据您的计算，有时您可能能够在生成所有组合之前达到您想要的结果。由于许多组合问题涉及大量组组合，我们可以通过跳过生成不需要的组合来潜在地节省大量资源。此外，这个概念可以扩展到无限流上，可能会产生无限多的组合。

const append = (xs, x) =>
  xs .concat ([ x ])

const ncomb = function* (n, xs = [])
{ const gen = function* (n, acc)
  { if (n === 0)
      yield acc
    else
      for (const x of xs)
        yield* gen (n - 1, append (acc, x))
  }
  yield* gen (n, [])
}

const data =
  [ 1, 2, 3 ]

const print = (...xs) =>
  console .log (...xs .map (x => JSON .stringify (x)))

print
  ( Array .from (ncomb (0, data))
    // [[]]
    
  , Array .from (ncomb (1, data))
    // [[1],[2],[3]]
    
  , Array .from (ncomb (2, data))
    // [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]]
    
  , Array .from (ncomb (3, data))
    // [[1,1,1],[1,1,2],[1,1,3],[1,2,1],[1,2,2],[1,2,3],[1,3,1],[1,3,2],[1,3,3],[2,1,1],[2,1,2],[2,1,3],[2,2,1],[2,2,2],[2,2,3],[2,3,1],[2,3,2],[2,3,3],[3,1,1],[3,1,2],[3,1,3],[3,2,1],[3,2,2],[3,2,3],[3,3,1],[3,3,2],[3,3,3]]
  )

组合增加最右边的元素，但可以更改此顺序。如果您将append 操作更改为prepend，您将生成最左侧元素递增的组合——

const prepend = (xs, x) =>
  [ x ] .concat (xs)

print
  ( Array .from (ncomb (3, data))
    // [[1,1,1],[2,1,1],[3,1,1],[1,2,1],[2,2,1],[3,2,1],[1,3,1],[2,3,1],[3,3,1],[1,1,2],[2,1,2],[3,1,2],[1,2,2],[2,2,2],[3,2,2],[1,3,2],[2,3,2],[3,3,2],[1,1,3],[2,1,3],[3,1,3],[1,2,3],[2,2,3],[3,2,3],[1,3,3],[2,3,3],[3,3,3]]
  )

为了演示生成器的短路行为，考虑一个函数solve，它接受任意数量的数字并返回第一个Pythagorean triple。找到第一个直角三角形后，不会再生成其他组合-

const isRightTriangle = (a, b, c) =>
  // pythagorean triple
  (a ** 2) + (b ** 2) === (c ** 2)

const solve = (...numbers) =>
{ for (const [ a, b, c ] of ncomb (3, numbers))
    if (isRightTriangle (a, b, c))
      return `solution: ${a}, ${b}, ${c}`
  return `no solution`
}

console .log (solve (1, 2, 3, 4, 5, 6, 7, 9, 10))
// solution: 3, 4, 5

console .log (solve (8, 11, 6, 9, 5, 10, 12, 7))
// solution: 8, 6, 10

console .log (solve (19, 6, 8, 7, 21, 4, 3, 15))
// no solution

展开下面的sn-p，在自己的浏览器中验证结果-

const append = (xs, x) =>
  xs .concat ([ x ])

const ncomb = function* (n, xs = [])
{ const gen = function* (n, acc)
  { if (n === 0)
      yield acc
    else
      for (const x of xs)
        yield* gen (n - 1, append (acc, x))
  }
  yield* gen (n, [])
}

const isTriangle = (a, b, c) =>
  // pythagorean theorem
  (a ** 2) + (b ** 2) === (c ** 2)

const solve = (...numbers) =>
{ for (const [ a, b, c ] of ncomb (3, numbers))
    if (isTriangle (a, b, c))
      return `solution: ${a}, ${b}, ${c}`
  return `no solution`
}

console .log (solve (1, 2, 3, 4, 5, 6, 7, 9, 10))
// solution: 3, 4, 5

console .log (solve (8, 11, 6, 9, 5, 10, 12, 7))
// solution: 8, 6, 10

console .log (solve (19, 6, 8, 7, 21, 4, 3, 15))
// no solution