计算系列的所有组合 [英] Calculate all combinations of a series

问题描述

我有一个项目列表，每个项目都有一个数量。

 各种项目= {
 1 ：12，//我们有12 x item1 
 2：1，// //我们有1 x item2 
 3：1，
 4：7，
 5：2，
 6：2 
}； 
  

或者，也可以将其视为：

  var个项= [1，1，1，1，1，1，1，1，1，1，1，1，
 2，3，4，4， 4，4，4，4，4，5，5，6，6]； 
  

您将如何获取这些项的每个组合的列表，请记住顺序完全不重要（因此 [1,2,3] == [3,2,1] ），并且结果中并非每个项目都必须存在。 / p>

我想输出看起来像这样：

  [1] 
 [1，1] 
 [1，2] 
 [1，3] 
 ... 
  

，甚至更好：

  {1：1} // 1 x item1 
 {1：2} // 2 x item1 
 {1：1，2：1：1} // 1 x item1，1 x item2 
 {1，1，3：1 } 
 .... 
  

解决方案

我认为

我将在此处递增：
从空开始，并在可能的情况下添加项目1。完成后，删除所有1，然后添加2，然后再次开始添加。当它们达到容量时，将其全部删除，再添加2个，然后重新开始。当2s达到容量时，删除它们并添加3。依此类推...

像数字一样的Kinda起作用。

---

好​​吧，让我们尝试编码...带递增整数键的哈希是一个数组;-)
假设数组的第一个元素是

这是javaScript：

  var限制= [1、3、5、2]； 
 
 function out（arr）{
 var text =’’; 
 for（var i = 0; i< arr.length; i ++）{
 text + = arr [i] +'。'
} 
 var log = document。 getElementById（'log'）; 
 var p = document.createElement（’p’）; 
 log.appendChild（p）; 
 p.innerHTML =’< span>’+文字+’< / span>’; 
} 
 
函数generateNextSet（set）{
 for（var i = 0; i  var amount = set [i ]; 
 if（金额+ 1>限制[i]）{
 set [i] = 0; 
}否则{
 set [i] =金额+ 1； 
返回集； 
} 
} 
返回false； 
} 
 
函数generateSets（）{
 var initial_set = [0，0，0，0] 
 var set = generateNextSet（initial_set）; 
 out（set）; 
 while（set = generateNextSet（set））{
 out（set）; 
} 
}; 
  

将ID为'log'的div添加到文档中，并以某种方式启动 generateSets（） 方法来检查输出。

I have a list of items, and each item has a quantity.

var items = {
    1: 12,   // we have 12 x item1
    2: 1,    // we have 1 x item2
    3: 1,
    4: 7,
    5: 2,
    6: 2
};

Alternatively this could be viewed as:

var items = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
             2, 3, 4, 4, 4, 4, 4, 4, 4, 5, 5, 6, 6];

How would you go about obtaining a list of every combination of these items, keeping in mind that the order is entirely unimportant (and hence [1,2,3] == [3,2,1]), and that not every item has to exist in the result.

I suppose the output could look like this:

[1]
[1, 1]
[1, 2]
[1, 3]
...

or, even better:

{1 : 1}          // 1 x item1
{1 : 2}          // 2 x item1 
{1 : 1, 2 : 1}   // 1 x item1, 1 x item2
{1 : 1, 3 : 1}
....

解决方案

I assume that quantity of each item is limited.

I'd go with incremental here: Start with empty and add item 1 while possible. When done, remove all 1s and add a 2 and start adding ones again. When ones reach capacity, remove them all, add another 2 and start again. When 2s reach capacity, remove them and add a 3. And so on...

Kinda like numbers work.

---

Ok, let's try to code... Hash with incrementing integer keys is an array ;-) It's easier to assume that first element of the array is the right digit of out 'floating radix' number.

This is javaScript:

var limits = [1, 3, 5, 2];

function out(arr){
  var text = '';
  for (var i=0; i < arr.length; i++){
    text += arr[i] + '.'
  }
  var log = document.getElementById('log');
  var p = document.createElement('p');
  log.appendChild(p);
  p.innerHTML = '<span>' + text + '</span>';
}

function generateNextSet(set){
  for (var i = 0; i < set.length; i++){
    var amount = set[i];
    if (amount + 1 > limits[i]){
      set[i] = 0;
    } else {
      set[i] = amount + 1;
      return set;
    }
  }
  return false;
}

function generateSets(){
  var initial_set = [0, 0, 0, 0]
  var set = generateNextSet(initial_set);
  out(set);
  while (set = generateNextSet(set)) {
    out(set);
  }
};

Add a div with id 'log' to the document and somehow start the generateSets() method to check out the output.

这篇关于计算系列的所有组合的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！