From 8ece70c708020c9e51bc05358311680807948297 Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Mon, 5 May 2025 00:45:46 -0500 Subject: [PATCH 01/21] add new file data_structures/binary_tree/segment_tree_node.py --- .../binary_tree/segment_tree_node.py | 204 ++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 data_structures/binary_tree/segment_tree_node.py diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py new file mode 100644 index 000000000000..23d24a745150 --- /dev/null +++ b/data_structures/binary_tree/segment_tree_node.py @@ -0,0 +1,204 @@ +class Node(): + def __init__(self, start, end): + # Initializes a segment tree node with start and end indices + self.start = start + self.end = end + self.value = None + self.left = None + self.right = None + + +class SegmentTree(): + def __init__(self, nums, mode='max'): + """ + Initializes the Segment Tree. + :param nums: List of integers to build the tree from. + :param mode: Operation mode of the tree ('max' or 'sum'). + """ + self.siz = len(nums) + self.mode = mode + if mode not in {'max', 'sum'}: + self.mode = 'max' # Default to max if invalid mode is given + + # Build the tree from the input list + self.root = self.build(0, self.siz - 1, nums) + + def build(self, start, end, nums): + """ + Recursively builds the segment tree. + :param start: Start index of the segment. + :param end: End index of the segment. + :param nums: Original input array. + :return: Root node of the constructed subtree. + """ + if start > end: + return None + + if start == end: + # Leaf node + n = Node(start, end) + n.value = nums[start] + return n + + mid = (start + end) // 2 + root = Node(start, end) + root.left = self.build(start, mid, nums) + root.right = self.build(mid + 1, end, nums) + + # Set the value according to the mode + if self.mode == 'max': + root.value = max(root.left.value, root.right.value) + else: + root.value = root.left.value + root.right.value + + return root + + def max_in_range(self, start_index, end_index): + """ + Queries the maximum value in a given range. + Only works in 'max' mode. + """ + if self.mode == 'sum': + raise Exception('Current Segment Tree doesn\'t support finding max') + + if start_index > end_index or start_index < 0 or end_index >= self.siz: + raise Exception('Invalid index') + + return self.query(self.root, start_index, end_index, 0, self.siz - 1) + + def sum_in_range(self, start_index, end_index): + """ + Queries the sum of values in a given range. + Only works in 'sum' mode. + """ + if self.mode == 'max': + raise Exception('Current Segment Tree doesn\'t support summing') + + if start_index > end_index or start_index < 0 or end_index >= self.siz: + raise Exception('Invalid index') + + return self.query(self.root, start_index, end_index, 0, self.siz - 1) + + def query(self, node, start_index, end_index, start, end): + """ + Recursively queries a value (max or sum) in a given range. + :param node: Current node in the tree. + :param start_index: Query start index. + :param end_index: Query end index. + :param start: Node's segment start. + :param end: Node's segment end. + :return: Result of query in the range. + """ + # Complete overlap + if start_index <= start and end <= end_index: + return node.value + + mid = (start + end) // 2 + + if end_index <= mid: + # Entire range is in the left child + return self.query(node.left, start_index, end_index, start, mid) + elif start_index > mid: + # Entire range is in the right child + return self.query(node.right, start_index, end_index, mid + 1, end) + else: + # Range spans both children + if self.mode == 'max': + return max( + self.query(node.left, start_index, end_index, start, mid), + self.query(node.right, start_index, end_index, mid + 1, end) + ) + else: + return ( + self.query(node.left, start_index, end_index, start, mid) + + self.query(node.right, start_index, end_index, mid + 1, end) + ) + + def update(self, index, new_value): + """ + Updates a value at a specific index in the segment tree. + :param index: Index to update. + :param new_value: New value to set. + """ + if index < 0 or index >= self.siz: + raise Exception('Invalid index') + + self.modify(self.root, index, new_value, 0, self.siz - 1) + + def modify(self, node, index, new_value, start, end): + """ + Recursively updates the tree to reflect a change at a specific index. + :param node: Current node being processed. + :param index: Index to update. + :param new_value: New value to assign. + :param start: Start index of node's segment. + :param end: End index of node's segment. + """ + if start == end: + node.value = new_value + return + + mid = (start + end) // 2 + + if index <= mid: + self.modify(node.left, index, new_value, start, mid) + else: + self.modify(node.right, index, new_value, mid + 1, end) + + # Recompute current node's value after update + if self.mode == 'max': + node.value = max(node.left.value, node.right.value) + else: + node.value = node.left.value + node.right.value + + +""" +nums = [1, 3, 5, 7, 9, 11] + +st_max = SegmentTree(nums, mode='max') +print(st_max.max_in_range(1, 3)) # Expected: 7 (max of [3,5,7]) +print(st_max.max_in_range(0, 5)) # Expected: 11 +st_max.update(3, 10) # nums[3] = 10 +print(st_max.max_in_range(1, 4)) # Expected: 10 + +try: + st_max.sum_in_range(0, 2) # Should raise exception +except Exception as e: + print(e) # Expected: Current Segment Tree doesn't support summing + +try: + st_max.max_in_range(3, 2) # Should raise exception +except Exception as e: + print(e) # Expected: Invalid index + +try: + st_max.max_in_range(1, 200) # Should raise exception +except Exception as e: + print(e) # Expected: Invalid index + + +st_sum = SegmentTree(nums, mode='sum') +print(st_sum.sum_in_range(1, 3)) # Expected: 15 (3+5+7) +print(st_sum.sum_in_range(0, 5)) # Expected: 36 (sum of all elements) +print(st_sum.sum_in_range(1, 3)) # Expected: 15 (3+5+7) +print(st_sum.sum_in_range(0, 5)) # Expected: 36 (sum of all elements) + +try: + st_sum.max_in_range(0, 2) # Should raise exception +except Exception as e: + print(e) # Expected: Current Segment Tree doesn't support finding max + +try: + st_sum.sum_in_range(3, 2) # Should raise exception +except Exception as e: + print(e) # Expected: Invalid index + +try: + st_sum.sum_in_range(1, 200) # Should raise exception +except Exception as e: + print(e) # Expected: Invalid index + + +st_invalid = SegmentTree(nums, mode='unknown') # Should default to 'max' +print(st_invalid.mode) # Expected: 'max' +""" \ No newline at end of file From 321d38ae42dd14f6f7f9d68228dce53a1b1b4dfb Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 May 2025 05:51:14 +0000 Subject: [PATCH 02/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../binary_tree/segment_tree_node.py | 57 +++++++++---------- 1 file changed, 28 insertions(+), 29 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 23d24a745150..a2ec1e3b9b3b 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,4 +1,4 @@ -class Node(): +class Node: def __init__(self, start, end): # Initializes a segment tree node with start and end indices self.start = start @@ -8,8 +8,8 @@ def __init__(self, start, end): self.right = None -class SegmentTree(): - def __init__(self, nums, mode='max'): +class SegmentTree: + def __init__(self, nums, mode="max"): """ Initializes the Segment Tree. :param nums: List of integers to build the tree from. @@ -17,8 +17,8 @@ def __init__(self, nums, mode='max'): """ self.siz = len(nums) self.mode = mode - if mode not in {'max', 'sum'}: - self.mode = 'max' # Default to max if invalid mode is given + if mode not in {"max", "sum"}: + self.mode = "max" # Default to max if invalid mode is given # Build the tree from the input list self.root = self.build(0, self.siz - 1, nums) @@ -39,14 +39,14 @@ def build(self, start, end, nums): n = Node(start, end) n.value = nums[start] return n - + mid = (start + end) // 2 root = Node(start, end) root.left = self.build(start, mid, nums) root.right = self.build(mid + 1, end, nums) # Set the value according to the mode - if self.mode == 'max': + if self.mode == "max": root.value = max(root.left.value, root.right.value) else: root.value = root.left.value + root.right.value @@ -58,12 +58,12 @@ def max_in_range(self, start_index, end_index): Queries the maximum value in a given range. Only works in 'max' mode. """ - if self.mode == 'sum': - raise Exception('Current Segment Tree doesn\'t support finding max') - + if self.mode == "sum": + raise Exception("Current Segment Tree doesn't support finding max") + if start_index > end_index or start_index < 0 or end_index >= self.siz: - raise Exception('Invalid index') - + raise Exception("Invalid index") + return self.query(self.root, start_index, end_index, 0, self.siz - 1) def sum_in_range(self, start_index, end_index): @@ -71,11 +71,11 @@ def sum_in_range(self, start_index, end_index): Queries the sum of values in a given range. Only works in 'sum' mode. """ - if self.mode == 'max': - raise Exception('Current Segment Tree doesn\'t support summing') - + if self.mode == "max": + raise Exception("Current Segment Tree doesn't support summing") + if start_index > end_index or start_index < 0 or end_index >= self.siz: - raise Exception('Invalid index') + raise Exception("Invalid index") return self.query(self.root, start_index, end_index, 0, self.siz - 1) @@ -92,7 +92,7 @@ def query(self, node, start_index, end_index, start, end): # Complete overlap if start_index <= start and end <= end_index: return node.value - + mid = (start + end) // 2 if end_index <= mid: @@ -103,16 +103,15 @@ def query(self, node, start_index, end_index, start, end): return self.query(node.right, start_index, end_index, mid + 1, end) else: # Range spans both children - if self.mode == 'max': + if self.mode == "max": return max( self.query(node.left, start_index, end_index, start, mid), - self.query(node.right, start_index, end_index, mid + 1, end) + self.query(node.right, start_index, end_index, mid + 1, end), ) else: - return ( - self.query(node.left, start_index, end_index, start, mid) + - self.query(node.right, start_index, end_index, mid + 1, end) - ) + return self.query( + node.left, start_index, end_index, start, mid + ) + self.query(node.right, start_index, end_index, mid + 1, end) def update(self, index, new_value): """ @@ -121,8 +120,8 @@ def update(self, index, new_value): :param new_value: New value to set. """ if index < 0 or index >= self.siz: - raise Exception('Invalid index') - + raise Exception("Invalid index") + self.modify(self.root, index, new_value, 0, self.siz - 1) def modify(self, node, index, new_value, start, end): @@ -137,16 +136,16 @@ def modify(self, node, index, new_value, start, end): if start == end: node.value = new_value return - + mid = (start + end) // 2 if index <= mid: self.modify(node.left, index, new_value, start, mid) else: self.modify(node.right, index, new_value, mid + 1, end) - + # Recompute current node's value after update - if self.mode == 'max': + if self.mode == "max": node.value = max(node.left.value, node.right.value) else: node.value = node.left.value + node.right.value @@ -201,4 +200,4 @@ def modify(self, node, index, new_value, start, end): st_invalid = SegmentTree(nums, mode='unknown') # Should default to 'max' print(st_invalid.mode) # Expected: 'max' -""" \ No newline at end of file +""" From 4c6df263c7e599872ab967642f3c3058d91fc0be Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Mon, 5 May 2025 00:57:33 -0500 Subject: [PATCH 03/21] add new file data_structures/binary_tree/segment_tree_node.py fixed --- .../binary_tree/segment_tree_node.py | 83 +++---------------- 1 file changed, 12 insertions(+), 71 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 23d24a745150..597f38547185 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -7,7 +7,6 @@ def __init__(self, start, end): self.left = None self.right = None - class SegmentTree(): def __init__(self, nums, mode='max'): """ @@ -15,13 +14,13 @@ def __init__(self, nums, mode='max'): :param nums: List of integers to build the tree from. :param mode: Operation mode of the tree ('max' or 'sum'). """ - self.siz = len(nums) + self.size = len(nums) self.mode = mode if mode not in {'max', 'sum'}: self.mode = 'max' # Default to max if invalid mode is given # Build the tree from the input list - self.root = self.build(0, self.siz - 1, nums) + self.root = self.build(0, self.size - 1, nums) def build(self, start, end, nums): """ @@ -61,10 +60,10 @@ def max_in_range(self, start_index, end_index): if self.mode == 'sum': raise Exception('Current Segment Tree doesn\'t support finding max') - if start_index > end_index or start_index < 0 or end_index >= self.siz: + if start_index > end_index or start_index < 0 or end_index >= self.size: raise Exception('Invalid index') - return self.query(self.root, start_index, end_index, 0, self.siz - 1) + return self.query(self.root, start_index, end_index, 0, self.size - 1) def sum_in_range(self, start_index, end_index): """ @@ -74,10 +73,10 @@ def sum_in_range(self, start_index, end_index): if self.mode == 'max': raise Exception('Current Segment Tree doesn\'t support summing') - if start_index > end_index or start_index < 0 or end_index >= self.siz: + if start_index > end_index or start_index < 0 or end_index >= self.size: raise Exception('Invalid index') - return self.query(self.root, start_index, end_index, 0, self.siz - 1) + return self.query(self.root, start_index, end_index, 0, self.size - 1) def query(self, node, start_index, end_index, start, end): """ @@ -104,15 +103,9 @@ def query(self, node, start_index, end_index, start, end): else: # Range spans both children if self.mode == 'max': - return max( - self.query(node.left, start_index, end_index, start, mid), - self.query(node.right, start_index, end_index, mid + 1, end) - ) + return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) else: - return ( - self.query(node.left, start_index, end_index, start, mid) + - self.query(node.right, start_index, end_index, mid + 1, end) - ) + return (self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end)) def update(self, index, new_value): """ @@ -120,10 +113,10 @@ def update(self, index, new_value): :param index: Index to update. :param new_value: New value to set. """ - if index < 0 or index >= self.siz: + if index < 0 or index >= self.size: raise Exception('Invalid index') - self.modify(self.root, index, new_value, 0, self.siz - 1) + self.modify(self.root, index, new_value, 0, self.size - 1) def modify(self, node, index, new_value, start, end): """ @@ -137,7 +130,7 @@ def modify(self, node, index, new_value, start, end): if start == end: node.value = new_value return - + mid = (start + end) // 2 if index <= mid: @@ -149,56 +142,4 @@ def modify(self, node, index, new_value, start, end): if self.mode == 'max': node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value - - -""" -nums = [1, 3, 5, 7, 9, 11] - -st_max = SegmentTree(nums, mode='max') -print(st_max.max_in_range(1, 3)) # Expected: 7 (max of [3,5,7]) -print(st_max.max_in_range(0, 5)) # Expected: 11 -st_max.update(3, 10) # nums[3] = 10 -print(st_max.max_in_range(1, 4)) # Expected: 10 - -try: - st_max.sum_in_range(0, 2) # Should raise exception -except Exception as e: - print(e) # Expected: Current Segment Tree doesn't support summing - -try: - st_max.max_in_range(3, 2) # Should raise exception -except Exception as e: - print(e) # Expected: Invalid index - -try: - st_max.max_in_range(1, 200) # Should raise exception -except Exception as e: - print(e) # Expected: Invalid index - - -st_sum = SegmentTree(nums, mode='sum') -print(st_sum.sum_in_range(1, 3)) # Expected: 15 (3+5+7) -print(st_sum.sum_in_range(0, 5)) # Expected: 36 (sum of all elements) -print(st_sum.sum_in_range(1, 3)) # Expected: 15 (3+5+7) -print(st_sum.sum_in_range(0, 5)) # Expected: 36 (sum of all elements) - -try: - st_sum.max_in_range(0, 2) # Should raise exception -except Exception as e: - print(e) # Expected: Current Segment Tree doesn't support finding max - -try: - st_sum.sum_in_range(3, 2) # Should raise exception -except Exception as e: - print(e) # Expected: Invalid index - -try: - st_sum.sum_in_range(1, 200) # Should raise exception -except Exception as e: - print(e) # Expected: Invalid index - - -st_invalid = SegmentTree(nums, mode='unknown') # Should default to 'max' -print(st_invalid.mode) # Expected: 'max' -""" \ No newline at end of file + node.value = node.left.value + node.right.value \ No newline at end of file From cd6dca2d7899a7ff5353564ead6831173ef1ba0a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 May 2025 06:02:21 +0000 Subject: [PATCH 04/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../binary_tree/segment_tree_node.py | 56 ++++++++++--------- 1 file changed, 31 insertions(+), 25 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 597f38547185..d0aa3801e43c 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,4 +1,4 @@ -class Node(): +class Node: def __init__(self, start, end): # Initializes a segment tree node with start and end indices self.start = start @@ -7,8 +7,9 @@ def __init__(self, start, end): self.left = None self.right = None -class SegmentTree(): - def __init__(self, nums, mode='max'): + +class SegmentTree: + def __init__(self, nums, mode="max"): """ Initializes the Segment Tree. :param nums: List of integers to build the tree from. @@ -16,8 +17,8 @@ def __init__(self, nums, mode='max'): """ self.size = len(nums) self.mode = mode - if mode not in {'max', 'sum'}: - self.mode = 'max' # Default to max if invalid mode is given + if mode not in {"max", "sum"}: + self.mode = "max" # Default to max if invalid mode is given # Build the tree from the input list self.root = self.build(0, self.size - 1, nums) @@ -38,14 +39,14 @@ def build(self, start, end, nums): n = Node(start, end) n.value = nums[start] return n - + mid = (start + end) // 2 root = Node(start, end) root.left = self.build(start, mid, nums) root.right = self.build(mid + 1, end, nums) # Set the value according to the mode - if self.mode == 'max': + if self.mode == "max": root.value = max(root.left.value, root.right.value) else: root.value = root.left.value + root.right.value @@ -57,12 +58,12 @@ def max_in_range(self, start_index, end_index): Queries the maximum value in a given range. Only works in 'max' mode. """ - if self.mode == 'sum': - raise Exception('Current Segment Tree doesn\'t support finding max') - + if self.mode == "sum": + raise Exception("Current Segment Tree doesn't support finding max") + if start_index > end_index or start_index < 0 or end_index >= self.size: - raise Exception('Invalid index') - + raise Exception("Invalid index") + return self.query(self.root, start_index, end_index, 0, self.size - 1) def sum_in_range(self, start_index, end_index): @@ -70,11 +71,11 @@ def sum_in_range(self, start_index, end_index): Queries the sum of values in a given range. Only works in 'sum' mode. """ - if self.mode == 'max': - raise Exception('Current Segment Tree doesn\'t support summing') - + if self.mode == "max": + raise Exception("Current Segment Tree doesn't support summing") + if start_index > end_index or start_index < 0 or end_index >= self.size: - raise Exception('Invalid index') + raise Exception("Invalid index") return self.query(self.root, start_index, end_index, 0, self.size - 1) @@ -91,7 +92,7 @@ def query(self, node, start_index, end_index, start, end): # Complete overlap if start_index <= start and end <= end_index: return node.value - + mid = (start + end) // 2 if end_index <= mid: @@ -102,10 +103,15 @@ def query(self, node, start_index, end_index, start, end): return self.query(node.right, start_index, end_index, mid + 1, end) else: # Range spans both children - if self.mode == 'max': - return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) + if self.mode == "max": + return max( + self.query(node.left, start_index, end_index, start, mid), + self.query(node.right, start_index, end_index, mid + 1, end), + ) else: - return (self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end)) + return self.query( + node.left, start_index, end_index, start, mid + ) + self.query(node.right, start_index, end_index, mid + 1, end) def update(self, index, new_value): """ @@ -114,8 +120,8 @@ def update(self, index, new_value): :param new_value: New value to set. """ if index < 0 or index >= self.size: - raise Exception('Invalid index') - + raise Exception("Invalid index") + self.modify(self.root, index, new_value, 0, self.size - 1) def modify(self, node, index, new_value, start, end): @@ -137,9 +143,9 @@ def modify(self, node, index, new_value, start, end): self.modify(node.left, index, new_value, start, mid) else: self.modify(node.right, index, new_value, mid + 1, end) - + # Recompute current node's value after update - if self.mode == 'max': + if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value \ No newline at end of file + node.value = node.left.value + node.right.value From 5b892bbad58e10beab0eecd3cd36a5300492a8a7 Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Mon, 5 May 2025 01:07:30 -0500 Subject: [PATCH 05/21] add new file data_structures/binary_tree/segment_tree_node.py add ret type --- data_structures/binary_tree/segment_tree_node.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 597f38547185..fb0f58af88b3 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,5 +1,5 @@ class Node(): - def __init__(self, start, end): + def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices self.start = start self.end = end @@ -8,7 +8,7 @@ def __init__(self, start, end): self.right = None class SegmentTree(): - def __init__(self, nums, mode='max'): + def __init__(self, nums: list[int], mode: str='max') -> None: """ Initializes the Segment Tree. :param nums: List of integers to build the tree from. @@ -22,7 +22,7 @@ def __init__(self, nums, mode='max'): # Build the tree from the input list self.root = self.build(0, self.size - 1, nums) - def build(self, start, end, nums): + def build(self, start: int, end: int, nums: list[int]) -> Node: """ Recursively builds the segment tree. :param start: Start index of the segment. @@ -52,7 +52,7 @@ def build(self, start, end, nums): return root - def max_in_range(self, start_index, end_index): + def max_in_range(self, start_index: int, end_index: int) -> int: """ Queries the maximum value in a given range. Only works in 'max' mode. @@ -65,7 +65,7 @@ def max_in_range(self, start_index, end_index): return self.query(self.root, start_index, end_index, 0, self.size - 1) - def sum_in_range(self, start_index, end_index): + def sum_in_range(self, start_index: int, end_index: int) -> int: """ Queries the sum of values in a given range. Only works in 'sum' mode. @@ -78,7 +78,7 @@ def sum_in_range(self, start_index, end_index): return self.query(self.root, start_index, end_index, 0, self.size - 1) - def query(self, node, start_index, end_index, start, end): + def query(self, node: Node, start_index: int, end_index: int, start: int, end: int) -> int: """ Recursively queries a value (max or sum) in a given range. :param node: Current node in the tree. @@ -107,7 +107,7 @@ def query(self, node, start_index, end_index, start, end): else: return (self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end)) - def update(self, index, new_value): + def update(self, index: int, new_value: int) -> int: """ Updates a value at a specific index in the segment tree. :param index: Index to update. @@ -118,7 +118,7 @@ def update(self, index, new_value): self.modify(self.root, index, new_value, 0, self.size - 1) - def modify(self, node, index, new_value, start, end): + def modify(self, node: Node, index: int, new_value: int, start: int, end: int) -> int: """ Recursively updates the tree to reflect a change at a specific index. :param node: Current node being processed. From 52da8ebd871ad77d11266871bf4a963ba4440ac7 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 May 2025 06:08:50 +0000 Subject: [PATCH 06/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../binary_tree/segment_tree_node.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index b77c5cff826a..2342e26a1204 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,4 +1,4 @@ -class Node(): +class Node: def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices self.start = start @@ -7,8 +7,9 @@ def __init__(self, start: int, end: int) -> None: self.left = None self.right = None -class SegmentTree(): - def __init__(self, nums: list[int], mode: str='max') -> None: + +class SegmentTree: + def __init__(self, nums: list[int], mode: str = "max") -> None: """ Initializes the Segment Tree. :param nums: List of integers to build the tree from. @@ -78,7 +79,9 @@ def sum_in_range(self, start_index: int, end_index: int) -> int: return self.query(self.root, start_index, end_index, 0, self.size - 1) - def query(self, node: Node, start_index: int, end_index: int, start: int, end: int) -> int: + def query( + self, node: Node, start_index: int, end_index: int, start: int, end: int + ) -> int: """ Recursively queries a value (max or sum) in a given range. :param node: Current node in the tree. @@ -123,7 +126,9 @@ def update(self, index: int, new_value: int) -> int: self.modify(self.root, index, new_value, 0, self.size - 1) - def modify(self, node: Node, index: int, new_value: int, start: int, end: int) -> int: + def modify( + self, node: Node, index: int, new_value: int, start: int, end: int + ) -> int: """ Recursively updates the tree to reflect a change at a specific index. :param node: Current node being processed. @@ -147,4 +152,4 @@ def modify(self, node: Node, index: int, new_value: int, start: int, end: int) - if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value \ No newline at end of file + node.value = node.left.value + node.right.value From 9e39d11b30015df78c20369f46ce658c722874ea Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Mon, 5 May 2025 01:13:15 -0500 Subject: [PATCH 07/21] add new file data_structures/binary_tree/segment_tree_node.py fixedtypo --- data_structures/binary_tree/segment_tree_node.py | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index b77c5cff826a..a5f5f3979811 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,4 +1,4 @@ -class Node(): +class Node: def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices self.start = start @@ -7,7 +7,7 @@ def __init__(self, start: int, end: int) -> None: self.left = None self.right = None -class SegmentTree(): +class SegmentTree: def __init__(self, nums: list[int], mode: str='max') -> None: """ Initializes the Segment Tree. @@ -103,14 +103,9 @@ def query(self, node: Node, start_index: int, end_index: int, start: int, end: i else: # Range spans both children if self.mode == "max": - return max( - self.query(node.left, start_index, end_index, start, mid), - self.query(node.right, start_index, end_index, mid + 1, end), - ) + return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) else: - return self.query( - node.left, start_index, end_index, start, mid - ) + self.query(node.right, start_index, end_index, mid + 1, end) + return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) def update(self, index: int, new_value: int) -> int: """ From cb5762c2a5f27c98c3a8958b8977ac23c9e2f0aa Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 May 2025 06:18:17 +0000 Subject: [PATCH 08/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../binary_tree/segment_tree_node.py | 46 +++++++++++-------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 3b46d63cd1a4..2342e26a1204 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -7,8 +7,9 @@ def __init__(self, start: int, end: int) -> None: self.left = None self.right = None + class SegmentTree: - def __init__(self, nums: list[int], mode: str='max') -> None: + def __init__(self, nums: list[int], mode: str = "max") -> None: """ Initializes the Segment Tree. :param nums: List of integers to build the tree from. @@ -16,8 +17,8 @@ def __init__(self, nums: list[int], mode: str='max') -> None: """ self.size = len(nums) self.mode = mode - if mode not in {'max', 'sum'}: - self.mode = 'max' # Default to max if invalid mode is given + if mode not in {"max", "sum"}: + self.mode = "max" # Default to max if invalid mode is given # Build the tree from the input list self.root = self.build(0, self.size - 1, nums) @@ -45,7 +46,7 @@ def build(self, start: int, end: int, nums: list[int]) -> Node: root.right = self.build(mid + 1, end, nums) # Set the value according to the mode - if self.mode == 'max': + if self.mode == "max": root.value = max(root.left.value, root.right.value) else: root.value = root.left.value + root.right.value @@ -57,11 +58,11 @@ def max_in_range(self, start_index: int, end_index: int) -> int: Queries the maximum value in a given range. Only works in 'max' mode. """ - if self.mode == 'sum': - raise Exception('Current Segment Tree doesn\'t support finding max') + if self.mode == "sum": + raise Exception("Current Segment Tree doesn't support finding max") if start_index > end_index or start_index < 0 or end_index >= self.size: - raise Exception('Invalid index') + raise Exception("Invalid index") return self.query(self.root, start_index, end_index, 0, self.size - 1) @@ -70,15 +71,17 @@ def sum_in_range(self, start_index: int, end_index: int) -> int: Queries the sum of values in a given range. Only works in 'sum' mode. """ - if self.mode == 'max': - raise Exception('Current Segment Tree doesn\'t support summing') + if self.mode == "max": + raise Exception("Current Segment Tree doesn't support summing") if start_index > end_index or start_index < 0 or end_index >= self.size: - raise Exception('Invalid index') + raise Exception("Invalid index") return self.query(self.root, start_index, end_index, 0, self.size - 1) - def query(self, node: Node, start_index: int, end_index: int, start: int, end: int) -> int: + def query( + self, node: Node, start_index: int, end_index: int, start: int, end: int + ) -> int: """ Recursively queries a value (max or sum) in a given range. :param node: Current node in the tree. @@ -102,10 +105,15 @@ def query(self, node: Node, start_index: int, end_index: int, start: int, end: i return self.query(node.right, start_index, end_index, mid + 1, end) else: # Range spans both children - if self.mode == 'max': - return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) + if self.mode == "max": + return max( + self.query(node.left, start_index, end_index, start, mid), + self.query(node.right, start_index, end_index, mid + 1, end), + ) else: - return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) + return self.query( + node.left, start_index, end_index, start, mid + ) + self.query(node.right, start_index, end_index, mid + 1, end) def update(self, index: int, new_value: int) -> int: """ @@ -114,11 +122,13 @@ def update(self, index: int, new_value: int) -> int: :param new_value: New value to set. """ if index < 0 or index >= self.size: - raise Exception('Invalid index') + raise Exception("Invalid index") self.modify(self.root, index, new_value, 0, self.size - 1) - def modify(self, node: Node, index: int, new_value: int, start: int, end: int) -> int: + def modify( + self, node: Node, index: int, new_value: int, start: int, end: int + ) -> int: """ Recursively updates the tree to reflect a change at a specific index. :param node: Current node being processed. @@ -139,7 +149,7 @@ def modify(self, node: Node, index: int, new_value: int, start: int, end: int) - self.modify(node.right, index, new_value, mid + 1, end) # Recompute current node's value after update - if self.mode == 'max': + if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value \ No newline at end of file + node.value = node.left.value + node.right.value From 8b8c832b17ae778cc70e900c29eb30168a5ec734 Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Tue, 6 May 2025 00:19:36 -0500 Subject: [PATCH 09/21] fixed elif statement --- data_structures/binary_tree/segment_tree_node.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 3b46d63cd1a4..69ec684e2a1b 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -100,12 +100,10 @@ def query(self, node: Node, start_index: int, end_index: int, start: int, end: i elif start_index > mid: # Entire range is in the right child return self.query(node.right, start_index, end_index, mid + 1, end) + elif self.mode == 'max': + return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) else: - # Range spans both children - if self.mode == 'max': - return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) - else: - return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) + return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) def update(self, index: int, new_value: int) -> int: """ From 12d6a8828e161df781a7aa13163e985ed25c5d37 Mon Sep 17 00:00:00 2001 From: "Yu-Chi (Daniel) Lin" <61955371+xxx595588@users.noreply.github.com> Date: Tue, 6 May 2025 00:26:40 -0500 Subject: [PATCH 10/21] Update segment_tree_node.py --- data_structures/binary_tree/segment_tree_node.py | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index d27e00e494cd..4cea02400013 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -106,20 +106,7 @@ def query( elif self.mode == 'max': return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) else: -<<<<<<< HEAD return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) -======= - # Range spans both children - if self.mode == "max": - return max( - self.query(node.left, start_index, end_index, start, mid), - self.query(node.right, start_index, end_index, mid + 1, end), - ) - else: - return self.query( - node.left, start_index, end_index, start, mid - ) + self.query(node.right, start_index, end_index, mid + 1, end) ->>>>>>> cb5762c2a5f27c98c3a8958b8977ac23c9e2f0aa def update(self, index: int, new_value: int) -> int: """ From a054a2286509df6a81383dd1f3ed6493beed9d9a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 6 May 2025 05:27:04 +0000 Subject: [PATCH 11/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- data_structures/binary_tree/segment_tree_node.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 4cea02400013..0edb04c4c030 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -103,10 +103,15 @@ def query( elif start_index > mid: # Entire range is in the right child return self.query(node.right, start_index, end_index, mid + 1, end) - elif self.mode == 'max': - return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) + elif self.mode == "max": + return max( + self.query(node.left, start_index, end_index, start, mid), + self.query(node.right, start_index, end_index, mid + 1, end), + ) else: - return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) + return self.query( + node.left, start_index, end_index, start, mid + ) + self.query(node.right, start_index, end_index, mid + 1, end) def update(self, index: int, new_value: int) -> int: """ From 14ce155a38feeefd2798c76eaae8924827c0a68e Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Tue, 6 May 2025 00:31:57 -0500 Subject: [PATCH 12/21] add optional --- .../binary_tree/segment_tree_node.py | 26 +++++-------------- 1 file changed, 7 insertions(+), 19 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index d27e00e494cd..3e160749f9df 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,12 +1,13 @@ +from typing import Optional + class Node: def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices self.start = start self.end = end - self.value = None - self.left = None - self.right = None - + self.value: Optional[int] = None + self.left: Optional["Node"] = None + self.right: Optional["Node"] = None class SegmentTree: def __init__(self, nums: list[int], mode: str = "max") -> None: @@ -21,9 +22,9 @@ def __init__(self, nums: list[int], mode: str = "max") -> None: self.mode = "max" # Default to max if invalid mode is given # Build the tree from the input list - self.root = self.build(0, self.size - 1, nums) + self.root: Optional[Node] = self.build(0, self.size - 1, nums) - def build(self, start: int, end: int, nums: list[int]) -> Node: + def build(self, start: int, end: int, nums: list[int]) -> Optional[Node]: """ Recursively builds the segment tree. :param start: Start index of the segment. @@ -106,20 +107,7 @@ def query( elif self.mode == 'max': return max(self.query(node.left, start_index, end_index, start, mid), self.query(node.right, start_index, end_index, mid + 1, end)) else: -<<<<<<< HEAD return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) -======= - # Range spans both children - if self.mode == "max": - return max( - self.query(node.left, start_index, end_index, start, mid), - self.query(node.right, start_index, end_index, mid + 1, end), - ) - else: - return self.query( - node.left, start_index, end_index, start, mid - ) + self.query(node.right, start_index, end_index, mid + 1, end) ->>>>>>> cb5762c2a5f27c98c3a8958b8977ac23c9e2f0aa def update(self, index: int, new_value: int) -> int: """ From f7f4980bb2d2fa485f840ea6edd77ca93f95ee08 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 6 May 2025 05:33:10 +0000 Subject: [PATCH 13/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- data_structures/binary_tree/segment_tree_node.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 000c5ea95098..ba7712e2e7fc 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,5 +1,6 @@ from typing import Optional + class Node: def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices @@ -9,6 +10,7 @@ def __init__(self, start: int, end: int) -> None: self.left: Optional["Node"] = None self.right: Optional["Node"] = None + class SegmentTree: def __init__(self, nums: list[int], mode: str = "max") -> None: """ @@ -110,7 +112,9 @@ def query( self.query(node.right, start_index, end_index, mid + 1, end), ) else: - return self.query(node.left, start_index, end_index, start, mid) + self.query(node.right, start_index, end_index, mid + 1, end) + return self.query( + node.left, start_index, end_index, start, mid + ) + self.query(node.right, start_index, end_index, mid + 1, end) def update(self, index: int, new_value: int) -> int: """ From 8ea6c0fe38503ea48986b8a94a60721523be9628 Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Tue, 6 May 2025 00:37:16 -0500 Subject: [PATCH 14/21] fixed type annotation --- data_structures/binary_tree/segment_tree_node.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 000c5ea95098..42362bd4f1b2 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -1,13 +1,11 @@ -from typing import Optional - class Node: def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices self.start = start self.end = end - self.value: Optional[int] = None - self.left: Optional["Node"] = None - self.right: Optional["Node"] = None + self.value: int | None = None + self.left: Node | None = None + self.right: Node | None = None class SegmentTree: def __init__(self, nums: list[int], mode: str = "max") -> None: @@ -22,9 +20,9 @@ def __init__(self, nums: list[int], mode: str = "max") -> None: self.mode = "max" # Default to max if invalid mode is given # Build the tree from the input list - self.root: Optional[Node] = self.build(0, self.size - 1, nums) + self.root: Node | None = self.build(0, self.size - 1, nums) - def build(self, start: int, end: int, nums: list[int]) -> Optional[Node]: + def build(self, start: int, end: int, nums: list[int]) -> Node| None: """ Recursively builds the segment tree. :param start: Start index of the segment. From fa8fe963bdc8ed9d6f213780bbcd8b31816de6cf Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 6 May 2025 05:38:16 +0000 Subject: [PATCH 15/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- data_structures/binary_tree/segment_tree_node.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 83b988252f77..358005d0379e 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -4,8 +4,8 @@ def __init__(self, start: int, end: int) -> None: self.start = start self.end = end self.value: int | None = None - self.left: Node | None = None - self.right: Node | None = None + self.left: Node | None = None + self.right: Node | None = None class SegmentTree: @@ -23,7 +23,7 @@ def __init__(self, nums: list[int], mode: str = "max") -> None: # Build the tree from the input list self.root: Node | None = self.build(0, self.size - 1, nums) - def build(self, start: int, end: int, nums: list[int]) -> Node| None: + def build(self, start: int, end: int, nums: list[int]) -> Node | None: """ Recursively builds the segment tree. :param start: Start index of the segment. From ba3008cf67cc62e7e77c5c1ff90b720a58607ed6 Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Tue, 6 May 2025 00:46:11 -0500 Subject: [PATCH 16/21] fixed ret type error --- .../binary_tree/segment_tree_node.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 83b988252f77..655e9be467f7 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -3,7 +3,7 @@ def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices self.start = start self.end = end - self.value: int | None = None + self.value: int = None self.left: Node | None = None self.right: Node | None = None @@ -23,7 +23,7 @@ def __init__(self, nums: list[int], mode: str = "max") -> None: # Build the tree from the input list self.root: Node | None = self.build(0, self.size - 1, nums) - def build(self, start: int, end: int, nums: list[int]) -> Node| None: + def build(self, start: int, end: int, nums: list[int]) -> Node: """ Recursively builds the segment tree. :param start: Start index of the segment. @@ -32,7 +32,7 @@ def build(self, start: int, end: int, nums: list[int]) -> Node| None: :return: Root node of the constructed subtree. """ if start > end: - return None + return if start == end: # Leaf node @@ -64,6 +64,9 @@ def max_in_range(self, start_index: int, end_index: int) -> int: if start_index > end_index or start_index < 0 or end_index >= self.size: raise Exception("Invalid index") + if self.root is None: + raise ValueError("Tree not initialized") + return self.query(self.root, start_index, end_index, 0, self.size - 1) def sum_in_range(self, start_index: int, end_index: int) -> int: @@ -77,6 +80,9 @@ def sum_in_range(self, start_index: int, end_index: int) -> int: if start_index > end_index or start_index < 0 or end_index >= self.size: raise Exception("Invalid index") + if self.root is None: + raise ValueError("Tree not initialized") + return self.query(self.root, start_index, end_index, 0, self.size - 1) def query( @@ -113,7 +119,7 @@ def query( node.left, start_index, end_index, start, mid ) + self.query(node.right, start_index, end_index, mid + 1, end) - def update(self, index: int, new_value: int) -> int: + def update(self, index: int, new_value: int) -> None: """ Updates a value at a specific index in the segment tree. :param index: Index to update. @@ -126,7 +132,7 @@ def update(self, index: int, new_value: int) -> int: def modify( self, node: Node, index: int, new_value: int, start: int, end: int - ) -> int: + ) -> None: """ Recursively updates the tree to reflect a change at a specific index. :param node: Current node being processed. @@ -150,4 +156,4 @@ def modify( if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value + node.value = node.left.value + node.right.value \ No newline at end of file From f96b4cbdd089032809a0b27592bacb21396349b7 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 6 May 2025 05:47:08 +0000 Subject: [PATCH 17/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- data_structures/binary_tree/segment_tree_node.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 655e9be467f7..c0c7a26365c5 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -4,8 +4,8 @@ def __init__(self, start: int, end: int) -> None: self.start = start self.end = end self.value: int = None - self.left: Node | None = None - self.right: Node | None = None + self.left: Node | None = None + self.right: Node | None = None class SegmentTree: @@ -156,4 +156,4 @@ def modify( if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value \ No newline at end of file + node.value = node.left.value + node.right.value From 987c1aa5c1b347ac070bbd2f0761e395c23d3493 Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Tue, 6 May 2025 00:50:48 -0500 Subject: [PATCH 18/21] fixed init --- data_structures/binary_tree/segment_tree_node.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 655e9be467f7..47bd2b17c822 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -3,9 +3,9 @@ def __init__(self, start: int, end: int) -> None: # Initializes a segment tree node with start and end indices self.start = start self.end = end - self.value: int = None - self.left: Node | None = None - self.right: Node | None = None + self.value: int = 0 + self.left: Node = self + self.right: Node = self class SegmentTree: @@ -21,7 +21,7 @@ def __init__(self, nums: list[int], mode: str = "max") -> None: self.mode = "max" # Default to max if invalid mode is given # Build the tree from the input list - self.root: Node | None = self.build(0, self.size - 1, nums) + self.root: Node = self.build(0, self.size - 1, nums) def build(self, start: int, end: int, nums: list[int]) -> Node: """ From 9725d2c04df59db4fd9e99ee1159c4e3bf5a5ff8 Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Tue, 6 May 2025 00:55:17 -0500 Subject: [PATCH 19/21] fixed build ret --- data_structures/binary_tree/segment_tree_node.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index 85ae61e3a758..d2be17ef6798 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -32,7 +32,7 @@ def build(self, start: int, end: int, nums: list[int]) -> Node: :return: Root node of the constructed subtree. """ if start > end: - return + return Node(0, 0) if start == end: # Leaf node @@ -156,4 +156,4 @@ def modify( if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value + node.value = node.left.value + node.right.value \ No newline at end of file From 87043320b3169c1ee620ecbde6af5626ca9eee99 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 6 May 2025 05:55:44 +0000 Subject: [PATCH 20/21] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- data_structures/binary_tree/segment_tree_node.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index d2be17ef6798..06b035b012a2 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -156,4 +156,4 @@ def modify( if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value \ No newline at end of file + node.value = node.left.value + node.right.value From 040112443fd39c6094d82d0b36c5eaab12c5582d Mon Sep 17 00:00:00 2001 From: Daniel Lin Date: Tue, 6 May 2025 01:04:44 -0500 Subject: [PATCH 21/21] add doctest --- .../binary_tree/segment_tree_node.py | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/data_structures/binary_tree/segment_tree_node.py b/data_structures/binary_tree/segment_tree_node.py index d2be17ef6798..d47c77048343 100644 --- a/data_structures/binary_tree/segment_tree_node.py +++ b/data_structures/binary_tree/segment_tree_node.py @@ -30,6 +30,10 @@ def build(self, start: int, end: int, nums: list[int]) -> Node: :param end: End index of the segment. :param nums: Original input array. :return: Root node of the constructed subtree. + + >>> tree = SegmentTree([1, 2, 3, 4, 5], mode="max") + >>> tree.root.value + 5 """ if start > end: return Node(0, 0) @@ -57,6 +61,10 @@ def max_in_range(self, start_index: int, end_index: int) -> int: """ Queries the maximum value in a given range. Only works in 'max' mode. + + >>> tree = SegmentTree([1, 2, 3, 4, 5], mode="max") + >>> tree.max_in_range(1, 3) + 4 """ if self.mode == "sum": raise Exception("Current Segment Tree doesn't support finding max") @@ -73,6 +81,10 @@ def sum_in_range(self, start_index: int, end_index: int) -> int: """ Queries the sum of values in a given range. Only works in 'sum' mode. + + >>> tree = SegmentTree([1, 2, 3, 4, 5], mode="sum") + >>> tree.sum_in_range(1, 3) + 9 """ if self.mode == "max": raise Exception("Current Segment Tree doesn't support summing") @@ -96,6 +108,10 @@ def query( :param start: Node's segment start. :param end: Node's segment end. :return: Result of query in the range. + + >>> tree = SegmentTree([1, 2, 3, 4, 5], mode="max") + >>> tree.query(tree.root, 1, 3, 0, 4) + 4 """ # Complete overlap if start_index <= start and end <= end_index: @@ -124,6 +140,11 @@ def update(self, index: int, new_value: int) -> None: Updates a value at a specific index in the segment tree. :param index: Index to update. :param new_value: New value to set. + + >>> tree = SegmentTree([1, 2, 3, 4, 5], mode="max") + >>> tree.update(2, 6) + >>> tree.max_in_range(1, 3) + 6 """ if index < 0 or index >= self.size: raise Exception("Invalid index") @@ -140,6 +161,11 @@ def modify( :param new_value: New value to assign. :param start: Start index of node's segment. :param end: End index of node's segment. + + >>> tree = SegmentTree([1, 2, 3, 4, 5], mode="max") + >>> tree.modify(tree.root, 2, 6, 0, 4) + >>> tree.max_in_range(0, 4) + 6 """ if start == end: node.value = new_value @@ -156,4 +182,5 @@ def modify( if self.mode == "max": node.value = max(node.left.value, node.right.value) else: - node.value = node.left.value + node.right.value \ No newline at end of file + node.value = node.left.value + node.right.value +