Calculate closest matches from array value combinations - php

Question

I have an array of part lengths, for examples sake:-
array(150, 180, 270);
I then have a measurement ($a = 440)
I need to calculate the two closest possible combinations of lengths which are greater than $a without manually having to write hundreds of possible combinations in order to work it out.
So:
150
180
270
150 + 150
150 + 180
150 + 270
180 + 180
180 + 270
270 + 270
150 + 150 + 150
150 + 150 + 180
..and so on.
This will need to run for a set number of times, rather than just finding the first two matches and stopping, as 150 + 150 + 150 would be a closer match to $a than 270 + 270 but may run after.
edit: I also need to store the combination of parts which made up the match, preferably in an array.
I hope I've explained this well enough for somebody to understand.

Answer 1

As this is quite a resource heavy script, I thought it would be a good idea to give the option to generate the choices beforehand, then use that data to create a variable/object/sql script to permanently store the data. For instance, doing something like
SELECT * FROM combination_total WHERE size > YOUR_SIZE ORDER BY size ASC LIMIT 2;
The new script I have is similar, but it just generates an array of all combinations without any duplicates. Seems pretty quick again. Notice the $maxLength variable, which is currently set to 2000, which can be modified with your own largest possible size.
<?php
$partLengths = array(150, 180, 270);
$currentCombinations = array(
array(
'total' => 150,
'combination' => array(150)
),
array(
'total' => 180,
'combination' => array(180)
),
array(
'total' => 270,
'combination' => array(270)
)
);
$maxLength = 2000;
$largestSize = 0;
function generateCombination() {
global $currentCombinations, $largestSize, $partLengths;
$tmpCombinations = $currentCombinations;
foreach ($tmpCombinations as $combination) {
foreach ($partLengths as $partLength) {
$newCombination = $combination['combination'];
$newCombination[] = $partLength;
sort($newCombination);
$newCombinationTotal = array_sum($newCombination);
if (!combinationExists($newCombination)) {
$currentCombinations[] = array(
'total' => $newCombinationTotal,
'combination' => $newCombination
);
}
$largestSize = ($newCombinationTotal > $largestSize) ? $newCombinationTotal : $largestSize;
}
}
}
function combinationExists($combination) {
global $currentCombinations;
foreach ($currentCombinations as $currentCombination) {
if ($combination == $currentCombination['combination']) {
return true;
}
}
return false;
}
while ($largestSize < $maxLength) {
generateCombination();
}
// here you can use $currentCombinations to generate sql/object/etc
var_dump($currentCombinations);
?>

Answer 2

This code works out the closest combination above $a, and the next closest one after that. It removes duplicates to speed things up a bit. It's not mega-optimized but initial tests show it's not too bad, depending on the initial value of $a not being massive.
<?php
/* value in cm */
$a = 1020;
$partLengths = array(150, 180, 270);
$closestValue = array();
$secondClosest = array();
$currentCombinations = array(
array(
'total' => 150,
'combination' => array(150)
),
array(
'total' => 180,
'combination' => array(180)
),
array(
'total' => 270,
'combination' => array(270)
)
);
function getCombinations(&$currentCombinations, $partLengths,$a, &$closestValue, &$secondClosest) {
$tmpCombinations = $currentCombinations;
static $secondMatch = true;
for ($x=0;$x<count($partLengths);$x++) {
for ($y=0;$y<count($tmpCombinations);$y++) {
$newCombination = $tmpCombinations[$y]['combination'];
$newCombination[] = $partLengths[$x];
$newCombinationTotal = array_sum($newCombination);
sort($newCombination);
if (!combinationExists($currentCombinations, $newCombination, $newCombinationTotal)) {
$currentCombinations[] = array('total' => $newCombinationTotal, 'combination' => $newCombination);
}
if ($closestValue['total'] < $a) {
$oldGap = $a - $closestValue['total'];
$newGap = $a - $newCombinationTotal;
$newGap = ($newGap < 0) ? 0 - $newGap : $newGap;
if ($newGap < $oldGap) {
$secondClosest = $closestValue;
$closestValue['total'] = $newCombinationTotal;
$closestValue['combination'] = $newCombination;
}
} else {
$oldGap = $a - $secondClosest['total'];
$newGap = $a - $newCombinationTotal;
$oldGap = ($oldGap < 0) ? 0 - $oldGap : $oldGap;
$newGap = ($newGap < 0) ? 0 - $newGap : $newGap;
if ($newCombinationTotal > $a && $newCombinationTotal > $closestValue['total']) {
if ($secondMatch || $newGap < $oldGap) {
$secondMatch = false;
$secondClosest['total'] = $newCombinationTotal;
$secondClosest['combination'] = $newCombination;
}
}
}
}
}
}
function combinationExists(&$currentCombinations, $newCombination, $newCombinationTotal) {
foreach ($currentCombinations as $currentCombination) {
if ($currentCombination['total'] != $newCombinationTotal && $currentCombination['combination'] != $newCombination) {
return false;
}
}
return false;
}
while ($secondClosest['total'] <= $a) {
getCombinations($currentCombinations, $partLengths, $a, $closestValue, $secondClosest);
}
var_dump($closestValue);
var_dump($secondClosest);
?>
A further suggestion, if speed does become an issue, is to pre generate all combinations and save them in some kind of hash/database/etc that you can easily access.

