add 729 java, array_overlap_explaination.md

Author: yennanliu

README.md

@@ -269,7 +269,7 @@
 717 | [1-bit and 2-bit Characters](https://leetcode.com/problems/1-bit-and-2-bit-characters/) | [Python](./leetcode_python/Array/1-bit-and-2-bit-characters.py) | _O(n)_ | _O(1)_ | Easy | Greedy |  AGAIN (not start)
 723 | [Candy Crush](https://leetcode.com/problems/candy-crush/) | [Python](./leetcode_python/Array/candy-crush.py) | _O((R * C)^2)_ | _O(1)_ | Medium |`complex`| AGAIN (not start)
 724 | [Find Pivot Index](https://leetcode.com/problems/find-pivot-index/) | [Python](./leetcode_python/Array/find-pivot-index.py)  | _O(n)_ | _O(1)_ | Easy || OK*
-729 | [My Calendar I](https://leetcode.com/problems/my-calendar-i/) |  [Python](./leetcode_python/Array/my-calendar-i.py) | _O(nlogn)_ | _O(n)_ | Medium |`python class`| AGAIN* (not start)
+729 | [My Calendar I](https://leetcode.com/problems/my-calendar-i/) |  [Python](./leetcode_python/Array/my-calendar-i.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MyCalendar1.java) | _O(nlogn)_ | _O(n)_ | Medium |good basic, brute force, binary search, google| AGAIN**** (1)
 731 | [My Calendar II](https://leetcode.com/problems/my-calendar-ii/) | [Python](./leetcode_python/Array/my-calendar-ii.py) | _O(n^2)_ | _O(n)_ | Medium |`trick`, `basic`| AGAIN** (not start)
 747 | [Largest Number At Least Twice of Others](https://leetcode.com/problems/largest-number-at-least-twice-of-others/) | [Python](./leetcode_python/Array/largest-number-at-least-twice-of-others.py) | _O(n)_ | _O(1)_ | Easy |`good basic`, `data structure`| OK* 
 755 | [Pour Water](https://leetcode.com/problems/pour-water/) | [Python](./leetcode_python/Array/pour-water.py) | _O(v * n)_ | _O(1)_ | Medium |`complex`| AGAIN (not start)

data/progress.txt

@@ -1,4 +1,4 @@
-20241019: 298
+20241019: 298,729
 20241018: 1146
 20241014: 737
 20241013: 686,734,737

data/to_review.txt

@@ -1,3 +1,4 @@
+2024-12-13 -> ['298,729']
 2024-12-12 -> ['1146']
 2024-12-08 -> ['737']
 2024-12-07 -> ['686,734,737']
@@ -9,7 +10,7 @@
 2024-11-26 -> ['743,889']
 2024-11-25 -> ['837']
 2024-11-23 -> ['981']
-2024-11-22 -> ['1087']
+2024-11-22 -> ['298,729', '1087']
 2024-11-21 -> ['1146']
 2024-11-20 -> ['939']
 2024-11-18 -> ['430']
@@ -19,25 +20,25 @@
 2024-11-14 -> ['528,334']
 2024-11-12 -> ['1145', '753']
 2024-11-11 -> ['727']
-2024-11-09 -> ['1145,1219']
+2024-11-09 -> ['298,729', '1145,1219']
 2024-11-08 -> ['1146']
 2024-11-06 -> ['524,221,889']
 2024-11-05 -> ['743,889']
 2024-11-04 -> ['737', '837', '659']
 2024-11-03 -> ['686,734,737', '801,552']
 2024-11-02 -> ['353', '981', '1057,1066,1110']
-2024-11-01 -> ['528,334', '1087']
+2024-11-01 -> ['298,729', '528,334', '1087']
 2024-10-31 -> ['1146']
 2024-10-30 -> ['1145', '939']
 2024-10-28 -> ['430']
-2024-10-27 -> ['737', '1145,1219', '363']
+2024-10-27 -> ['298,729', '737', '1145,1219', '363']
 2024-10-26 -> ['1146', '686,734,737', '1032,844,1011']
 2024-10-25 -> ['353', '947', '1110, 1055']
-2024-10-24 -> ['528,334', '524,221,889']
+2024-10-24 -> ['298,729', '528,334', '524,221,889']
 2024-10-23 -> ['1146', '743,889']
-2024-10-22 -> ['737', '1145', '837', '753']
-2024-10-21 -> ['1146', '686,734,737', '727']
-2024-10-20 -> ['1146', '353', '981']
+2024-10-22 -> ['298,729', '737', '1145', '837', '753']
+2024-10-21 -> ['298,729', '1146', '686,734,737', '727']
+2024-10-20 -> ['298,729', '1146', '353', '981']
 2024-10-19 -> ['1146', '737', '528,334', '1145,1219', '1087']
 2024-10-18 -> ['686,734,737', '359,1057,1055(todo)']
 2024-10-17 -> ['737', '353', '1145', '939']
@@ -832,19 +833,19 @@
 2020-07-10 -> ['734,737', '388', '836,860,863']
 2020-07-09 -> ['066,271', '694']
 2020-07-08 -> ['066,271', '163', '646', '663']
-2020-07-07 -> ['298', '066,271', '210,261', '776', '661,662', '703,787,819']
+2020-07-07 -> ['066,271', '210,261', '298', '776', '661,662', '703,787,819']
 2020-07-06 -> ['130', '163', '361,393,133,207', '669,682,739,763']
 2020-07-05 -> ['163', '734,737', '346,686', '771,775', '701,450', '642,652,657']
 2020-07-04 -> ['163', '210,261', '640,645', '545,617,628']
 2020-07-03 -> ['361,393,133,207', '482,127,102,107', '762', '606,459']
-2020-07-02 -> ['298', '210,261', '734,737', '388', '742', '445,508']
+2020-07-02 -> ['210,261', '734,737', '298', '388', '742', '445,508']
 2020-07-01 -> ['130', '269', '210,261', '361,393,133,207', '322,380,394']
 2020-06-30 -> ['210,261', '361,393,133,207', '734,737', '346,686', '646', '738', '537,553,579', '289,295']
-2020-06-29 -> ['298', '361,393,133,207', '734,737', '776', '396', '251,287']
+2020-06-29 -> ['361,393,133,207', '734,737', '298', '776', '396', '251,287']
 2020-06-28 -> ['130', '734,737', '482,127,102,107', '355,119,536', '231,232,240']
 2020-06-27 -> ['298', '346,686', '388', '771,775', '451,414,189', '198,203,230']
-2020-06-26 -> ['298', '130', '694', '155,165,167,179']
-2020-06-25 -> ['298', '130', '346,686', '482,127,102,107', '646', '762', '663', '725,538,089']
+2020-06-26 -> ['130', '298', '694', '155,165,167,179']
+2020-06-25 -> ['130', '298', '346,686', '482,127,102,107', '646', '762', '663', '725,538,089']
 2020-06-24 -> ['130', '346,686', '388', '776', '742', '661,662', '517,535,529', '153']
 2020-06-23 -> ['346,686', '482,127,102,107', '711,046,126,127', '131,134,150']
 2020-06-22 -> ['482,127,102,107', '388', '646', '771,775', '738', '701,450', '063,064,120,0146']

doc/cheatsheet/array_overlap_explaination.md

@@ -0,0 +1,77 @@
+
+# Explanation of Overlapping Booking Logic in MyCalendar
+
+This document explains the logic used in the following code snippet from the `MyCalendar` class:
+
+```java
+if (start < date.get(1) && end > date.get(0)) {
+    return false;  // There's an overlap
+}
+```
+
+## Purpose
+The purpose of this logic is to check whether a new booking overlaps with an existing booking in the calendar. If the new booking overlaps with an existing booking, the function will return `false`, indicating that the booking cannot be made.
+
+## Visual Explanation
+
+Imagine a timeline where each event has a start and an end time. The new event is represented by `start` and `end`, while an existing event is represented by `date.get(0)` (start) and `date.get(1)` (end).
+
+### Cases:
+
+### 1. **No Overlap - New Event is Completely Before the Existing Event**
+
+```
+New:      |-----|   
+Existing:          |-----|
+```
+
+- **Condition**: `end <= date.get(0)`
+- Explanation: The new event ends before the existing event starts, so no overlap.
+
+### 2. **No Overlap - New Event is Completely After the Existing Event**
+
+```
+New:              |-----|
+Existing:  |-----|
+```
+
+- **Condition**: `start >= date.get(1)`
+- Explanation: The new event starts after the existing event ends, so no overlap.
+
+### 3. **Overlap - New Event Partially Overlaps with the Existing Event**
+
+```
+New:       |-------|
+Existing:     |------|
+```
+
+- **Condition**: `start < date.get(1)` and `end > date.get(0)`
+- Explanation: The new event starts before the existing event ends and ends after the existing event starts, causing a partial overlap.
+
+### 4. **Complete Overlap - New Event Starts and Ends Inside the Existing Event**
+
+```
+New:         |---|
+Existing:   |-------|
+```
+
+- **Condition**: `start < date.get(1)` and `end > date.get(0)`
+- Explanation: Both conditions are true, meaning the new event is entirely within the bounds of the existing event.
+
+### 5. **New Event Engulfs the Existing Event (Starts Before and Ends After)**
+
+```
+New:     |-----------|
+Existing:   |-----|
+```
+
+- **Condition**: `start < date.get(1)` and `end > date.get(0)`
+- Explanation: The new event starts before and ends after the existing event, completely overlapping it.
+
+## Breakdown of the Condition:
+
+- **`start < date.get(1)`**: This checks if the new event starts before the existing event ends.
+- **`end > date.get(0)`**: This checks if the new event ends after the existing event starts.
+
+If **both conditions are true**, there is an overlap, and the function returns `false` to indicate that the booking cannot be made.
+

leetcode_java/src/main/java/LeetCodeJava/Array/MyCalendar1.java

@@ -0,0 +1,134 @@
+package LeetCodeJava.Array;
+
+// https://leetcode.com/problems/my-calendar-i/description/
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.TreeMap;
+
+/**
+ * 729. My Calendar I
+ * Medium
+ * Topics
+ * Companies
+ * Hint
+ * You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a double booking.
+ *
+ * A double booking happens when two events have some non-empty intersection (i.e., some moment is common to both events.).
+ *
+ * The event can be represented as a pair of integers start and end that represents a booking on the half-open interval [start, end), the range of real numbers x such that start <= x < end.
+ *
+ * Implement the MyCalendar class:
+ *
+ * MyCalendar() Initializes the calendar object.
+ * boolean book(int start, int end) Returns true if the event can be added to the calendar successfully without causing a double booking. Otherwise, return false and do not add the event to the calendar.
+ *
+ *
+ * Example 1:
+ *
+ * Input
+ * ["MyCalendar", "book", "book", "book"]
+ * [[], [10, 20], [15, 25], [20, 30]]
+ * Output
+ * [null, true, false, true]
+ *
+ * Explanation
+ * MyCalendar myCalendar = new MyCalendar();
+ * myCalendar.book(10, 20); // return True
+ * myCalendar.book(15, 25); // return False, It can not be booked because time 15 is already booked by another event.
+ * myCalendar.book(20, 30); // return True, The event can be booked, as the first event takes every time less than 20, but not including 20.
+ *
+ *
+ * Constraints:
+ *
+ * 0 <= start < end <= 109
+ * At most 1000 calls will be made to book.
+ *
+ */
+public class MyCalendar1 {
+
+    // V0
+    // IDEA : BRUTE FORCE (fixed by gpt)
+    class MyCalendar {
+        List<List<Integer>> dates;
+
+        public MyCalendar() {
+            this.dates = new ArrayList<>();
+        }
+
+        public boolean book(int start, int end) {
+            for (List<Integer> date : dates) {
+                // Check if the new booking overlaps with an existing booking
+                /**
+                 *
+                 *
+                 * 	•	The condition if (start < date.get(1) && end > date.get(0)) checks if the new event overlaps with any existing booking. Specifically, this checks:
+                 * 	•	start < date.get(1) ensures that the new event starts before the current event ends.
+                 * 	•	end > date.get(0) ensures that the new event ends after the current event starts.
+                 * 	•	If there is an overlap, return false.
+                 * 	•	If no overlap exists, the event is added to the list and returns true.
+                 *
+                 */
+                if (start < date.get(1) && end > date.get(0)) {
+                    return false;  // There's an overlap
+                }
+            }
+            // If no overlap, add the new booking
+            List<Integer> newBook = new ArrayList<>();
+            newBook.add(start);
+            newBook.add(end);
+            this.dates.add(newBook);
+            return true;
+        }
+    }
+
+    // V1-1
+    // IDEA : BRUTE FORCE
+    // https://leetcode.com/problems/my-calendar-i/editorial/
+    public class MyCalendar_1_1 {
+        List<int[]> calendar;
+
+        MyCalendar_1_1() {
+            calendar = new ArrayList();
+        }
+
+        /**
+         *    10     20      iv
+         *       15     25   start, end
+         *
+         */
+        public boolean book(int start, int end) {
+            for (int[] iv: calendar) {
+                if (iv[0] < end && start < iv[1]) {
+                    return false;
+                }
+            }
+            calendar.add(new int[]{start, end});
+            return true;
+        }
+    }
+
+    // V1-2
+    // IDEA : Sorted List + Binary Search
+    // https://leetcode.com/problems/my-calendar-i/editorial/
+    public class MyCalendar_1_2 {
+        TreeMap<Integer, Integer> calendar;
+
+        MyCalendar_1_2() {
+            calendar = new TreeMap();
+        }
+
+        public boolean book(int start, int end) {
+            Integer prev = calendar.floorKey(start),
+                    next = calendar.ceilingKey(start);
+            if ((prev == null || calendar.get(prev) <= start) &&
+                    (next == null || end <= next)) {
+                calendar.put(start, end);
+                return true;
+            }
+            return false;
+        }
+    }
+
+    // V2
+}