Ermitteln, ob sich zwei Zeitbereiche überlappen

Question

Ich schreibe ein Scheduling-Programm mit einem Algorithmus. Auf der letzten Stufe des Algorithmus muss ich in den Stundenplan (den erstellten Stundenplan) schauen, um zu sehen, ob der Student zu diesem Zeitpunkt bereits einer Klasse zugeordnet ist.

Deshalb haben wir:

Current Class Start Time: (2017, 02, 09, 10, 00, 00) 
Current Class Finish Time: (2017, 02, 09, 11, 00, 00) 

In diesem Moment, wo wir den Zeitplan suchen, um zu sehen, was Schüler anderer Klassen A zugeordnet:

Zum Beispiel, lassen Sie uns am selben Tag sagen sie sind bereits zugeordnet:

Class 'Z' Start Time: (2017, 02, 09, 09, 00, 00) 
Class 'Z' Finish Time: (2017, 02, 09, 12, 00, 00) 

Jetzt möchte ich den Zeitbereich der Klasse ‚Z‘ finden und es mit dem Zeitbereich der aktuellen Klasse zu vergleichen.

DateTime startClassZ = new DateTime(2017, 02, 09, 09, 00, 00); 
DateTime endClassZ = new DateTime(2017, 02, 09, 12, 00, 00); 

DateTime StartCurrent = new DateTime(2017, 02, 09, 10, 00, 00); 
DateTime StartCurrent = new DateTime(2017, 02, 09, 11, 00, 00); 

if (They do not clash) 
{ 
    Assign 
} 
if (Clash) 
{ 
    Select Another Student 
} 

Könnte jemand bitte helfen Sie mir mit meinen 'WENN Aussagen' und auch, wie man dieses Problem löst.

Die Art und Weise, die ich von ihm denke, gibt es drei Möglichkeiten:

1. Wenn 'aktuelle Klasse' (Start und Endzeit) landet in zwischen 'Klasse Z' (Clash 1)
2. Wenn die von ‚aktuellen Klasse‘ landet dazwischen ‚Klasse Z‘ (Clash 2)
3. Wenn die ‚Endzeit‘ der ‚aktuelle Klasse‘ landet dazwischen ‚Klasse Z‘ (Clash 3) ‚Startzeit‘

Danke

Answer 1

Dies ist der einfachste Weg, es zu tun:

public static bool HasOverlap(DateTime start1, DateTime end1, DateTime start2, DateTime end2) 
{ 
    return start1 < end2 && end1 > start2; 
} 

Oder wenn die Daten sind nicht unbedingt in der richtigen Start/Ende Reihenfolge:

public static bool HasOverlap(DateTime start1, DateTime end1, DateTime start2, DateTime end2) 
{ 
    return Min(start1, end1) < Max(start2, end2) && Max(start1, end1) > Min(start2, end2); 
} 

public static DateTime Max(DateTime d1, DateTime d2) 
{ 
    return d1 > d2 ? d1 : d2; 
} 

public static DateTime Min(DateTime d1, DateTime d2) 
{ 
    return d2 > d1 ? d1: d2; 
} 

Hinweis, wenn eine Klasse in 2 endet und der nächste beginnt um 2, es wird keine Überlappung geben. Da du über Klassen sprichst, gehe ich davon aus, dass du das so willst.

Testen Beispiel:

static void Main(string[] args) 
{ 
    DateTime startClassZ = new DateTime(2017, 02, 09, 09, 00, 00); 
    DateTime endClassZ = new DateTime(2017, 02, 09, 12, 00, 00); 

    DateTime StartCurrent = new DateTime(2017, 02, 09, 10, 00, 00); 
    DateTime EndCurrent = new DateTime(2017, 02, 09, 11, 00, 00); 


    if(HasOverlap(startClassZ, endClassZ, StartCurrent, EndCurrent)) 
    { 
     Console.WriteLine("clash"); 
    } 
    else 
    { 
     Console.WriteLine("yay"); 
    } 
    Console.Read(); 
} 

ich für Sie ein paar schnelle Tests hinzugefügt haben:

public static void Test1() 
{ 
    // Class A overlaps class B 
    DateTime aStart = DateTime.Parse("2017-01-01T09:00:00"); 
    DateTime aEnd = DateTime.Parse("2017-01-01T10:00:00"); 

    DateTime bStart = DateTime.Parse("2017-01-01T09:30:00"); 
    DateTime bEnd = DateTime.Parse("2017-01-01T11:00:00"); 

    bool isCorrect = HasOverlap(aStart, aEnd, bStart, bEnd) == true; 
    Console.WriteLine($"1: {isCorrect}"); 
} 

public static void Test2() 
{ 
    // Class A "surrounds" class B 
    DateTime aStart = DateTime.Parse("2017-01-01T09:00:00"); 
    DateTime aEnd = DateTime.Parse("2017-01-01T15:00:00"); 

    DateTime bStart = DateTime.Parse("2017-01-01T09:30:00"); 
    DateTime bEnd = DateTime.Parse("2017-01-01T11:00:00"); 

    bool isCorrect = HasOverlap(aStart, aEnd, bStart, bEnd) == true; 
    Console.WriteLine($"2: {isCorrect}"); 
} 

