/*

You are given an array of time windows (represented by a string)

Return a list of the time windows that overlap. You may return the answer in any order  

​

Example input:

[

    "00:00-03:00",

    "15:00-17:00",

    "04:00-06:00", 

    "18:00-19:00",

    "05:00-07:00", 

    "08:00-12:00", 

    "09:00-10:00", 

    "18:00-19:00",

    "13:00-14:00", 

    "16:00-17:00", 

    "20:00-21:00"

]

Sample output: 

[

  "04:00-06:00",

  "05:00-07:00",

  "08:00-12:00",

  "09:00-10:00",

  "15:00-17:00",

  "16:00-17:00",

  "18:00-19:00",

  "18:00-19:00"

]

​

Constraints:

    windows.length <= 1000

    Each window[i] is a string in the form "HH:mm-HH:mm"

    Each window is a valid time using a 24 hour clock 

    Each window is within the same day --> for example will not be "23:00-01:30" 

    Overlaps are noninclusive --> "05:00-06:00" does not overlap "06:00-07:00"

Harder Constraints if time allows

    Windows can stretch over a day --> "23:00-01:30" is allowed 

*/

​

using System;

using System.Linq;

using System.Collections.Generic;

public static class Solution

{

    private static double TimeStringToDouble(string timewindow){

        var parts = timewindow.Split(':');

        var hour = Convert.ToInt32(parts[0]);

        var minute = Convert.ToInt32(parts[1]);

        return hour + (minute / 60);

    }

    public static List<string> FindOverlappingWindows(string[] windows)

    {

        List<(double Start, double End, string Window)> parsedWindows = new List<(double, double, string)>();

​

        foreach (var window in windows)

        {

            var parts = window.Split('-');

            var start = TimeStringToDouble(parts[0]);

            var end = TimeStringToDouble(parts[1]);

            parsedWindows.Add((start, end, window));

        }

​

        parsedWindows.Sort((a, b) => a.Item1.CompareTo(b.Item1));

​

        List<string> overlappingWindows = new List<string>();

        for (int i = 0; i < parsedWindows.Count - 1; i++)

        {

            if (parsedWindows[i].Start <= parsedWindows[i+1].End && parsedWindows[i].End >= parsedWindows[i+1].Start)

            {

                overlappingWindows.Add(parsedWindows[i].Window);

                overlappingWindows.Add(parsedWindows[i+1].Window);

            }

        }

​

        return overlappingWindows;

    }

    public static void Main()

    {

        string[] windows = {

            "00:00-03:00",

            "15:00-17:00",

            "04:00-06:00", 

            "18:00-19:00",

            "05:00-07:00", 

            "08:00-12:00", 

            "09:00-10:00", 

            "18:00-19:00",

            "13:00-14:00", 

            "16:00-17:00", 

            "20:00-21:00",

            "23:00-01:00"

        };

        List<string> result = FindOverlappingWindows(windows);

        Console.WriteLine(string.Join("\n", result));

    }

}