segment-tree-lazy-propagation challenge

Author: IbatoLionDev

3-HARD/Python/4-segment-tree-lazy-propagation/proposed-solution/__pycache__/segment_tree.cpython-312.pyc

@@ -0,0 +1,17 @@
+# Challenge: Implement a segment tree that supports range queries and updates efficiently,
+# using lazy propagation to handle deferred updates without sacrificing performance.
+# Use object-oriented programming and follow the DRY principle.
+
+from segment_tree import SegmentTree
+
+def main():
+    data = [1, 3, 5, 7, 9, 11]
+    seg_tree = SegmentTree(data)
+
+    print("Initial sum of range [1, 3]:", seg_tree.query_range(1, 3))
+    seg_tree.update_range(1, 5, 10)
+    print("Sum of range [1, 3] after update:", seg_tree.query_range(1, 3))
+    print("Sum of range [0, 5]:", seg_tree.query_range(0, 5))
+
+if __name__ == "__main__":
+    main()

3-HARD/Python/4-segment-tree-lazy-propagation/proposed-solution/main.py

@@ -0,0 +1,65 @@
+from typing import List
+
+class SegmentTree:
+    def __init__(self, data: List[int]):
+        self.n = len(data)
+        self.tree = [0] * (4 * self.n)
+        self.lazy = [0] * (4 * self.n)
+        self._build(data, 0, 0, self.n - 1)
+
+    def _build(self, data: List[int], node: int, start: int, end: int):
+        if start == end:
+            self.tree[node] = data[start]
+        else:
+            mid = (start + end) // 2
+            self._build(data, 2 * node + 1, start, mid)
+            self._build(data, 2 * node + 2, mid + 1, end)
+            self.tree[node] = self.tree[2 * node + 1] + self.tree[2 * node + 2]
+
+    def _update_range(self, node: int, start: int, end: int, l: int, r: int, val: int):
+        if self.lazy[node] != 0:
+            self.tree[node] += (end - start + 1) * self.lazy[node]
+            if start != end:
+                self.lazy[2 * node + 1] += self.lazy[node]
+                self.lazy[2 * node + 2] += self.lazy[node]
+            self.lazy[node] = 0
+
+        if start > r or end < l:
+            return
+
+        if l <= start and end <= r:
+            self.tree[node] += (end - start + 1) * val
+            if start != end:
+                self.lazy[2 * node + 1] += val
+                self.lazy[2 * node + 2] += val
+            return
+
+        mid = (start + end) // 2
+        self._update_range(2 * node + 1, start, mid, l, r, val)
+        self._update_range(2 * node + 2, mid + 1, end, l, r, val)
+        self.tree[node] = self.tree[2 * node + 1] + self.tree[2 * node + 2]
+
+    def update_range(self, l: int, r: int, val: int):
+        self._update_range(0, 0, self.n - 1, l, r, val)
+
+    def _query_range(self, node: int, start: int, end: int, l: int, r: int) -> int:
+        if start > r or end < l:
+            return 0
+
+        if self.lazy[node] != 0:
+            self.tree[node] += (end - start + 1) * self.lazy[node]
+            if start != end:
+                self.lazy[2 * node + 1] += self.lazy[node]
+                self.lazy[2 * node + 2] += self.lazy[node]
+            self.lazy[node] = 0
+
+        if l <= start and end <= r:
+            return self.tree[node]
+
+        mid = (start + end) // 2
+        left_sum = self._query_range(2 * node + 1, start, mid, l, r)
+        right_sum = self._query_range(2 * node + 2, mid + 1, end, l, r)
+        return left_sum + right_sum
+
+    def query_range(self, l: int, r: int) -> int:
+        return self._query_range(0, 0, self.n - 1, l, r)