public static void Test3() 
{ 
    // Class B "surrounds" class A 
    DateTime aStart = DateTime.Parse("2017-01-01T09:30:00"); 
    DateTime aEnd = DateTime.Parse("2017-01-01T11:00:00"); 

    DateTime bStart = DateTime.Parse("2017-01-01T09:00:00"); 
    DateTime bEnd = DateTime.Parse("2017-01-01T15:00:00"); 

    bool isCorrect = HasOverlap(aStart, aEnd, bStart, bEnd) == true; 
    Console.WriteLine($"3: {isCorrect}"); 
} 

public static void Test4() 
{ 
    // Class A is before Class B 
    DateTime aStart = DateTime.Parse("2017-01-01T09:00:00"); 
    DateTime aEnd = DateTime.Parse("2017-01-01T11:00:00"); 

    DateTime bStart = DateTime.Parse("2017-01-01T11:00:00"); 
    DateTime bEnd = DateTime.Parse("2017-01-01T12:00:00"); 

    bool isCorrect = HasOverlap(aStart, aEnd, bStart, bEnd) == false; 
    Console.WriteLine($"4: {isCorrect}"); 
} 

public static void Test5() 
{ 
    // Class A is after Class B 
    DateTime aStart = DateTime.Parse("2017-01-01T12:00:00"); 
    DateTime aEnd = DateTime.Parse("2017-01-01T14:00:00"); 

    DateTime bStart = DateTime.Parse("2017-01-01T11:00:00"); 
    DateTime bEnd = DateTime.Parse("2017-01-01T12:00:00"); 

    bool isCorrect = HasOverlap(aStart, aEnd, bStart, bEnd) == false; 
    Console.WriteLine($"5: {isCorrect}"); 
} 

public static void Test6() 
{ 
    // Class B overlaps class A 
    DateTime bStart = DateTime.Parse("2017-01-01T09:00:00"); 
    DateTime bEnd = DateTime.Parse("2017-01-01T10:00:00"); 

    DateTime aStart = DateTime.Parse("2017-01-01T09:30:00"); 
    DateTime aEnd = DateTime.Parse("2017-01-01T11:00:00"); 

    bool isCorrect = HasOverlap(aStart, aEnd, bStart, bEnd) == true; 
    Console.WriteLine($"6: {isCorrect}"); 
} 

static void Main() 
{ 
    Test1(); 
    Test2(); 
    Test3(); 
    Test4(); 
    Test5(); 
    Test6(); 
    Console.Read(); 
} 

Answer 2

Sie bieten drei Möglichkeiten:

A) insgesamt currentClass ist in zClass

B) Start von currentClass ist in zClass

C) Ende des currentClass in zClass ist

Ich möchte darauf hinweisen, dass A) bedeutet dasselbe wie B) und C) kombiniert wird, somit keine besondere Aufmerksamkeit benötigt.Darüber hinaus wird, wenn Sie versuchen, eine einfache Skizze im Kopf (oder auf Papier) der Dauer der Klassen zu ziehen, dann sind die Bedingungen werden sich ganz natürlich aus Pop als:

clash = (endOfCurrentClass > startOfZClass) || (startOfCurrentClass < endOfZClass)

Was bleibt, ist darüber nachzudenken, Äquivalenz (zB endOfCurrentClass == startOfZClass), aber das hängt von anderen Einschränkungen ab (fügt Klassenzeiten Pausen zwischen Klassen ein? Sind sie in einem Raum? ...). Dies ist jedoch ein anderes Problem.

Answer 3

Sie müssen überprüfen: classZ mit Strom in diesem Fall

DateTime startClassZ = new DateTime(2017, 02, 09, 09, 00, 00); 
DateTime endClassZ = new DateTime(2017, 02, 09, 12, 00, 00); 

DateTime startCurrent = new DateTime(2017, 02, 10, 10, 00, 00); 
DateTime endCurrent = new DateTime(2017, 02, 09, 11, 00, 00); 

und Strom mit classZ

DateTime startClassZ = new DateTime(2017, 02, 09, 09, 00, 00); 
DateTime endClassZ = new DateTime(2017, 02, 09, 12, 00, 00); 

DateTime startCurrent = new DateTime(2017, 02, 08, 10, 00, 00); 
DateTime endCurrent = new DateTime(2017, 02, 09, 13, 00, 00); 

Voll Code ist hier:

DateTime startClassZ = new DateTime(2017, 02, 09, 09, 00, 00); 
DateTime endClassZ = new DateTime(2017, 02, 09, 12, 00, 00); 

DateTime startCurrent = new DateTime(2017, 02, 08, 10, 00, 00); 
DateTime endCurrent = new DateTime(2017, 02, 09, 13, 00, 00); 


bool ClashCurrentStart = startClassZ < startCurrent && startCurrent < endClassZ; 
bool ClashCurrentEnd = startClassZ < endCurrent && endCurrent < endClassZ; 
//bool ClashCurrentBetween = ClashCurrentStart && ClashCurrentEnd; 

bool ClashClassZStart = startCurrent < startClassZ && startClassZ < endCurrent; 
bool ClashClassZEnd = startCurrent < endClassZ && endClassZ < endCurrent; 
//bool ClashClassZBetween = ClashClassZStart && ClashClassZEnd; 


bool Clash = ClashCurrentStart || ClashCurrentEnd || ClashClassZStart || ClashClassZEnd; 

if (!Clash) 
{ 
    //Assign 
} 
else // Clash 
{ 
    //Select Another Student 
}