chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2025-11-20-757-Set-Intersection-Size-At-Least-Two/explanation.md

@@ -0,0 +1,26 @@
+# Set Intersection Size At Least Two (Hard)
+
+**Problem ID:** 757  
+**Date:** 2025-11-20  
+**Link:** https://leetcode.com/problems/set-intersection-size-at-least-two/
+
+## Approach
+
+To solve the "Set Intersection Size At Least Two" problem, we need to ensure that every interval in the given list has at least two integers from a selected set. The main idea is to strategically choose integers such that the total count of selected integers is minimized while still satisfying the requirement for all intervals.
+
+### Approach:
+
+1. **Sort Intervals**: Start by sorting the intervals based on their ending points. This allows us to handle overlapping intervals more effectively and ensures that we can cover as many intervals as possible with the least number of integers.
+
+2. **Greedy Selection**: Use a greedy approach to select integers. For each interval, check if it is already covered by the previously selected integers. If it is not covered, we need to add integers to ensure that this interval has at least two integers from our set.
+
+3. **Choosing Integers**:
+   - If an interval `[start, end]` is not covered, check the last two integers that were added to the set. If both are less than `start`, add the two largest integers from the interval (i.e., `end` and `end-1`).
+   - If one of the last two integers is within the interval, add the other integer to ensure that the interval is covered with at least two integers.
+
+4. **Data Structures**: Use a list to maintain the selected integers. A set can also be used to quickly check if an integer is already included in the selected integers.
+
+5. **Complexity**: The overall time complexity is O(n log n) due to sorting the intervals, where n is the number of intervals. The greedy selection process runs in O(n), resulting in an efficient solution.
+
+### Summary:
+The solution effectively combines sorting and a greedy selection strategy to ensure that each interval is covered by at least two integers while minimizing the total number of integers selected. By focusing on the end points of intervals and ensuring coverage through careful selection, we achieve the required result efficiently.

Hard/2025-11-20-757-Set-Intersection-Size-At-Least-Two/solution.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Solution {
+    public int intersectionSizeTwo(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt(a -> a[1]));
+        int count = 0;
+        int end1 = -1, end2 = -1;
+
+        for (int[] interval : intervals) {
+            if (end2 < interval[0]) {
+                count += 2;
+                end1 = interval[1];
+                end2 = interval[1] - 1;
+            } else if (end1 < interval[0]) {
+                count += 1;
+                end1 = end2;
+                end2 = interval[1];
+            }
+        }
+
+        return count;
+    }
+}

Hard/2025-11-20-757-Set-Intersection-Size-At-Least-Two/solution.js

@@ -0,0 +1,19 @@
+var intersectionSizeTwo = function(intervals) {
+    intervals.sort((a, b) => a[1] - b[1]);
+    let count = 0;
+    let end = -1;
+    let secondEnd = -1;
+
+    for (let [start, finish] of intervals) {
+        if (end < finish - 1) {
+            count += 2;
+            secondEnd = finish;
+            end = finish - 1;
+        } else if (end === finish - 1) {
+            count += 1;
+            end = secondEnd;
+        }
+    }
+    
+    return count;
+};

Hard/2025-11-20-757-Set-Intersection-Size-At-Least-Two/solution.py

@@ -0,0 +1,18 @@
+class Solution:
+    def intersectionSizeTwo(self, intervals: List[List[int]]) -> int:
+        intervals.sort(key=lambda x: (x[1], x[0]))
+        end1, end2 = -1, -1
+        count = 0
+        
+        for start, end in intervals:
+            if end1 < start:
+                count += 2
+                end1, end2 = end - 1, end
+            elif end2 < start:
+                count += 1
+                end1, end2 = end2, end
+            
+            end1 = max(end1, end - 1)
+            end2 = max(end2, end)
+        
+        return count

README.md

@@ -284,3 +284,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-17 — [Check If All 1's Are at Least Length K Places Away](https://leetcode.com/problems/check-if-all-1s-are-at-least-length-k-places-away/) (Easy) → `Easy/2025-11-17-1437-Check-If-All-1-s-Are-at-Least-Length-K-Places-Away`
 - 2025-11-18 — [1-bit and 2-bit Characters](https://leetcode.com/problems/1-bit-and-2-bit-characters/) (Easy) → `Easy/2025-11-18-717-1-bit-and-2-bit-Characters`
 - 2025-11-19 — [Keep Multiplying Found Values by Two](https://leetcode.com/problems/keep-multiplying-found-values-by-two/) (Easy) → `Easy/2025-11-19-2154-Keep-Multiplying-Found-Values-by-Two`
+- 2025-11-20 — [Set Intersection Size At Least Two](https://leetcode.com/problems/set-intersection-size-at-least-two/) (Hard) → `Hard/2025-11-20-757-Set-Intersection-Size-At-Least-Two`