Merge pull request #178 from BrianLusina/feat/algorithms-intervals-min-intervals

feat(algorithms, intervals): min interval to include each query

Author: BrianLusina

DIRECTORY.md

@@ -1,6 +1,8 @@
 
 ## Algorithms
   * Arrays
+    * Find Missing Elem
+      * [Test Find Missing Elem](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/arrays/find_missing_elem/test_find_missing_elem.py)
     * Intersection
       * [Intersection One](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/arrays/intersection/intersection_one.py)
       * [Intersection Two](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/arrays/intersection/intersection_two.py)
@@ -247,6 +249,8 @@
       * [Test Most Booked Meeting Rooms](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/intervals/meeting_rooms/test_most_booked_meeting_rooms.py)
     * Merge Intervals
       * [Test Merge Intervals](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/intervals/merge_intervals/test_merge_intervals.py)
+    * Min Intervals For Queries
+      * [Test Min Intervals To Include Query](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/intervals/min_intervals_for_queries/test_min_intervals_to_include_query.py)
     * Non Overlapping Intervals
       * [Test Non Overlapping Intervals](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/intervals/non_overlapping_intervals/test_non_overlapping_intervals.py)
     * Remove Intervals
@@ -324,6 +328,8 @@
   * Trie
     * Longest Word With Prefixes
       * [Test Longest Word With Prefixes](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/trie/longest_word_with_prefixes/test_longest_word_with_prefixes.py)
