Calculating the availiability of things in a time range - php

Question

the following situiation:
We have 3 things available at the same time.
The first is booked from 09:00 to 11:00.
The second is booked from 11:00 to 13:00
I want to calculate how much things are available from 10:00 to 12:00.
I've done it calculating how much things are booked in the range from 10:00 to 12:00.
It was 2. So the available things are 1.
But the first and the second could be the same. So the available things in the designated time are 2 and my calculation was wrong.
So I created the following algorithm to calculate the occupied things in a time range. the results came from a database query and contains the booking of things which are in my time range (result is an array and contains start,end and cnt which is the amount of booked things):
$blocks = array();
$times = array();
foreach($results as $result){
$block = array();
$block['start'] = DateTime::createFromFormat("Y-m-d H:i:s", $result['start'])->getTimestamp();
$block['end'] = DateTime::createFromFormat("Y-m-d H:i:s", $result['end'])->getTimestamp();
$block['things'] = $result['cnt'];
$blocks[] = $block;
$times[] = $block['start'];
$times[] = $block['end'];
}
$times = array_unique($times);
$times = array_values($times);
$peak = 0;
foreach($times as $time){
$timePeak = 0;
foreach($blocks as $block){
if($time >= $block['start'] && $time <= $block['end']){
$timePeak += $block['things'];
}
}
if($timePeak > $peak){
$peak = $timePeak;
}
}
return $peak;
}
whith this method, I am creating timestamps for every start and endtime of every booking in this range.
Then I have calculated the sum of all bookings of every timestamp. The maximum of the calculations (peak) was the maximum amount of bookings. So the available things are max - peak.
It works.
But is there a more elegant way to calculate it?

Answer 1

Sounds similar to this common coding interview problem: https://www.geeksforgeeks.org/find-the-point-where-maximum-intervals-overlap/
If your "max things" is hardcoded then yeah I think you find the maximum booking of things during the given time and subtract from the max to get minimum availability over the range. To do this, you need to consider all bookings that either start or end in your range. As the efficient solution on that link suggests, you sort the starts and ends and then go through them to see your running utilization.
To handle the boundary case you talked about where a booking ending lines up with a booking start, make sure your sorting of "starts" and "ends" always sorts an "end" before a "start" when the time is the same so that you don't get the appearance of an overlap where one doesn't really exist.
I'm assuming you are working on a table like this:
CREATE TABLE `bookings` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`start` datetime NOT NULL,
`end` datetime NOT NULL,
PRIMARY KEY (`id`)
);
And, you have data like this:
INSERT INTO `bookings` (`id`, `start`, `end`)
VALUES
(1, '2019-05-05 09:00:00', '2019-05-05 11:00:00'),
(2, '2019-05-05 11:00:00', '2019-05-05 13:00:00'),
(3, '2019-05-05 07:00:00', '2019-05-05 10:00:00'),
(4, '2019-05-05 12:00:00', '2019-05-05 14:00:00'),
(5, '2019-05-05 14:00:00', '2019-05-05 17:00:00'),
(6, '2019-05-05 10:30:00', '2019-05-05 11:30:00');
This data has all the relevant cases you need to consider:
Bookings that end before your range
Bookings that start after your range
Bookings that intersect the start of your range
Bookings that intersect the end of your range
Bookings contained entirely within your range
Bookings that "hand-off" within your range
I looked at making a SQL query for this but stopped when it got more complicated than you would actually want to code in SQL. I think it's probably do-able but requires really ugly SQL. Definitely do this in code. I think the algorithm is to load all bookings relevant to your range with a query like:
SELECT * FROM bookings
WHERE start BETWEEN :start AND :end
OR end BETWEEN :start AND :end
That's all the bookings that will possibly matter. Then you sort the start and end events as distinct events as described earlier and loop over the list of events keeping a running counter going as well as a max value seen so far. The running count will first go up and at the end it will go back down to zero, but may have multiple peaks in the middle. So, you can't just stop the first time it goes down, you have to keep scanning until you get through all the events (or at least to your end time, but simpler and no real cost to just go all the way through the list). Once done, you've got the maximum number of concurrent bookings.
I haven't tested or compiled this, so take it as psuedo-code. I'd change your code to something like this:
//assumedly, prior to this point you have a
//$startTime and $endTime that you used to do the query mentioned above
//and the results of the query are in $results
$times = array();
foreach($results as $result){
$time = array();
$time['time'] = DateTime::createFromFormat("Y-m-d H:i:s", $result['start'])->getTimestamp();
$time['change'] = $result['cnt'];
$times[] = $time;
$time['time'] = DateTime::createFromFormat("Y-m-d H:i:s", $result['end'])->getTimestamp();
$time['change'] = -1 * $result['cnt'];
$times[] = $time;
}
usort($times, function($lh, $rh) {
if ($lh['time'] === $rh['time']) {
return $lh['change'] - $rh['change']
} else {
return $lh['time'] < $rh['time'] ? -1 : 1;
}
}
$maxPeak = 0;
$curVal = 0;
foreach($times as $time){
//breaking early here isn't so much about optimization as it is about
//dealing with the instantaneous overlap problem where something starts
//right at the end time. You don't want that to look like a utilization
//that counts against you.
if ($time['time'] === $endTime) {
break;
}
$curVal += $time['change'];
if ($curVal > $maxPeak) {
$maxPeak = $curVal;
}
}
//$maxPeak is the max number of things in use during the period