Merge pull request #185 from Priyanka-Podder/master

Added 715. Range Module

Cpp/Range_Module/problem.md

@@ -0,0 +1,35 @@
+715. Range Module
+
+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.

Cpp/Range_Module/solution.cpp

@@ -0,0 +1,101 @@
+class RangeModule {
+private:
+    // Nested class to represent an interval with start and end values.
+    class Interval {
+        public:
+            int start;
+            int end;
+            // Constructor to initialize an interval with given start and end.
+            Interval (int left, int right) {
+                start = left;
+                end = right;
+            }
+    };
+    // Vector to store all intervals.
+    vector<Interval> intervals;
+
+public:
+    // Constructor for RangeModule.
+    RangeModule() {}
+
+    // Add a new range [left, right), merging overlapping intervals.
+    void addRange(int left, int right) {
+        vector<Interval> newIntervals;
+        int i = 0, n = intervals.size();
+        // Traverse intervals and merge with the new range if overlapping.
+        while (i < n) {
+            if (left > intervals[i].end) { // No overlap, add current interval.
+                newIntervals.push_back(intervals[i]);
+            } else if (intervals[i].start > right) { // No further overlap, insert new range.
+                newIntervals.push_back(Interval(left, right));
+                break;
+            } else { // Overlap, merge intervals.
+                left = min(left, intervals[i].start);
+                right = max(right, intervals[i].end);
+            }
+            i++;
+        }
+        // If all intervals have been processed, add the merged range.
+        if (i == n) {
+            newIntervals.push_back(Interval(left, right));
+        }
+        // Add remaining non-overlapping intervals.
+        while (i < n) {
+            newIntervals.push_back(intervals[i]);
+            i++;
+        }
+        intervals = newIntervals;
+    }
+
+    // Query if the entire range [left, right) is completely covered.
+    bool queryRange(int left, int right) {
+        int low = 0, high = intervals.size()-1;
+        // Binary search to find the interval that may cover [left, right).
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            if (intervals[mid].end <= left) { // Move right if current interval ends before the range.
+                low = mid + 1;
+            } else if (right <= intervals[mid].start) { // Move left if current interval starts after the range.
+                high = mid - 1;
+            } else { // Check if the range is fully covered by the current interval.
+                if (left >= intervals[mid].start && right <= intervals[mid].end) {
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+        }
+        return false;
+    }
+
+    // Remove the range [left, right), splitting intervals if necessary.
+    void removeRange(int left, int right) {
+        vector<Interval> newIntervals;
+        int i = 0, n = intervals.size();
+        // Traverse intervals and adjust the intervals based on the removal range.
+        while (i < n) {
+            if (left >= intervals[i].end) { // No overlap, add current interval.
+                newIntervals.push_back(intervals[i]);
+            } else if (intervals[i].start >= right) { // No further overlap, add remaining intervals.
+                newIntervals.push_back(intervals[i]);
+            } else { // Overlap, split the interval if necessary.
+                if (intervals[i].start < left) {
+                    newIntervals.push_back(Interval(intervals[i].start, left)); // Left part remains.
+                }
+                if (intervals[i].end > right) {
+                    newIntervals.push_back(Interval(right, intervals[i].end)); // Right part remains.
+                }
+            }
+            i++;
+        }
+        intervals = newIntervals;
+    }
+};
+
+/**
+ * Your RangeModule object will be instantiated and called as such:
+ * RangeModule* obj = new RangeModule();
+ * obj->addRange(left,right);
+ * bool param_2 = obj->queryRange(left,right);
+ * obj->removeRange(left,right);
+ */