CareerCup

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace ConsoleApplication47
{
    class Program
    {
        static void Main(string[] args)
        {
            //Input file:
           // name begin   end
           // Bob1  1       3
           // Bob2  2       4
           // Bob3  1       4
           // Bob1  5       6
           // Bob2  4       7
           // Bob3  5       6
            string[] input_data = File.ReadAllText(@"G:\input.txt").Split(new char[] {'\n','\r','\t' }, StringSplitOptions.RemoveEmptyEntries);
            Employee[] calendar = new Employee[input_data.Length*2];
            int j = 0;
            // convert input file to the list. for each line in file, we make two items: for begin and for end
            for (int i = 0; i < input_data.Length; i++)
            {
                string[] employee = input_data[i].Split(new char[] {' ', '\r'}, StringSplitOptions.RemoveEmptyEntries);
                Employee man = new Employee(employee[0], int.Parse(employee[1]), true); // begin
                calendar[j] = man;
                j++;
                man = new Employee(employee[0],int.Parse(employee[2]), false); // end
                calendar[j] = man;
                j++;
            }
            // quicksorting
            calendar = SortingCalendar(calendar, 0, calendar.Length-1);
            int count = 0;
            int t_min=0;
            // finding when all employees are not work
            for (int i = 0; i < calendar.Length; i++)
            {
                if (calendar[i].is_begin) count++;
                else count--;
                if (count == 0)
                {
                    t_min = calendar[i + 1].time - calendar[i].time; // this line needs to be checked for i+1 < calendar.length. But i suppose, that shedule is looped
                    break;
                }
            }
            Console.WriteLine(t_min);
            Console.ReadKey();
        }
        static Employee[] SortingCalendar(Employee[] calendar, int begin, int end)
        {
            int i = begin;
            int j = end;
            int m = (begin + end) / 2;
            int median = calendar[m].time;
            while (i <= j)
            {
                while (calendar[i].time < median)
                {
                    i++;
                }
                while (calendar[j].time > median)
                {
                    j--;
                }
                if (i <= j)
                {
                    // This check is necessary for the situation where the beginning of the next cycle coincides with the end of the previous
                    if (calendar[i].time != calendar[j].time)
                    {
                        Employee temp = calendar[i];
                        calendar[i] = calendar[j];
                        calendar[j] = temp;
                    }
                    i++;
                    j--;
                }
            }
            if (j > begin) calendar = SortingCalendar(calendar, begin, j);
            if (i < end) calendar = SortingCalendar(calendar, i, end);
            return calendar;
        }
    }
    class Employee
    {
        public string name;
        public int time;
        public bool is_begin;
        public Employee()
        { }
        public Employee(string in_name, int in_time, bool in_is_begin)
        {
            name = in_name;
            time = in_time;
            is_begin = in_is_begin;
        }
    }
}

Assumption: Each employee has one interval (Start-i, End-i)

Define strucrure :
struct node_t {
time_t time;
int type; // START, END
}

Convert given input into following heterogenous SORTED(by time) list/array with each node of "node_t".

Now scan this list/array with counter = 0, whenever u encounter START_type "++counter" and whenever u encounter START_type "--counter".

Moment when u get counter = 0, that's free time for all employees so just check next START_type to find interval length