I am trying to build a simple algorithm to achieve the best combination of values based on two params in an array of objects.

The whole code is available here

First I have an array holding objects. The items which will be analyzed and packed into volumes together. All of the values are in percentages.

```
const nonStackableItems = (
{
id: 0,
m2: 15,
m3: 11,
weight: 20
},
{
id: 1,
m2: 25,
m3: 12,
weight: 42
},
{
id: 2,
m2: 50,
m3: 13,
weight: 40
},
{
id: 3,
m2: 65,
m3: 14,
weight: 25
}
);
```

The idea is to combine these objects into packages, respecting the `maximum`

of 100% for each value (except for `m3`

in this case, as all the packages should have enough `height`

in this first analysis).

The approach that I gave is just not good enough, as I am sorting this `array`

by `m2`

then by `weight`

, call the `function`

and then compare the length of both, and then choose the result that creates less volumes.

This is the piece of code that does the calculations:

```
function nSVolHelper(arr, vol, param1, param2) {
let newVol = {
id: vol.length,
m2: 0,
m3: 0,
weight: 0
};
for (let i = 0; i < arr.length; i++) {
const validation =
newVol(param1) + arr(i)(param1) < 100 &&
newVol.m2 + arr(i)(param2) < 100;
if (validation) {
newVol.m2 += arr(i).m2;
newVol.m3 += arr(i).m3;
newVol.weight += arr(i).weight;
}
if (!validation) {
return nSVolHelper(arr.slice(i), (...vol, newVol), param1, param2);
}
}
vol.push(newVol);
return vol;
}
function nSVol(arr, param1, param2) {
return nSVolHelper(arr, (), param1, param2);
}
```

I would like to find a way of doing this without taking as a base the order of the `array`

, to get the finest calculation without running unnecessary code, and I get the feeling that this approach of mine is just not reliable as well.

As an example, for better understanding:

If I pass the array sorted by `weight`

I get a create 2 volumes.

```
console.log(
"call",
nSVol(
nonStackableItems.sort((a, b) => a.weight - b.weight),
"weight",
"m2"
)
```

If I pass this same `array`

sorted by `m2`

I get 3 volumes.

```
console.log(
"call",
nSVol(
nonStackableItems.sort((a, b) => a.m2 - b.m2),
"weight",
"m2"
)
```

This was the best approach that I could find, but I feel that there could be another way of thinking of this.