#! /usr/bin/perl

use strict;
use warnings;
use Data::Dumper;

my @array;
while(my $line = <DATA>){
   push(@array,[split(/\&\&/,$line)];
}

my @uberschneidungen;
for(1..$#array){
  push(@uberschneidungen,[$array[$_-1]->[2],$array[$_]->[2]]) if($array[$_-1]->[1] > $array[$_]->[0]);
}

print "Anzahl: ",scalar(@uberschneidungen);
print Dumper(\@uberschneidungen);

_ _DATA_ _
0800&&0900&&Text
0930&&1015&&Text
1000&&1100&&Text
1045&&1145&&Text

#! /usr/bin/perl

use strict;
use warnings;
use Data::Dumper;

my @dates = ();
while(my $line = <DATA>) {
    my @parts = split(/&&/,$line);

    push @dates, {
        Start => $parts[0],
        End => $parts[1],
        Text  => $parts[2],
    };
}

my @colitions = ();
for(my $i = 0; $i < @dates; ++$i) {
    for(my $j = $i+1; $j < @dates; ++$j) {
        if($dates[$i]->{Start} >= $dates[$j]->{Start} && $dates[$i]->{End} <= $dates[$j]->{End} ||
           $dates[$j]->{Start} >= $dates[$i]->{Start} && $dates[$j]->{End} <= $dates[$i]->{End})
        {
            push @colitions, [{%{$dates[$i]}}, {%{$dates[$j]}}];
        }
    }
}

print "Anzahl: ", scalar @colitions, "\n",
print Dumper(\@colitions);

exit(0);

_ _DATA_ _
0800&&0900&&Eintrag1
0930&&1015&&Eintrag2
1000&&1100&&Eintrag3
1045&&1145&&Eintrag4
0800&&0830&&Eintrag5
0930&&1050&&Eintrag6
1051&&1141&&Eintrag7
1045&&1145&&Eintrag8

Vertex backtrackingColoring(const Graph &g, CSet &c)
{
    Vertex k = 0;
    bool success = false;
    
    while (!success) {
        ++k;
        success = kBacktracking(g, k, c);
    }

    return k;
} /* backtrackingColoring */ 

bool kBacktracking(const Graph &g, const Color k, CSet &c)
{
    if (k < 1)
        error("kBacktracking", "Farbe %d zu klein.", k);

    /**************************************************************************
    * Initialisierungen:                                                      *
    **************************************************************************/
    const Vertex n = g.getn();
    c.resize(n);
    for (Vertex i=0; i<n; ++i)
        c[i] = 0;

    /**************************************************************************
    * Aufruf der rekursiven Untersuchung:                                     *
    **************************************************************************/
    return btcTry(g, 0, k, c);
} /* kBacktracking */ 

bool btcTry(const Graph &g, const Vertex i, const Color k, CSet &c)
{
    /**************************************************************************
    * Initialisierungen:                                                      *
    **************************************************************************/
    const Vertex n = g.getn();
    Color color = 0;
    bool q = false;

    /**************************************************************************
    * Fehler abfangen:                                                        *
    **************************************************************************/
    if (i >= n)
        error("btcTry", "Ecke i = %d ist außerhalb des zulässigen Bereiches "
            "[0, %d]", i, n-1);
    if (k < 1 || k > static_cast<Color>(n))
        error("btcTry", "Farbe k = %d ist außerhalb des zulässigen Bereiches "
            "[1, %d]", k, n);

    /**************************************************************************
    * Schleife:                                                               *
    **************************************************************************/
    while (q == false && color != k) {
        ++color;
        /*** Abbruch, falls i==0 und color>1: ***/
        if (i == 0 && color > 1)
            break;
        if (btcPossible(g, i, color, c)) {
            c[i] = color;
            if (i < n-1) {
                q = btcTry(g, i+1, k, c);
                if (!q)
                    c[i] = 0;
            }
            else
                q = true;
        }
    }

    return q;
} /* btcTry */

bool btcPossible(const Graph &g, const Vertex i, const Color color,
    const CSet &c)
{
    VSet N;
    g.getNeighbours(i, N);
    for (Vertex j=0; j<N.size(); ++j)
        if (c[N[j]] == color)
            return false;

    return true;
} /* btcPossible */