Answer 3

The following code is brute-force and tests only possible combinations of 2 values, so I know it's not complete. However, it is a start.
UPDATE: See my other answer, below, for a far better solution that works with any possible combination, not just 2, and that is optimized.
<?php
echo "<html><head><title>Test Array Sums</title></head><body>";
$testarray = array(2, 5, 9, 78, 332);
$target_value = 10;
$closest1 = 0;
$closest2 = 0;
$closest_sum = 0;
$closest_difference = 0;
$first_time_in_loop = TRUE;
foreach ($testarray AS $entry1)
{
foreach ($testarray AS $entry2)
{
if ($first_time_in_loop)
{
$first_time_in_loop = FALSE;
$closest1 = $entry1;
$closest2 = $entry2;
$closest_sum = $closest1 + $closest2;
$closest_difference = abs($target_value - $closest_sum);
}
$test_sum = $entry1 + $entry2;
if (abs($test_sum - $target_value) < $closest_difference)
{
if ($test_sum - $target_value >= 0)
{
// Definitely the best so far
$closest1 = $entry1;
$closest2 = $entry2;
$closest_sum = $closest1 + $closest2;
$closest_difference = abs($closest_sum - $target_value);
}
else if ($closest_sum - $target_value < 0)
{
// The sum isn't big enough, but neither was the previous best option
// and at least this is closer
$closest1 = $entry1;
$closest2 = $entry2;
$closest_sum = $closest1 + $closest2;
$closest_difference = abs($closest_sum - $target_value);
}
}
else
{
if ($closest_sum - $target_value < 0 && $test_sum - $target_value >= 0)
{
// $test_value is farther away from the target than the previous best option,
// but at least it's bigger than the target value (the previous best option wasn't)
$closest1 = $entry1;
$closest2 = $entry2;
$closest_sum = $closest1 + $closest2;
$closest_difference = abs($closest_sum - $target_value);
}
}
}
}
echo "Best pair: " . $closest1 . ", " . $closest2 . "<br />";
echo "</body></html>";
?>
Can you limit the total number of test values to 3 - or some larger number - or do you truly need to extend it to all possible combinations (i.e. if 4+4+5+4+4+5+3+5+4+5+3+4 is closer than 26+26, than you need to find it?)
If you can limit the number being tested to, say, 5, then you could just extend the loop above to handle up to 5 choices. Otherwise, a more sophisticated loop would need to be written.

Answer 4

