CODEWITHSUNDEEP
c#asp.netlinqentity-framework
Christopher Rayl
Christopher Rayl

Reputation: 329

How do I find the intersect of two sets of non-contiguous Times?

I am trying to build a tool that calculates something called quota based upon when employees are scheduled to work and when they request off.

My ShiftSet object is a set of Shift objects which consist of a StartTime and EndTime (both of type time(7). Each ShiftSet corresponds to a day.

ScheduleExceptions are times that an employee has off. There can be any number of overlapping or non-overlapping ScheduleExceptions in a day. They are of the datetime data type.

An example of a ShiftSet:
08:00-10:00
10:00-12:00
13:00-15:00
15:00-17:00

An example of ScheduleExceptions for that same day:
07:30-10:30
14:35-16:00

What I need to do is to find the amount of time that the employee is working on a day. The way I can figure to do this is to calculate the intersection of ShiftSet and the inverse of ScheduleExceptions.

How would I do this with time? I would prefer to use Linq if possible.

Upvotes: 7

Views: 1031

Answers (4)

Alexandros B
Alexandros B

Reputation: 1891

A very crude solution would be something like

void Main()
{
    var workTime = new List<ShiftSet> {
        new ShiftSet{StartTime= new TimeSpan(8,0,0),EndTime= new TimeSpan(10,0,0)},
        new ShiftSet{StartTime= new TimeSpan(10,0,0),EndTime= new TimeSpan(12,0,0)},
        new ShiftSet{StartTime= new TimeSpan(13,0,0),EndTime= new TimeSpan(15,0,0)},
        new ShiftSet{StartTime= new TimeSpan(15,0,0),EndTime= new TimeSpan(17,0,0)}
        };


    var missingTime= new List<ShiftSet> {
        new ShiftSet{StartTime= new TimeSpan(7,30,0),EndTime= new TimeSpan(10,30,0)},
        new ShiftSet{StartTime= new TimeSpan(14,35,0),EndTime= new TimeSpan(16,0,0)}
        };


    Console.WriteLine(workTime.Sum(p=>p.Shift()) - missingTime.Sum(p=>p.Shift()));
}


public class ShiftSet 
{
    public TimeSpan StartTime {get;set;}
    public TimeSpan EndTime {get;set;}

    public double Shift() {return (EndTime-StartTime).TotalMinutes;}
}

I calculate a worktime in minutes so I can sum more easily using linq

I am also missing specific shift information which I think don't belong with ShiftSet class

Because the employee is not scheduled to work from 7:30 to 8:00, we would not include that time

Upvotes: 0

Saeed Amiri
Saeed Amiri

Reputation: 22555

I didn't test bellow code, may be there is some bugs, Also I wrote it in textpad may be there are invalid characters, Idea is simple, and I try to use meaningful variables.

var orderedShifts = ShiftSets.OrderBy(x=>x.StartDate).ToList();

var compactShifts = new List<Shift>();
compactShifts.Add(orderedShifs[0]);

foreach (var item in orderedShift)
{
    if (item.Start <= compactShifts[compactShifts.Count-1].End 
        && item.End > compactShifts[compactShifts.Count-1].End)
    {
        compactShifts[compactShifts.Count-1].End = item.End;
    } 
    else if (item.Start > compactShifts[compactShifts.Count-1].End)
      compactShifts.Add(item);
}  

//run similar procedure for schedule exceptions to create compact schedules.

var validShifts = new List<Shift>();

foreach (var item in compactShifts)
{
   var shiftCheatingPart = compactExceptions
                          .FirstOrDefault(x=>x.Start < item.Start 
                                         && x.End > item.End)
   if (shiftCheatingPart != null)
   {
       if (item.End <= shiftCheatingPart.End)
         continue;

       validShifts.Add(new Shift{Start = shiftCheatingPart.End,End = item.End);
   }
}

var totalTimes = validShifts.Sum(x=>x.End.Sunbtract(x.Start).TotalHours);

Upvotes: 0

CassOnMars
CassOnMars

Reputation: 6181

As InBetween mentioned, there are libraries out there that have solved this problem, but they solve many related problems as well. If you are wanting to just tackle this particular problem without taking on another dependency, you can try the following.

// Finds ones with absolutely no overlap
var unmodified = shifts.Where(s => !exceptions.Any(e => s.Start < e.End && s.End > e.Start));

// Finds ones entirely overlapped
var overlapped = shifts.Where(s => exceptions.Any(e => e.End >= s.End && e.Start <= s.Start));

// Adjusted shifts
var adjusted = shifts.Where(s => !unmodified.Contains(s) && !overlapped.Contains(s))
                        .Select(s => new Shift
                        {
                            Start = exceptions.Where(e => e.Start <= s.Start && e.End > s.Start).Any() ? exceptions.Where(e => e.Start <= s.Start && e.End > s.Start).First().End : s.Start,
                            End = exceptions.Where(e => e.Start < s.End && e.End >= s.End).Any() ? exceptions.Where(e => e.Start < s.End && e.End >= s.End).First().Start : s.End
                        });

var newShiftSet = unmodified.Union(overlapped).Union(adjusted);

It's a basic example, though it could be compacted (albeit less-readable) and improved.

Upvotes: 2

InBetween
InBetween

Reputation: 32760

Check out this great article at CodeProject

It's probably way too broad for your specific problem but it will probably give you a good starting point on how to solve it.

Upvotes: 3

Related Questions