simplier solution than iterating through all combinations - c++

Question

Designing a program given the following:
A initial array with a unknown length, with only 2’s and 6’s
Initial Array {2,2,2,2,2,2,6,6,6,6,6,6}
The goal is to find the fewest amount of arrays whose sum is less than or equal to 16 using the initial array
Wrong answer would be
4 arrays:
Array 1 {2,2,2,2,2,2}
Array 2 {6,6}
Array 3 {6,6}
Array 4 {6,6}
The correct answer would be
3 arrays:
Array 1 {6,6,2,2}
Array 2 {6,6,2,2}
Array 3 {6,6,2,2}
My solution is to step through each and every possible solution keeping track of the needed arrays. If the previous solution has the same amount of arrays or less than the current one throw the current one out. This seems a bit intensive due to the likely hood of comparing the difference in (6,6) and (6,6)…
I was reading on how to iterate through different combinations. Most of the articles related to poker and Im sure I could draw some similarities to blackjack(21).
I was hoping a “shortcut” might work here due to:
Possible entries are only 2’s & 6’s
Sums up to less than 16…Can’t go over
Final remark: I would love any info on how to proceed…logic..go read this..etc
Thanks,
Josh

Answer 1

A few notes on your problem before making any assumptions.
First, there are not many ways to arrange 6's and 2's to get a sum of 16. As a matter of fact, there are only 3 :
2*6+2*2 = 6+6+2+2
1*6+5*2 = 6+2+2+2+2+2
0*6+8*2 = 2+2+2+2+2+2+2+2
Second, you can sum up 2's to get 6's : 2+2+2 = 6
Third (comes from first), you cannot have more than 2 6's in an array.
Now, I think that the solution is pretty simple. However, I have no proof, so do not take my word for granted.
From second and third, I assume that you better get rid of 6's first. So you can pack them up by pairs in arrays like so : {6, 6, 2, 2}. If you do not have enough 2's to fill in, just do not fill in.
If you have an odd number of 6's, then the last one will appear in an array like so : {6, 2, 2, 2, 2, 2}.
Then you just need to fill in arrays of 2's if there are any left : {2, 2, 2, 2, 2, 2, 2, 2}.
Despite the fact that I have no proof (probably because I am lazy), it appear quite ovious to me that this is a solution, and it doesn't involve any kind of complicated combinatorics or so.
Mind to test it against the solution you describe ?
Edit :
Below are a correction of my comment and a proof that my solution is, indeed, a good solution.
Let us call n2 and n6 the number of 2's and 6's in the initial array, and sum the sum of elements in the initial array (6+6+...+2+2+...).
The number of arrays necessary is not ceil((3*n6 + n2)/8) = ceil(sum/16). It doesn't work if you have, for exemple, nine 6's and no 2 : it gives 4 instead of 5. This is because you cannot entirely fill an array with 6's (the sum would be 12, not 16), but you can with 2's. The correct formula would then be max(ceil(sum/16), ceil(n6/2)).
Now for the whole solution. Let us keep the notations n2, n6 and sum.
Consider your arrays as 16 meters long boxes (replace m with any linear unit you want), 2's as 2m long blocks and 6's as 6m long blocks. What you want in order to arrange all your blocks within the least boxes possible is to fit in each array the maximum length (not number) of blocks you can. This is pretty obvious : you need to fit sum meters in the least boxes of 16m.
So, the way to solve the problem is to fill up the boxes to the maximum. With 2's, it is easy : you can put eight 2m long blocks in one box. With 6's, you can only put two 6m long blocks in a box, without filling it up.
If you only have 6's, just put the maximum in every box (two in each), and you get your arrays. The number of arrays in that case is ceil(n6/2).
If you only have 2's, do the same (eight in each box). The number of arrays in this case is ceil(n2/8).
If you have both, you can pack two 6's and two 2's to fill up a box, so just do that ! We already know it is the best solution to fit the maximum length of blocks in each array, and you cannot do better than 16m = 2*6m + 2*2m.
When you run out of one kind of block, here is what to do.
If you run out of 6's, well you can fill up the rest of the boxes with 2's : you will get to the maximum of 16m for every next box until you run out of 2's, in which case you have floor(sum/16) boxes full, and maybe one partially filled. So the number of arrays in this case is ceil(sum/16).
If you run out of 2's, then discard every 2m long block you just put in boxes. What you have left is boxes with pairs of 6m long blocks, as if you didn't have any 2 to start with. Then you have your solution : put two 6m long blocks in every box. You can put back the 2's in the gaps left because you know they will not overflow. The number of arrays in this case is also ceil(n6/2).
Now, how to know the number of arrays necessary in every case ? Well, we have 3 possible formulas and need to take the maximum : ceil(n6/2), ceil(n2/8) and ceil(sum/16). But we know that ceil(n2/8) cannot be larger than ceil(sum/16), since sum = 6*n6 + 2*n2, sum/16 = 3/8 *n6 + n2/8, and 3/8 *n6 is not negative.
However, ceil(n6/2) might be larger than ceil(sum/16).
Exemple : n6 = 9, n2 = 0. Then ceil(n6/2) = 5 but ceil(sum/16) = 4
Finally, the correct formula is max(ceil(sum/16), ceil(n6/2)).

Answer 2

Since your objective deals with only 2s and 6s, you can use a greedy algorithm (since 6 is at least twice 2). That means you just take the largest number from your source numbers that still fits under 16 and add it to the current array. When no new number will fit, start a new array.
From that approach it seems clear that you can simplify this down to a formula in terms of the number of 2s and 6s in the source array: In other words you do one linear count of 2s and 6s, and then use a constant time formula to determine the number of arrays.