Javascript 需要帮助获得尽可能多的独特啤酒吗

比如说，我有一个酒吧，汽车在去海滩之前停下来买啤酒。每辆车都有一个行李箱大小（

remaingsum

），每种啤酒都有一个大小（

beer.size

）

我想为客户提供啤酒组合选择（

allcombination

），让他们的汽车行李箱能够容纳，但组合独特

例如，输入：

let Beers = [ 
    {id: 1, size: 4},
    {id: 5, size: 1},
    {id: 10, size: 0.5},
    {id: 11, size: 1},
    {id: 12, size: 2},
    {id: 13, size: 1},
];

let TrunkSize = 2;

预期产量

AllCombinations = [ // no duplicates
    [{id: 5, size: 1}, {id: 10, size: 0.5}],
    [{id: 5, size: 1}, {id: 11, size: 1}],
    [{id: 5, size: 1}, {id: 13, size: 1}],
    [{id: 10, size: 0.5}, {id: 11, size: 1}],
    [{id: 10, size: 0.5}, {id: 13, size: 1}],
    [{id: 11, size: 1}, {id: 13, size: 1}],
    [{id: 5, size: 1}],
    [{id: 11, size: 1}],
    [{id: 12, size: 2}],
    [{id: 13, size: 1}],
    [{id: 10, size: 0.5}],
] 

电流输出

AllCombinations = [ 
    [{id: 5, size: 1}, {id: 10, size: 0.5}],  // dup a
    [{id: 5, size: 1}, {id: 11, size: 1}],    // dup c
    [{id: 5, size: 1}, {id: 13, size: 1}],    // dup d
    [{id: 10, size: 0.5}, {id: 5, size: 1}],  // dup a
    [{id: 10, size: 0.5}, {id: 11, size: 1}], // dup b
    [{id: 10, size: 0.5}, {id: 13, size: 1}], // dup e
    [{id: 11, size: 1}, {id: 13, size: 1}],   // dup f
    [{id: 11, size: 1}, {id: 10, size: 0.5}], // dup b
    [{id: 11, size: 1}, {id: 5, size: 1}],    // dup c
    [{id: 13, size: 1}, {id: 5, size: 1}],    // dup d
    [{id: 13, size: 1}, {id: 10, size: 0.5}], // dup e
    [{id: 13, size: 1}, {id: 11, size: 1}],   // dup f
    [{id: 5, size: 1}],
    [{id: 11, size: 1}],
    [{id: 12, size: 2}],
    [{id: 13, size: 1}],
    [{id: 10, size: 0.5}]
]

当前功能：

AllCombinations = [];
GetCombinations(currentCombination, beers, remainingSum) 
{ 

    if (remainingSum < 0) 
        return;// Sum is too large; terminate recursion

    else {
        if (currentCombination.length > 0) 
        {
            currentCombination.sort();  
            var uniquePermutation = true;

            for (var i = 0; i < this.AllCombinations.length; i++) 
            {
                if (currentCombination.length == this.AllCombinations[i].length) 
                {
                    for (var j = 0; currentCombination[j] == this.AllCombinations[i][j] && j < this.AllCombinations[i].length; j++);  // Pass

                    if (j == currentCombination.length) {
                        uniquePermutation = false; 
                        break;
                    }
                }
            }

            if (uniquePermutation)
                this.AllCombinations.push(currentCombination);
        }
    }

    for (var i = 0; i < beers.length; i++) {
        var newChoices = beers.slice();       
        var newCombination = currentCombination.concat(newChoices.splice(i, 1)); 
        var newRemainingSum = remainingSum - beers[i].size;
        this.GetCombinations(newCombination, newChoices, newRemainingSum);
    }
}

