# Solving Leetcode Interviews in Seconds with AI: Range Module


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "715" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> A Range Module is a module that tracks ranges of numbers. Design a data structure to track the ranges represented as half-open intervals and query about them. A half-open interval [left, right) denotes all the real numbers x where left <= x < right. Implement the RangeModule class:  RangeModule() Initializes the object of the data structure. void addRange(int left, int right) Adds the half-open interval [left, right), tracking every real number in that interval. Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval [left, right) that are not already tracked. boolean queryRange(int left, int right) Returns true if every real number in the interval [left, right) is currently being tracked, and false otherwise. void removeRange(int left, int right) Stops tracking every real number currently being tracked in the half-open interval [left, right).    Example 1:  Input ["RangeModule", "addRange", "removeRange", "queryRange", "queryRange", "queryRange"] [[], [10, 20], [14, 16], [10, 14], [13, 15], [16, 17]] Output [null, null, null, true, false, true]  Explanation RangeModule rangeModule = new RangeModule(); rangeModule.addRange(10, 20); rangeModule.removeRange(14, 16); rangeModule.queryRange(10, 14); // return True,(Every number in [10, 14) is being tracked) rangeModule.queryRange(13, 15); // return False,(Numbers like 14, 14.03, 14.17 in [13, 15) are not being tracked) rangeModule.queryRange(16, 17); // return True, (The number 16 in [16, 17) is still being tracked, despite the remove operation)    Constraints:  1 <= left < right <= 109 At most 104 calls will be made to addRange, queryRange, and removeRange.  

	# Explanation
	Here's a solution to the Range Module problem:

*   **Interval Management with Sorted List:** Maintain a sorted list of non-overlapping intervals. This allows efficient searching and merging of intervals during `addRange` and `removeRange` operations.

*   **Binary Search for Interval Operations:** Employ binary search to locate the positions where new intervals should be inserted, merged, or split during `addRange` and `removeRange`. This ensures logarithmic time complexity for these operations.

*   **Querying for Coverage:** In the `queryRange` operation, use binary search to find the interval that might contain the query range's start. If such an interval exists and it completely covers the query range, return true; otherwise, return false.

*   **Runtime Complexity:** O(N log N) where N is the number of intervals.  Storage Complexity: O(N)

	
	# Code
	```python
	class RangeModule:
    def __init__(self):
        self.intervals = []

    def addRange(self, left: int, right: int) -> None:
        new_interval = [left, right]
        new_intervals = []
        i = 0
        while i < len(self.intervals) and self.intervals[i][1] < new_interval[0]:
            new_intervals.append(self.intervals[i])
            i += 1

        while i < len(self.intervals) and self.intervals[i][0] <= new_interval[1]:
            new_interval[0] = min(new_interval[0], self.intervals[i][0])
            new_interval[1] = max(new_interval[1], self.intervals[i][1])
            i += 1

        new_intervals.append(new_interval)

        while i < len(self.intervals):
            new_intervals.append(self.intervals[i])
            i += 1

        self.intervals = new_intervals

    def queryRange(self, left: int, right: int) -> bool:
        l, r = 0, len(self.intervals) - 1
        while l <= r:
            mid = (l + r) // 2
            if self.intervals[mid][0] <= left and self.intervals[mid][1] >= right:
                return True
            elif self.intervals[mid][1] < left:
                l = mid + 1
            else:
                r = mid - 1
        return False

    def removeRange(self, left: int, right: int) -> None:
        new_intervals = []
        i = 0
        while i < len(self.intervals) and self.intervals[i][1] <= left:
            new_intervals.append(self.intervals[i])
            i += 1

        while i < len(self.intervals) and self.intervals[i][0] < right:
            interval = self.intervals[i]
            if interval[0] < left:
                new_intervals.append([interval[0], left])
            if interval[1] > right:
                new_intervals.append([right, interval[1]])
            i += 1

        while i < len(self.intervals):
            new_intervals.append(self.intervals[i])
            i += 1

        self.intervals = new_intervals
	```