Two Sum problem but target is within a range - php

Question

I've encountered a problem similar to the old two sum problem but instead of solving for a value, it needs to be within a range, and I'm not sure how to efficiently approach this. Here is a simplified version of my problem:
Given an array of integers in order of preference, find the first two integers whose sum lies between the range of X and Y s.t. X <= sum <= Y (where X < Y and are known, i.e. arbitrarily X=20 and Y=40).
I've done a brute force approach using a for loop, but I'm unsure if this is the most performant solution. I've considered using a hash table, but I don't know how to apply it.
note: by order of preference I mean, the return the first two integers that fulfill this criteria

Answer 1

You could use the binary search method of resolving the 2 sum problem, and tweak your binary search function to search within a range. Something like this:
$arr = [1,2,4,6,8,14,15,17];
print_r(first_sum_in_range($arr, 25, 40));
function first_sum_in_range($array, $min, $max){
foreach ($array as $k=>$a) {
$b = binary_search_range($array, $a, $min, $max);
if ($b !== false) {
return [$a,$b];
}
}
}
function binary_search_range($array, $a, $min, $max) {
$top = sizeof($array) -1;
$bot = 0;
while($top >= $bot)
{
$p = floor(($top + $bot) / 2);
if ($a+$array[$p] < $min) $bot = $p + 1;
elseif ($a+$array[$p] > $max) $top = $p - 1;
else return $array[$p];
}
return false;
}
OUTPUT:
Array
(
[0] => 8
[1] => 17
)

Answer 2

Add each element to a tree map with key as element and value as list of indices where that element occurs.
While adding element to tree map check if there is a submap whose keys range from X - current_element to Y - current_element both inclusive. If you have a submap your answer is [curr_element, A[first_index_of_submap's value_of_first_key] ]

Answer 3

Maybe this is the brute force method you've already tried, but I think this is the simplest way.
Starting with a subset of the first two elements, iterate subsets of increasing size comparing the sum of the value of each element in the subset and the value of the last element. When you find a sum within the range, you're done.
This will find the first pair of numbers within the range based on the definition of "first" being "the pair with the lowest maximum index".
function findFirstSumInRange(int $min, int $max, array $values = []): array
{
for ($b = 1, $n = count($values); $b < $n; $b++) {
for ($a = 0; $a < $b; $a++) {
if ($min <= ($sum = $values[$a] + $values[$b]) && $sum <= $max) {
return [$values[$a], $values[$b]];
// or return [$a => $values[$a], $b => $values[$b]]; if you need the keys as well
}
}
}
return [];
}
You can make it faster by skipping any values that are already greater than the upper limit of the range.
function findFirstSumInRangeB(int $min, int $max, array $values = []): array
{
for ($b = 1, $n = count($values); $b < $n; $b++) {
if ($values[$b] < $max) { // else these sums will all be > the range because one addend is
for ($a = 0; $a < $b; $a++) {
if ($values[$a] < $max && $min <= ($sum = $values[$a] + $values[$b]) && $sum <= $max) {
return [$a => $values[$a], $b => $values[$b]];
}
}
}
}
return [];
}
Regarding "the most performant solution", I'd prefer to go for simplicity rather than optimizing for performance unless the performance is causing problems. Just my opinion.