AllCombinations=[]；
获取组合（当前组合、啤酒、剩余金额）
{ 
如果（剩余总和<0）
return；//总和太大；终止递归
否则{
如果（currentCombination.length>0）
{
currentCombination.sort（）；
var uniquePermutation=true；
对于（var i=0；i

还有另一种方法：

let Beers = [ 
            {id: 1, size: 4},
            {id: 5, size: 1},
            {id: 10, size: 0.5},
            {id: 11, size: 1},
            {id: 12, size: 2},
            {id: 13, size: 1},
];

let TrunkSize = 2;

// get all combinations (stolen from http://stackoverflow.com/questions/5752002/find-all-possible-subset-combos-in-an-array )
function combinations(array) {
    return new Array(1 << array.length).fill().map(
        (e1,i) => array.filter((e2, j) => i & 1 << j));
}

// filter them out if the summed sizes are > trunksize
var valids = combinations(Beers).filter(function(el) {
  return el.reduce(function(a,b){return a+b.size;}, 0) <= TrunkSize;
});

console.log(valids);

let Beers=[
{id:1，大小：4}，
{id:5，大小：1}，
{id:10，大小：0.5}，
{id:11，大小：1}，
{id:12，大小：2}，
{id:13，大小：1}，
];
让树干大小=2；
//获取所有组合（从http://stackoverflow.com/questions/5752002/find-all-possible-subset-combos-in-an-array )
函数组合（数组）{
返回新数组（1个数组.过滤器（（e2，j）=>i&1个大小
var valids=组合（啤酒）。过滤器（功能（el）{
return el.reduce（函数（a，b）{return a+b.size；}，0）下面是另一种方法：

let Beers = [ 
            {id: 1, size: 4},
            {id: 5, size: 1},
            {id: 10, size: 0.5},
            {id: 11, size: 1},
            {id: 12, size: 2},
            {id: 13, size: 1},
];

let TrunkSize = 2;

// get all combinations (stolen from http://stackoverflow.com/questions/5752002/find-all-possible-subset-combos-in-an-array )
function combinations(array) {
    return new Array(1 << array.length).fill().map(
        (e1,i) => array.filter((e2, j) => i & 1 << j));
}

// filter them out if the summed sizes are > trunksize
var valids = combinations(Beers).filter(function(el) {
  return el.reduce(function(a,b){return a+b.size;}, 0) <= TrunkSize;
});

console.log(valids);

let Beers=[
{id:1，大小：4}，
{id:5，大小：1}，
{id:10，大小：0.5}，
{id:11，大小：1}，
{id:12，大小：2}，
{id:13，大小：1}，
];
让树干大小=2；
//获取所有组合（从http://stackoverflow.com/questions/5752002/find-all-possible-subset-combos-in-an-array )
函数组合（数组）{
返回新数组（1个数组.过滤器（（e2，j）=>i&1个大小
var valids=组合（啤酒）。过滤器（功能（el）{
返回el.reduce（函数（a，b）{返回a+b.size；}，0）若要获得所有可能的组合而不存在重复项，可以用一组N位来表示组合，其中N=#of若要获得所有可能的组合而不存在重复项，可以用一组N位来表示组合，其中N=#of我已经编辑了您的代码，修复了使用附加数组和字符串化进行排序和检查的问题：


let Beers=[
{id:1，大小：4}，
{id:5，大小：1}，
{id:10，大小：0.5}，
{id:11，大小：1}，
{id:12，大小：2}，
{id:13，大小：1}，
];
让树干大小=2；
所有组合=[]；
var combStrings=[]
函数GetCombinations（currentCombination、beers、remainingSum）
{ 
如果（剩余总和<0）
return；//总和太大；终止递归
否则{
如果（currentCombination.length>0）
{
currentCombination.sort（（a，b）=>{
返回a.id>b.id
});  
//var uniquePermutation=true；
var tmp=currentCombination.map（（cc）=>{
返回cc.id；
})
if（combStrings.indexOf（JSON.stringify（tmp））=-1）{
此.allcombines.push（当前组合）；
var tmp=currentCombination.map（（cc）=>{
返回cc.id；
})
push（JSON.stringify（tmp））
}
}
}
对于（变量i=0；ilog（所有组合，组合字符串）
我已经编辑了您的代码，修复了使用附加数组和字符串化进行排序和检查的问题：


let Beers=[
{id:1，大小：4}，
{id:5，大小：1}，
{id:10，大小：0.5}，
{id:11，大小：1}，
{id:12，大小：2}，
{id:13，大小：1}，
];
让树干大小=2；
所有组合=[]；
var combStrings=[]
函数GetCombinations（currentCombination、beers、remainingSum）
{ 
如果（剩余总和<0）
return；//总和太大；终止递归
否则{
如果（currentCombination.length>0）
{
currentCombination.sort（（a，b）=>{
返回a.id>b.id
});  
//var uniquePermutation=true；
var tmp=currentCombination.map（（cc）=>{
返回cc.id；
})
if（combStrings.indexOf（JSON.stringify（tmp））=-1）{
此.allcombines.push（当前组合）；
var tmp=currentCombination.map（（cc）=>{
返回cc.id；
})
push（JSON.stringify（tmp））
}
}
}
对于（变量i=0；i