Count values between ranges - php

Question

I have two arrays, one of values, and the other for ranges:
$ranges = array(10,15,30);
$values = array(1,4,12,15,27,32);
I want to count the number of values in between each ranges, as such:
$output = array(
"<10" => 2, // number of values < 10
"10-15" => 1, // number of values >= 10 && < 15
"15-30" => 2, // number of values >= 15 && < 30
">=30" => 1, // number of values > 30
);
Obviously, ranges and values are dynamic and can't be hard-coded if-conditions.
What I made so far is working:
$output = array();
foreach ( $values as $val ) {
foreach ( $ranges as $k => $range ) {
if ( $k == 0 ) { // first range
$max = $range;
$label = '<' . $max;
if ( $val < $max ) {
$output[$label] += 1;
}
} else if ( $k == count($ranges) - 1 ) { // last range
$min = $ranges[$k-1];
$max = $range;
$label = $min . '-' . $max;
if ( $val >= $min && $val < $max ) {
$output[$label] += 1;
}
$min = $range;
$label = '>=' . $min;
if ( $val >= $min ) {
$output[$label] += 1;
}
} else {
$min = $ranges[$k-1];
$max = $range;
$label = $min . '-' . $max;
if ( $val >= $min && $val < $max ) {
$output[$label] += 1;
}
}
}
}
print_r($output);
This seems costly and I'm really not sure about it. Is there a simpler way to achieve what I'm looking for?

Answer 1

You can simplify the logic a bit by added limiting values to the beginning and end of the $ranges array and then just processing the whole array by pairs.
<?php
$ranges = [10,15,30];
$values = [1,4,12,15,27,32];
\array_push($ranges, null); // append null to array
\array_unshift($ranges, null); // prepend null to array
$output = [];
$count = \count($ranges);
for ($i = 0; $i < $count - 1; $i++) {
$output[] = ['start' => $ranges[$i], 'end' => $ranges[$i+1], 'count' => 0];
}
foreach ($values as $value) {
foreach ($output as $key => $range) {
if (
($range['start'] === null || $range['start'] <= $value) &&
($range['end'] === null || $range['end'] > $value)
) {
$output[$key]['count']++;
break;
}
}
}
var_dump($output);

Answer 2

This starts off by creating a zeroed array with the keys from the $ranges array (using array_fill_keys()), plus one for the values 'over' the last entry.
The loops over each value and checks it against the range, if it finds it, it just adds 1 to the corresponding count and stops looking. If after finishing the loop, the value is greater than the last range, it adds 1 to the 'over' entry.
$ranges = array(10,15,30);
$values = array(1,4,12,15,27,32);
$rangeCount = array_fill_keys($ranges, 0);
$rangeCount[ "over" ] = 0;
foreach ( $values as $value ) {
foreach ( $ranges as $range ) {
if ( $value < $range ) {
$rangeCount [ $range ]++;
break;
}
}
if ( $value >= $range ) {
$rangeCount[ "over" ]++;
}
}
print_r($rangeCount);
which gives...
Array
(
[10] => 2
[15] => 1
[30] => 2
[over] => 1
)
Just to add an optimised version which only does one loop. But assumes the values are in ascending order. Each time it passes the 'current' range it moves onto the next output counter and the last part doesn't even loop for the over the top value, it subtracts the current count from the total count and does a break...
$currentRange = 0;
$numberValues = count($values);
$numberRanges = count($ranges);
$rangeCount = array_fill(0, $numberRanges, 0);
$rangeCount[ "over" ] = 0;
foreach ( $values as $count => $value ) {
if ( $value >= $ranges[$currentRange] ) {
$currentRange++;
if ( $currentRange >= $numberRanges ) {
$rangeCount[ "over" ] = $numberValues - $count;
break;
}
}
$rangeCount[$currentRange]++;
}
print_r($rangeCount);

Answer 3

The following solution first sorts the ranges in ascending/non-decreasing order.
Then, we create a range_map which is a collection of all possible ranges from $ranges.
Then, we loop over all values in $values and do a binary search over $ranges to get the exact range index a particular value belongs to. In the below code, exact index is stored in $low.
Then, we just collect the count by taking the range key from $range_map and incrementing it's counter by 1.
This is faster from nested looping since time complexity of nested looping is O(m*n) where m is size of $ranges and n is size of $values, whereas time complexity of current solution is O(m logm) + O(n logm) where m is size of $ranges and n is size of $values.
Snippet:
<?php
$ranges = array(10,15,30);
$values = array(1,4,12,15,27,32);
sort($ranges);
$range_map = [];
$ptr = 0;
foreach($ranges as $index => $value){
if($index === 0) $range_map[$ptr++] = "<" . $value;
if($index > 0) $range_map[$ptr++] = $ranges[$index - 1] . "-" . $value;
if($index === count($ranges) - 1) $range_map[$ptr++] = ">=" . $value;
}
$result = [];
foreach($values as $value){
$low = 0; $high = count($ranges) - 1;
while($low <= $high){
$mid = $low + intval(($high - $low) / 2);
if($value === $ranges[ $mid ]){
$low = $mid + 1;
break;
}else if($value < $ranges[ $mid ]){
$high = $mid - 1;
}else{
$low = $mid + 1;
}
}
if(!isset($result[$range_map[$low]])) $result[$range_map[$low]] = 0; // get the range key from range_map
$result[$range_map[$low]]++; // increment the value for that range
}
print_r($result);
Demo: https://3v4l.org/JcYBv

Answer 4

Assuming you have pre-sorted ranges and values.
<?php
$ranges = array(10,15,30);
$values = array(1,4,12,15,27,32);
$lower = null;
$i = 0;
$upper = $ranges[$i];
foreach($values as $item) {
if(!is_null($upper) && $item >= $upper) {
$lower = $upper;
$upper = $ranges[++$i] ?? null;
}
$result["$lower<$upper"][] = $item;
}
var_export(array_map('count', $result));
Output:
array (
'<10' => 2,
'10<15' => 1,
'15<30' => 2,
'30<' => 1,
)