根据星期几确定重叠的时间范围

Question

I have an array of time ranges like this:-

$events = array(
    array("Monday", '19:00:00', '19:30:00', 0),
    array("Monday", '19:10:00', '19:40:00', 0),
    array("Tuesday", '19:10:00', '19:40:00', 0),
    array("Wednesday", '19:10:00', '19:40:00', 0),
    array("Monday", '19:30:00', '19:50:00', 0),
);

I am using bubble sort on the array:-

for($i = 0; $i < (count($events) - 1); $i++)
{
    for($j = 1; $j < (count($events) - i - 1); $j++)
    {
        if($events[$i][0] < $events[$j][0])
        {
            if ($events[$j] > $events[($j + 1)]) 
              {
                $swap       = $events[$j];
                $events[$j]   = $events[($j + 1)];
                $events[($j + 1)] = $swap;
              }
        }
    }
}

The result comes like this:-

Array ( 
    [0] => Array ( 
                    [0] => Monday 
                    [1] => 19:00:00 
                    [2] => 19:30:00
                    [3] => 0)
    [1] => Array ( 
                    [0] => Monday 
                    [1] => 19:10:00 
                    [2] => 19:40:00
                    [3] => 0) 

    [2] => Array ( 
                    [0] => Monday 
                    [1] => 19:30:00 
                    [2] => 19:50:00
                    [3] => 0)

    [3] => Array ( 
                    [0] => Tuesday 
                    [1] => 19:10:00 
                    [2] => 19:40:00
                    [3] => 0)

    [4] => Array ( 
                    [0] => Wednesday 
                    [1] => 19:10:00 
                    [2] => 19:40:00
                    [3] => 0)
)

Now I need to strike out those time ranges which overlap on a specific day.

Like this:

Array ( 
[0] => Array ( 
                [0] => Monday 
                [1] => 19:00:00 
                [2] => 19:30:00
                [3] => 1) 
[1] => Array ( 
                [0] => Monday 
                [1] => 19:10:00 
                [2] => 19:40:00
                [3] => 1)

[2] => Array ( 
                [0] => Monday 
                [1] => 19:30:00 
                [2] => 19:50:00
                [3] => 1)


[3] => Array ( 
                [0] => Tuesday 
                [1] => 19:10:00 
                [2] => 19:40:00 
                [3] => 0) 

[4] => Array ( 
                [0] => Wednesday 
                [1] => 19:10:00 
                [2] => 19:40:00
                [3] => 0)

)

The ones which are [3] => 1, denote there is a time overlap conflict.

How can I proceed?

I tried to use this solution , but got no luck. Besides, mine has a day of week.

Answer 1

I had a little play and this is what I came up with. It preserves the original order of the $events array as textual days don't sort well (Friday would come before Wednesday etc). A bit brute force, not optimised or properly tested, but hope it's useful for ideas.

foreach ($events as $event_id=>$event) {
    $days[$event[0]][]=[$event_id,$event[1],$event[2]];
}

foreach ($days as $dayevents) {
    if (count($dayevents)>1) {
        foreach ($dayevents as $dayevent1) {
            foreach ($dayevents as $dayevent2) {
                if ((($dayevent1[1]>$dayevent2[1]) and ($dayevent1[1]<$dayevent2[2])) or 
                    (($dayevent1[2]>$dayevent2[1]) and ($dayevent1[2]<$dayevent2[2]))) {
                    $events[$dayevent1[0]][3]=1;
                    $events[$dayevent2[0]][3]=1;
                }
            }
        }
    }
}

Answer 2

$events = array(
    array("Monday", '19:00:00', '19:30:00', 0),
    array("Monday", '19:10:00', '19:40:00', 0),
    array("Tuesday", '19:10:00', '19:40:00', 0),
    array("Wednesday", '19:10:00', '19:40:00', 0),
    array("Monday", '19:30:00', '19:50:00', 0),
);

$combined = array();
// first we collect all intervals for the given day
foreach($events as $record)
{
  $combined[$record[0]][] = array(
    $record[1], $record[2], 0
  );
}

