Bestimmen Sie, ob sich zwei Datumsbereiche überschneiden.

Question

Angenommen, wir haben Bereiche, die durch DateTime-Variablen StartDate1 bis EndDate1 und StartDate2 bis EndDate2 bezeichnet sind.

Answer 1

(StartA <= EndB) und (EndA >= StartB)

Beweis:
Nehmen wir an, Bedingung A bedeutet, dass der Datumsbereich A vollständig nach dem Datumsbereich B liegt

_                        |---- Datumsbereich A ------|
|---Datumsbereich B -----|                          _

(Wahr, wenn StartA > EndB)

Nehmen wir an, Bedingung B bedeutet, dass der Datumsbereich A vollständig vor dem Datumsbereich B liegt

|---- Datumsbereich A -----|                        _ 
_                          |---Datumsbereich B ----|

(Wahr, wenn EndA < StartB)

Dann besteht eine Überlappung, wenn weder A noch B wahr sind -
(Wenn ein Bereich weder vollständig nach dem anderen liegt,
noch vollständig vor dem anderen, dann müssen sie sich überlappen.)

Nun besagt eines von De Morgan's laws:

Nicht (A Oder B) <=> Nicht A Und Nicht B

Was übersetzt bedeutet: (StartA <= EndB) und (EndA >= StartB)

---

HINWEIS: Dies beinhaltet Bedingungen, bei denen die Ränder genau überlappen. Wenn Sie das ausschließen möchten,
ändern Sie die >= Operatoren in > um, und <= in <

---

HINWEIS2. Dank an @Baodad, siehe dieses Blog, die tatsächliche Überlappung ist am wenigsten von:
{ endA-startA, endA - startB, endB-startA, endB - startB }

(StartA <= EndB) und (EndA >= StartB) (StartA <= EndB) und (StartB <= EndA)

---

HINWEIS3. Dank an @tomosius, eine kürzere Version lautet:
DateRangesOverlap = max(start1, start2) < min(end1, end2)
Dies ist eigentlich eine syntaktische Abkürzung für eine längere Implementierung, die zusätzliche Überprüfungen enthält, um zu überprüfen, dass die Startdaten auf oder vor den Enddaten liegen. Abgeleitet aus obigem:

Wenn Start- und Enddaten in umgekehrter Reihenfolge sein können, d.h., wenn es möglich ist, dass startA > endA oder startB > endB ist, müssen Sie auch überprüfen, ob sie in der richtigen Reihenfolge sind. Das bedeutet, dass Sie zwei zusätzliche Gültigkeitsregeln hinzufügen müssen:
(StartA <= EndB) und (StartB <= EndA) und (StartA <= EndA) und (StartB <= EndB) oder:
(StartA <= EndB) und (StartA <= EndA) und (StartB <= EndA) und (StartB <= EndB) oder:
(StartA <= Min(EndA, EndB) und (StartB <= Min(EndA, EndB)) or:
(Max(StartA, StartB) <= Min(EndA, EndB)

Aber um Min() und Max() zu implementieren, müssen Sie codieren (mit C-Ternary für Kürze):
((StartA > StartB) ? StartA : StartB) <= ((EndA < EndB) ? EndA : EndB)

Answer 2

Ich glaube, dass es ausreicht zu sagen, dass die beiden Bereiche sich überschneiden, wenn:

(StartDate1 <= EndDate2) und (StartDate2 <= EndDate1)

Answer 3

Dieser Artikel Zeitperiodenbibliothek für .NET beschreibt die Beziehung von zwei Zeitperioden anhand der Aufzählung PeriodRelation:

// ------------------------------------------------------------------------
public enum PeriodRelation
{
    After,
    StartTouching,
    StartInside,
    InsideStartTouching,
    EnclosingStartTouching,
    Enclosing,
    EnclosingEndTouching,
    ExactMatch,
    Inside,
    InsideEndTouching,
    EndInside,
    EndTouching,
    Before,
} // enum PeriodRelation

Answer 4

Für Überlegungen zu zeitlichen Beziehungen (oder zu anderen Intervallbeziehungen) könnte Allens Intervallalgebra von Interesse sein. Es beschreibt die 13 möglichen Beziehungen, die zwei Intervalle zueinander haben können. Weitere Referenzen finden Sie unter dem Suchbegriff „Allen Intervall“. Informationen zu diesen Operationen finden Sie auch bei Snodgrass in Die Programmierung zeitbezogener Anwendungen in SQL (PDF online verfügbar unter der URL), und bei Date, Darwen und Lorentzos in Zeitdaten und das relationale Modell (2002) oder in Zeit und Relationale Theorie: Zeitliche Datenbanken im relationalen Modell und SQL (2014; effektiv die zweite Ausgabe von TD&RM).

---

Die kurze (in etwa) Antwort ist: Gegeben zwei Datumsintervalle A und B mit den Komponenten .start und .end sowie der Einschränkung .start <= .end, dann überlappen sich zwei Intervalle, wenn:

A.end >= B.start AND A.start <= B.end

Sie können die Verwendung von >= vs > und <= vs < anpassen, um Ihre Anforderungen an den Überlappungsgrad zu erfüllen.

---

ErikE kommentiert:

Sie kommen nur auf 13, wenn Sie die Dinge seltsam zählen... Ich komme auf "15 mögliche Beziehungen, die zwei Intervalle haben können", wenn ich etwas verrückt werde. Durch vernünftiges Zählen erhalte ich nur sechs, und wenn Sie darauf verzichten, ob A oder B zuerst kommt, erhalte ich nur drei (keine Überschneidung, teilweise Überschneidung, eines vollständig im anderen). 15 wäre so: [before:before, start, within, end, after], [start:start, within, end, after], [within:within, end, after], [end:end, after], [after:after].

Ich denke, dass die beiden Einträge 'before:before' und 'after:after' nicht gezählt werden können. Ich könnte 7 Einträge sehen, wenn Sie bestimmte Beziehungen mit ihren Inversen gleichsetzen (siehe das Diagramm unter der in der referenzierten Wikipedia-URL; es enthält 7 Einträge, von denen 6 ein unterschiedliches Inverses haben, wobei Gleichheit kein eigenständiges Inverses hat). Und ob drei sinnvoll sind, hängt von Ihren Anforderungen ab.

----------------------|-------A-------|----------------------
    |----B1----|
           |----B2----|
               |----B3----|
               |----------B4----------|
               |----------------B5----------------|
                      |----B6----|
----------------------|-------A-------|----------------------
                      |------B7-------|
                      |----------B8-----------|
                         |----B9----|
                         |----B10-----|
                         |--------B11--------|
                                      |----B12----|
                                         |----B13----|
----------------------|-------A-------|----------------------

Answer 5

Wenn der Überlapp selbst ebenfalls berechnet werden soll, können Sie die folgende Formel verwenden:

Überlapp = max(0, min(EndDate1, EndDate2) - max(StartDate1, StartDate2))
if (overlap > 0) { 
    ...
}