Improving on my previous answer, here is a version that works to test any number of entries, up to a maximum number.
UPDATE: (Optimization added; see comments below)
For example, if the desired value is 15, and the list is (1, 17, 20), the best choice is 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1, so you would have to allow $max_loops, below, to be at least 15 in order to find this match - even though there are only 3 values in the list! It's worse for (1, 133, 138) where the desired value is, say, 130. In that case, you need 130 recursions! You can see that this is could be an optimization nightmare. But, the below algorithm works and is fairly well optimized.
<?php
echo "<html><head><title>Test Array Sums</title></head><body>";
$testarray = array(1, 3, 6);
$target_value = 10;
$current_closest_sum = 0;
$current_closest_difference = 0;
$first_time_in_loop = TRUE;
$max_loops = 10;
$current_loop = 0;
$best_set = array();
$current_set = array();
$sums_already_evaluated = array();
function nestedLoop($current_test = 0)
{
global $testarray, $target_value, $current_closest_sum, $current_closest_difference, $first_time_in_loop, $max_loops, $current_loop, $best_set, $current_set, $sums_already_evaluated;
++$current_loop;
foreach ($testarray AS $entry)
{
$current_set_temp = $current_set;
$current_set[] = $entry;
if ($first_time_in_loop)
{
$first_time_in_loop = FALSE;
$current_closest_sum = $entry + $current_test;
$current_closest_difference = abs($target_value - $current_closest_sum);
$best_set[] = $entry;
}
$test_sum = $entry + $current_test;
if (in_array($test_sum, $sums_already_evaluated))
{
// no need to test a sum that has already been tested
$current_set = $current_set_temp;
continue;
}
$sums_already_evaluated[] = $test_sum;
if ($test_sum > $target_value && $current_closest_sum > $target_value && $test_sum >= $current_closest_sum)
{
// No need to evaluate a sum that is certainly worse even by itself
$current_set = $current_set_temp;
continue;
}
$set_best = FALSE;
if (abs($test_sum - $target_value) < $current_closest_difference)
{
if ($test_sum - $target_value >= 0)
{
// Definitely the best so far
$set_best = TRUE;
}
else if ($current_closest_sum - $target_value < 0)
{
// The sum isn't big enough, but neither was the previous best option
// and at least this is closer
$set_best = TRUE;
}
}
else
{
if ($current_closest_sum - $target_value < 0 && $test_sum - $target_value >= 0)
{
// $test_value is farther away from the target than the previous best option,
// but at least it's bigger than the target value (the previous best option wasn't)
$set_best = TRUE;
}
}
if ($set_best)
{
$current_closest_sum = $test_sum;
$current_closest_difference = abs($current_closest_sum - $target_value);
$best_set = $current_set;
}
if ($current_loop < $max_loops)
{
if ($test_sum - $target_value < 0)
{
nestedLoop($test_sum);
}
}
$current_set = $current_set_temp;
}
--$current_loop;
}
// make array unique
$testarray = array_unique($testarray);
rsort($testarray, SORT_NUMERIC);
// Enter the recursion
nestedLoop();
echo "Best set: ";
foreach ($best_set AS $best_set_entry)
{
echo $best_set_entry . " ";
}
echo "<br />";
echo "</body></html>";
?>
UPDATE: I have added two small optimizations that seem to help greatly, and avoid the memory overload or hash-table lookup. They are:
(1) Track all previously evaluated sums, and do not evaluate them again.
(2) If a sum is (by itself) already worse than a previous test, skip any further tests with that sum.
I think, with these two optimizations, the algorithm may work quite well for realistic use in your situation.
PREVIOUS COMMENTS BELOW, NOW SOMEWHAT IRRELEVANT
My previous comments, below, are somewhat moot because the above two optimizations do seem to work quite well. But I include the comments anyways.
Unfortunately, as noted, the above loop is HIGHLY non-optimized. It would have to be optimized in order to work in a realistic situation, by avoiding duplicate tests (and other optimizations). However, it demonstrates an algorithm that works.
Note that this is a complex area mathematically. Various optimizations might help in one scenario, but not another. Therefore, to make the above algorithm work efficiently, you would need to discuss realistic usage scenarios - Will there be a limit on the largest length in the list of parts? What is the range of lengths? And other, more subtle features of the parts list & desired goal, though subtle, are likely to make a big difference in how to go about optimizing the algorithm.
This is a case where the "theoretical" problem isn't sufficient to yield a desired solution, since optimization is so critically important. Therefore, it's not particularly useful to make optimization suggestions.
Leonard's optimization, for example, (avoiding duplicates by saving all combinations previously tested) works well for a small-ish set, but the memory usage would explode for larger sets (as he noted). It's not a simple problem.
(code edited ~2 hours later to handle possible missed combination due to limiting the recursion to a certain number of recursions - by sorting the array from high to low, initially)