+    * Topkfreqwords
+      * [Test Top K Frequent Words](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/trie/topkfreqwords/test_top_k_frequent_words.py)
   * Two Pointers
     * Array 3 Pointers
       * [Test Array 3 Pointers](https://github.com/BrianLusina/PythonSnips/blob/master/algorithms/two_pointers/array_3_pointers/test_array_3_pointers.py)
@@ -607,6 +613,9 @@
         * [Types](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/trees/trie/suffix/types.py)
       * [Trie](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/trees/trie/trie.py)
       * [Trie Node](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/trees/trie/trie_node.py)
+      * Word Dictionary
+        * [Test Word Dictionary](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/trees/trie/word_dictionary/test_word_dictionary.py)
+        * [Word Dictionary Trie Node](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/trees/trie/word_dictionary/word_dictionary_trie_node.py)
   * Tuples
     * [Named Tuples](https://github.com/BrianLusina/PythonSnips/blob/master/datastructures/tuples/named_tuples.py)
 
@@ -644,8 +653,32 @@
       * [Visitor](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/behavioral/visitor/visitor.py)
   * Browser History
     * [Test Browser History](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/browser_history/test_browser_history.py)
+  * Circuit Breaker
+    * [Circuit Breaker](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/circuit_breaker/circuit_breaker.py)
   * Continuous Median
     * [Test Continuous Median Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/continuous_median/test_continuous_median_handler.py)
+  * Event Stream
+    * [Audit Logger](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/audit_logger.py)
+    * [Batch Event Processor](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/batch_event_processor.py)
+    * [Event](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/event.py)
+    * [Event Priority Mapper](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/event_priority_mapper.py)
+    * [Event Type](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/event_type.py)
+    * Handlers
+      * [Event Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/event_handler.py)
+      * [Handlers](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/handlers.py)
+      * [Message Delivered Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/message_delivered_handler.py)
+      * [Message Failed Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/message_failed_handler.py)
+      * [Message Read Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/message_read_handler.py)
+      * [Message Revoked Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/message_revoked_handler.py)
+      * [Message Sent Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/message_sent_handler.py)
+      * [Typing Handler](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/handlers/typing_handler.py)
+    * [Logger](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/logger.py)
+    * [Message Context](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/message_context.py)
+    * [Message State](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/message_state.py)
+    * [Message State Manager](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/message_state_manager.py)
+    * [Prioritized Event](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/prioritized_event.py)
+    * [Processor](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/processor.py)
+    * [State Transition Config](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/event_stream/state_transition_config.py)
   * Linked List
     * [Test Linked List](https://github.com/BrianLusina/PythonSnips/blob/master/design_patterns/linked_list/test_linked_list.py)
   * Oop
@@ -778,8 +811,6 @@
     * [Battleship](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/battleship/battleship.py)
   * Beeramid
     * [Test Bearamid](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/beeramid/test_bearamid.py)
-  * Find Missing Elem
-    * [Test Find Missing Elem](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/find_missing_elem/test_find_missing_elem.py)
   * Hashmap
     * Close Strings
       * [Test Close Strings](https://github.com/BrianLusina/PythonSnips/blob/master/puzzles/hashmap/close_strings/test_close_strings.py)

algorithms/intervals/min_intervals_for_queries/README.md

@@ -0,0 +1,128 @@
+# Minimum Interval to Include Each Query
+
+You are given a 2D integer array intervals, where intervals[i] = [lefti, righti] describes the ith interval starting at
+lefti and ending at righti (inclusive). The size of an interval is defined as the number of integers it contains, or
+more formally righti - lefti + 1.
+
+You are also given an integer array queries. The answer to the jth query is the size of the smallest interval i such
+that lefti <= queries[j] <= righti. If no such interval exists, the answer is -1.
+
+- If at least one interval contains the query, return the minimum interval size among those intervals.
+- If no interval contains the query, return -1 for that query.
+
+Return an array containing the answers to the queries.
+
+## Examples
+
+![Example 1](./images/examples/min_intervals_to_include_query_example_1.png)
+![Example 2](./images/examples/min_intervals_to_include_query_example_2.png)
+![Example 3](./images/examples/min_intervals_to_include_query_example_3.png)
+
+Example 4
+
+```text
+Input: intervals = [[1,4],[2,4],[3,6],[4,4]], queries = [2,3,4,5]
+Output: [3,3,1,4]
+Explanation: The queries are processed as follows:
+- Query = 2: The interval [2,4] is the smallest interval containing 2. The answer is 4 - 2 + 1 = 3.
+- Query = 3: The interval [2,4] is the smallest interval containing 3. The answer is 4 - 2 + 1 = 3.
+- Query = 4: The interval [4,4] is the smallest interval containing 4. The answer is 4 - 4 + 1 = 1.
+- Query = 5: The interval [3,6] is the smallest interval containing 5. The answer is 6 - 3 + 1 = 4.
+```
+
+Example 5
+```text
+Input: intervals = [[2,3],[2,5],[1,8],[20,25]], queries = [2,19,5,22]
+Output: [2,-1,4,6]
+Explanation: The queries are processed as follows:
+- Query = 2: The interval [2,3] is the smallest interval containing 2. The answer is 3 - 2 + 1 = 2.
+- Query = 19: None of the intervals contain 19. The answer is -1.
+- Query = 5: The interval [2,5] is the smallest interval containing 5. The answer is 5 - 2 + 1 = 4.
+- Query = 22: The interval [20,25] is the smallest interval containing 22. The answer is 25 - 20 + 1 = 6.
+```
+
+## Constraints
+
+- 1 <= intervals.length <= 10^5
+- 1 <= queries.length <= 10^5
+- intervals[i].length == 2
+- 1 <= lefti <= righti <= 10^7
+- 1 <= queries[j] <= 10^7
+
+## Topics
+
+- Array
+- Binary Search
+- Sweep Line
+- Sorting
+- Heap (Priority Queue)
+
+## Hints
+
+- Is there a way to order the intervals and queries such that it takes less time to query?
+- Is there a way to add and remove intervals by going from the smallest query to the largest query to find the minimum
+  size?
+
+## Solution
+
+The core idea is to process the queries from smallest to largest, while continuously keeping track of which intervals
+are active candidates for the current query. As we move forward through increasing query values, more intervals become
+eligible because their left endpoint is now less than equal to the current query, so we add them to a min heap. At the
+same time, some previously added intervals may stop being useful because their right endpoints are now less than the
+query, meaning they can no longer cover the query (or any future larger query), so we remove them. The heap is ordered
+by interval size (smallest first), and we store each interval’s right endpoint alongside its size; this lets us quickly
+discard expired intervals and ensures that after cleanup, the heap’s top element always represents the smallest-size
+interval that still covers the current query. This gives an efficient way to answer each query without scanning all
+intervals repeatedly.
+
+The steps of the algorithm are as follows:
+
+1. Sort intervals by starting point (`left`) so we can add them in the correct order as queries increase.
+2. Attach original indexes to queries as (`queryValue`, `originalIndex`), then sort queries by `queryValue` so we
+   process them from smallest to largest.
+3. Initialize the `ans` array filled with -1
+4. Initialize a min heap, `heap`, that stores interval size and right endpoint as tuples `(size, right)`.
+5. Initialize a pointer i = 0 to walk through the sorted intervals
+6. For each query q in sorted order:
+   - **Add all intervals starting at or before q**: While intervals[i].left <= q, push (size, right) into the heap and
+     increment i.
+   - **Remove invalid intervals**: While heap top has `right < q`, pop it (it cannot cover `q` anymore).
+   - Answer the query:
+     - If the heap is non-empty, the top element’s `size` is the smallest interval covering `q`, so store it in the `ans`
+       array at the query’s original index.
+     - Otherwise, leave `ans` as -1.
+7. Return ans in the original query order.
+
+![Solution 1](./images/solutions/min_intervals_to_include_query_solution_1.png)
+![Solution 2](./images/solutions/min_intervals_to_include_query_solution_2.png)
+![Solution 3](./images/solutions/min_intervals_to_include_query_solution_3.png)
+![Solution 4](./images/solutions/min_intervals_to_include_query_solution_4.png)
+![Solution 5](./images/solutions/min_intervals_to_include_query_solution_5.png)
+![Solution 6](./images/solutions/min_intervals_to_include_query_solution_6.png)
+![Solution 7](./images/solutions/min_intervals_to_include_query_solution_7.png)
+![Solution 8](./images/solutions/min_intervals_to_include_query_solution_8.png)
+![Solution 19](./images/solutions/min_intervals_to_include_query_solution_9.png)
+![Solution 10](./images/solutions/min_intervals_to_include_query_solution_10.png)
+![Solution 11](./images/solutions/min_intervals_to_include_query_solution_11.png)
+![Solution 12](./images/solutions/min_intervals_to_include_query_solution_12.png)
+![Solution 13](./images/solutions/min_intervals_to_include_query_solution_13.png)
+![Solution 14](./images/solutions/min_intervals_to_include_query_solution_14.png)
+
+## Complexity Analysis
+
+### Time Complexity
+
+The algorithm's time complexity is dominated by sorting and heap operations. Sorting the `intervals` array takes 
+`O(nlog(n))`, where `n` is the number of intervals, and sorting the queries (after pairing each query with its original
+index) takes `O(mlog(m))`, where `m` is the number of queries.
+
+During the sweep through the sorted queries, each interval is pushed into the min heap at most once, and popped at most
+once, and each heap operation costs `O(log(n))`, giving a total heap cost of `O(nlog(n))`.
+
+Altogether, the overall time complexity is `O(n log(n) + m log(m) + n log(n))`, which is commonly simplified to 
+`O((n+m) log(n))` (or equivalently O(n log (n) + m log(m))).
+
+### Space Complexity
+
+The space complexity is `O(n+m)` because, in the worst case, the heap can hold up to `n` intervals, and we also store
+the sorted query list and the answer array, each of size `m`.

algorithms/intervals/min_intervals_for_queries/__init__.py

@@ -0,0 +1,42 @@
+from typing import List, Tuple
+import heapq
+
+
+def min_interval(intervals: List[List[int]], queries: List[int]) -> List[int]:
+    query_len=len(queries)
+
+    query_indexes = list(range(query_len))
+    query_indexes.sort(key=lambda q: queries[q])
+
+    # Sort intervals in ascending order. Avoiding sorting in place to keep the 'intervals' input without side effects.
+    # Space incurred is O(n) where n is the size of intervals and time is O(n log(n))
+    sorted_intervals = sorted(intervals, key=lambda x: x[0])
+    intervals_len = len(sorted_intervals)
+
+    min_heap: List[Tuple[int, int]] = []
+
+    result = [-1] * query_len
+    # Pointer to sweep through interval list
+    i = 0
+
+    for query_idx in query_indexes:
+        query = queries[query_idx]
+
+        # Push all intervals that start at or before query into the heap
+        # (they are "eligible" to cover query, but might end before query)
+        while i < intervals_len and sorted_intervals[i][0] <= query:
+            current_interval = sorted_intervals[i]
+            interval_start, interval_end = current_interval
+            interval_size = interval_end - interval_start + 1
+            heapq.heappush(min_heap, (interval_size, interval_end))
+            i += 1
+
+        # Remove intervals that end before q (they can't cover q anymore)
+        while min_heap and min_heap[0][1] < query:
+            heapq.heappop(min_heap)
+
+        # If heap is not empty, top has the smallest size among intervals that cover q
+        if min_heap:
+            result[query_idx] = min_heap[0][0]
+
+    return result