// then for each day we look if there are overlaps
foreach($combined as $day => &$intervals)
{
  $len = count($intervals);
  // we compare each interval with each of the rest intervals for the same day
  foreach($intervals as $i => &$interval_1)
  {
    // we convert the start/end times of the interval A to an integer
    $begin_1 = str_replace(':','',$interval_1[0]);
    $end_1 = str_replace(':','',$interval_1[1]);
    for($k = $i + 1; $k < $len; $k++)
    {
      // we convert the start/end times of the interval B to an integer
      $begin_2 = str_replace(':','',$intervals[$k][0]);
      $end_2 = str_replace(':','',$intervals[$k][1]);      
      // we compute the overlap of the 2 intervals
      $overlap = max(0,$end_1 - $begin_1 - max(0,$end_1 - $end_2) - max(0,$begin_2 - $begin_1));
      if($overlap)
      {
        $interval_1[2]++; // we increase the counter of interval A
        $intervals[$k][2]++; // we increase the counter of interval B
      }
    }
  }
}

Answer 3

<?php

$events = array(
    array("Monday", '19:00:00', '19:10:00'),
    array("Monday", '19:05:00', '19:20:00'),
    array("Tuesday", '19:10:00', '19:40:00'),
    array("Wednesday", '19:10:00', '19:40:00'),
    array("Monday", '19:15:00', '19:30:00'),

);

function convertToSeconds($time){
    $time = explode(":",$time);
    return intval($time[0]) * 3600 + intval($time[1]) * 60 + intval($time[2]);
}


$time_ranges = [];
$hold_dates = [];
for($i=0;$i<=86401;++$i){
    $time_ranges[] = 0;
    $hold_dates[$i] = [];
}

$time_range_for_week = [];
$week_days = ['monday' ,'tuesday','wednesday','thursday','friday','saturday','sunday'];

foreach($week_days as $day){
    $time_range_for_week[$day] = [
        'hold_dates' => $hold_dates,
        'time_range' => $time_ranges
    ];
}

foreach($events as &$data){
    $start_time = convertToSeconds($data[1]);
    $end_time = convertToSeconds($data[2]);

    $time_range_for_week[strtolower($data[0])]['hold_dates'][$start_time][] = &$data;
    $time_range_for_week[strtolower($data[0])]['hold_dates'][$end_time][] = &$data;
    $time_range_for_week[strtolower($data[0])]['time_range'][$start_time] += 1;
    $time_range_for_week[strtolower($data[0])]['time_range'][$end_time + 1] -= 1;
}


foreach($time_range_for_week as $day_name => &$day_data){
    $sum = 0;
    foreach($day_data['time_range'] as $time => $value){
        $sum += $value;
        if($sum > 1 && count($day_data['hold_dates'][$time]) > 0){
            foreach($day_data['hold_dates'][$time] as &$each_event){
                $each_event[3] = 1;
            }
        }
    }
}


print_r($events);

Demo: https://3v4l.org/JeGdR

Algorithm:

• This is rather simple and efficient than basic brute force.

• To find out collisions between times, we first make an array of size 86400 for each day. 86400 because it is no. of seconds (24*60*60) for a day(like Monday or Tuesday etc).

• The array looks like this for a particular day(like Monday or Tuesday etc):

Structure:

Array
(
    [monday] => Array
        (
            [hold_dates] => Array
                (
                    [],[],[],... till 86400
                ),
            [time_range] => Array
                (
                    [],[],[],... till 86400
                ),
        ),
      [tuesday] => Array(
          ...
        ),
      ...
)

• In the hold_dates key for a day, we are just going to have our array values at the start time and end times positions. Here start time is the 1 ^st position(0-based indexing) in array("Monday", '19:10:00', '19:40:00', 0) and end time is 2 ^nd position in array("Monday", '19:10:00', '19:40:00', 0) . In the code, the lines look like:

Code:

 $time_range_for_week[strtolower($data[0])]['hold_dates'][$start_time][] = &$data;
 $time_range_for_week[strtolower($data[0])]['hold_dates'][$end_time][] = &$data;

The & is used for syncing updates with actual $events array, so it's a pass by reference.

• The time_range will just hold integer values and those integer values as explained below.

Let's consider intervals like below:

[2,7],
[4,9],
[6,10]

We have a timeline like below:

1  2  3  4  5  6  7  8  9  10 11 // these are seconds from 1 to 11
  +1                -1
        +1                 -1
              +1              -1
   1  1  2  2  3  3  2  2  1   0    

In the above diagram, for each date's start time, we add +1 , and -1 to it's end time + 1 . This means that, when we iterate from 1 to 11 and keep summing values, if we find any date's start time or end time having a sum > 1 , we found there is a collision and we need to set it's value to 1 .

• We do the same in the above code. Here, the space used for this code is 86400 * 7 = 604800 , which is constant space O(1) since this does not depend upon size of $events .

• Time complexity is again the constant iterations 86400 * 7 = 604800 + looping twice through each element in $events , which makes it O(n) where n is size of $events .