Update meeting rooms logic

Author: sudheerj

README.md

@@ -234,7 +234,7 @@ List of Programs related to data structures and algorithms
 
    3. Non-overlapping intervals: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.md)
 
-   4. Meeting rooms: [JavaScript](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/meetingRooms.js)
+   4. Meeting rooms: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/meetingRooms/meetingRooms.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/meetingRooms/meetingRooms.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/meetingRooms/meetingRooms.md)
 
    5. Meeting rooms 2: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/meetingRooms2.js)
 

src/java1/algorithms/interval/MeetingRooms.java

@@ -0,0 +1,46 @@
+//TC: O(n logn)+ O(n) SC:O(1)
+
+package java1.algorithms.interval.meetingRooms;
+import java.util.*;
+
+class Interval {
+    int start, end;
+    Interval(int start, int end) {
+        this.start = start;
+        this.end = end;
+    }
+}
+
+public class MeetingRooms {
+    
+    private static boolean canAttendMeetings(List<Interval> intervals) {
+        Collections.sort(intervals, (a, b) -> a.start - b.start);
+
+        for(int i=1; i< intervals.size(); i++) {
+            int startTime = intervals.get(i).start;
+            int prevEndTime = intervals.get(i-1).end;
+
+            if(prevEndTime > startTime) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        List<Interval> intervals1 = new ArrayList<Interval>();
+        intervals1.add(new Interval(1, 3));
+        intervals1.add(new Interval(3, 7));
+        intervals1.add(new Interval(6, 8));
+        intervals1.add(new Interval(8, 10));
+        intervals1.add(new Interval(10, 12));
+
+        List<Interval> intervals2 = new ArrayList<Interval>();
+        intervals2.add(new Interval(1, 5));
+        intervals2.add(new Interval(5, 7));
+        intervals2.add(new Interval(8, 10));
+
+        System.out.println(canAttendMeetings(intervals1));
+        System.out.println(canAttendMeetings(intervals2));
+    }
+}

src/java1/algorithms/interval/meetingRooms/MeetingRooms.java

@@ -0,0 +1,38 @@
+**Problem:**
+Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), determine if a person could attend all meetings.
+
+Remember that [[1, 4],[4, 7]] will not conflict at 4.
+
+**Examples:**
+Input: intervals = [[1,3],[3,7],[6,8],[8, 10], [10, 12]]
+Output: false
+Explanation: 
+The meeting intervals [3,7], [6,8] will conflict
+
+Input: intervals = [[1,5], [5,7], [8, 10]]
+Output: true
+Explanation: 
+The three meeting intervals will not conflict
+
+**Algorithmic Steps**
+This problem is solved with the help of greedy approach. The algorithmic approach can be summarized as follows:
+
+1. First, sort the list of intervals based on their start times. This step helps to keep the intervals arranged in a sequential order and makes it easy to check for any overlaps in the list.
+
+2. Iterate through the list of intervals. For each iteration, keep the current start time(i.e, `startTime`) and previous end time(i.e, `prevEndTime`) values to compare start time with previous meeting's end time.
+
+    **Note:** Remember that the main idea behind this solution is to verify that each meeting ends before the next meeting starts.
+
+3. If the start time is less than the end time of the previous interval, then there is an overlap between the intervals. In this case, a person cannot attend all meetings. So you need to return `false` immeidately.
+
+4. If the start time is greater than the previous interval's end time, then there is no overlap between the intervals. In this case, you need to proceed with next set of intervals to find any overlap between the meetings. 
+
+5. Repeat steps 2-4 until there is no overlap exists in the list or all intervals have been traversed.
+
+6. Return `true` indicating that a person can attend all meetings.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n logn) + O(n) ~= O(n), where n is the number of intervals. This is because sort operation typically takes a time complexity of O(n log n) for sorting the list. Thereafter, iteration over the intervals take a time complexity of O(n). So the total time complexity simplifies to O(n log n).
+
+The space complexity of this algorithm is O(1) due to no additional data structure used.

src/java1/algorithms/interval/meetingRooms/meetingRooms.md

@@ -0,0 +1,21 @@
+//TC: O(n logn)+ O(n) SC:O(1)
+
+function canAttendMeetings(intervals) {
+    intervals.sort((a, b) => a[0] - b[0]);
+
+    for(let i=1; i< intervals.length; i++) {
+        let startTime = intervals[i][0];
+        let prevEndTime = intervals[i-1][1];
+
+        if(prevEndTime > startTime) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+let intervals1 = [[1,3], [3,7], [6, 8], [8, 10], [10, 12]];
+let intervals2 = [[1,5], [5,7], [8, 10]];
+console.log(canAttendMeetings(intervals1));
+console.log(canAttendMeetings(intervals2));

src/javascript/algorithms/interval/meetingRooms.js

@@ -0,0 +1,38 @@
+**Problem:**
+Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), determine if a person could attend all meetings.
+
+Remember that [[1, 4],[4, 7]] will not conflict at 4.
+
+**Examples:**
+Input: intervals = [[1,3],[3,7],[6,8],[8, 10], [10, 12]]
+Output: false
+Explanation: 
+The meeting intervals [3,7], [6,8] will conflict
+
+Input: intervals = [[1,5], [5,7], [8, 10]]
+Output: true
+Explanation: 
+The three meeting intervals will not conflict
+
+**Algorithmic Steps**
+This problem is solved with the help of greedy approach. The algorithmic approach can be summarized as follows:
+
+1. First, sort the list of intervals based on their start times. This step helps to keep the intervals arranged in a sequential order and makes it easy to check for any overlaps in the list.
+
+2. Iterate through the list of intervals. For each iteration, keep the current start time(i.e, `startTime`) and previous end time(i.e, `prevEndTime`) values to compare start time with previous meeting's end time.
+
+    **Note:** Remember that the main idea behind this solution is to verify that each meeting ends before the next meeting starts.
+
+3. If the start time is less than the end time of the previous interval, then there is an overlap between the intervals. In this case, a person cannot attend all meetings. So you need to return `false` immeidately.
+
+4. If the start time is greater than the previous interval's end time, then there is no overlap between the intervals. In this case, you need to proceed with next set of intervals to find any overlap between the meetings. 
+
+5. Repeat steps 2-4 until there is no overlap exists in the list or all intervals have been traversed.
+
+6. Return `true` indicating that a person can attend all meetings.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n logn) + O(n) ~= O(n), where n is the number of intervals. This is because sort operation typically takes a time complexity of O(n log n) for sorting the list. Thereafter, iteration over the intervals take a time complexity of O(n). So the total time complexity simplifies to O(n log n).
+
+The space complexity of this algorithm is O(1) due to no additional data structure used.