updated

Author: Prakash-sa

README.md

@@ -143,6 +143,8 @@ Useful utility snippets:
 - Set kth bit: `num |= (1 << k)`.
 - Unset kth bit: `num &= ~(1 << k)`.
 - Toggle kth bit: `num ^= (1 << k)`.
+- Binary string to int: `int(s, 2)`.
+- Int to binary string: `bin(num)[2:]`.
 - Power of two check: `(num & (num - 1)) == 0` or `(num & -num) == num`.
 - Swap without temp: `a ^= b; b ^= a; a ^= b`.
 - Compare floating values with tolerance: `abs(x - y) <= 1e-7`.

Segment Trees/3721. Longest Balanced Subarray II.py

@@ -0,0 +1,165 @@
+# https://leetcode.com/problems/longest-balanced-subarray-ii/description/
+
+'''
+You are given an integer array nums.
+A subarray is called balanced if the number of distinct even numbers in the subarray is equal to the number of distinct odd numbers.
+Return the length of the longest balanced subarray.
+
+Example 1:
+Input: nums = [2,5,4,3]
+Output: 4
+Explanation:
+The longest balanced subarray is [2, 5, 4, 3].
+It has 2 distinct even numbers [2, 4] and 2 distinct odd numbers [5, 3]. Thus, the answer is 4.
+Example 2:
+Input: nums = [3,2,2,5,4]
+Output: 5
+Explanation:
+The longest balanced subarray is [3, 2, 2, 5, 4].
+It has 2 distinct even numbers [2, 4] and 2 distinct odd numbers [3, 5]. Thus, the answer is 5.
+Example 3:
+Input: nums = [1,2,3,2]
+Output: 3
+Explanation:
+
+The longest balanced subarray is [2, 3, 2].
+It has 1 distinct even number [2] and 1 distinct odd number [3]. Thus, the answer is 3.
+
+Constraints:
+1 <= nums.length <= 105
+1 <= nums[i] <= 105
+
+Prefix Sum + Segment Tree
+'''
+
+class LazyTag:
+    def __init__(self):
+        self.to_add=0
+    
+    def add(self,other):
+        self.to_add+=other.to_add
+        return self
+    
+    def has_tag(self):
+        return self.to_add!=0
+    
+    def clear(self):
+        self.to_add=0
+
+class SegmentTreeNode:
+    def __init__(self):
+        self.min_value=0
+        self.max_value=0
+        self.lazy_tag=LazyTag()
+
+
+class SegmentTree:
+    def __init__(self,data):
+        self.n=len(data)
+        self.tree=[SegmentTreeNode() for _ in range(self.n*4+1)]
+        self._build(data,1,self.n,1)
+    
+    def add(self,l,r,val):
+        tag=LazyTag()
+        tag.to_add=val
+        self._update(l,r,tag,1,self.n,1)
+    
+    def find_last(self,start,val):
+        if start>self.n:
+            return -1
+        return self._find(start,self.n,val,1,self.n,1)
+    
+    def _apply_tag(self,i,tag):
+        self.tree[i].min_value+=tag.to_add
+        self.tree[i].max_value+=tag.to_add
+        self.tree[i].lazy_tag.add(tag)
+    
+    def _pushdown(self,i):
+        if self.tree[i].lazy_tag.has_tag():
+            tag=LazyTag()
+            tag.to_add=self.tree[i].lazy_tag.to_add
+            self._apply_tag(i<<1,tag)
+            self._apply_tag((i<<1)|1,tag)
+            self.tree[i].lazy_tag.clear()
+    def _pushup(self,i):
+        self.tree[i].min_value=min(
+            self.tree[i<<1].min_value,self.tree[(i<<1)|1].min_value
+        )
+        self.tree[i].max_value=max(self.tree[i<<1].max_value,self.tree[(i<<1)|1].max_value)
+
+    def _build(self,data,l,r,i):
+        if l==r:
+            self.tree[i].min_value=data[l-1]
+            self.tree[i].max_value=data[l-1]
+            return
+        mid=l+((r-l)>>1)
+        self._build(data,l,mid,i<<1)
+        self._build(data,mid+1,r,(i<<1)|1)
+        self._pushup(i)
+    
+    def _update(self,target_l,target_r,tag,l,r,i):
+        if target_l<=l and r<=target_r:
+            self._apply_tag(i,tag)
+            return
+        self._pushdown(i)
+        mid=l+((r-l)>>1)
+        if target_l<=mid:
+            self._update(target_l,target_r,tag,l,mid,i<<1)
+        if target_r>mid:
+            self._update(target_l,target_r,tag,mid+1,r,(i<<1)|1)
+        self._pushup(i)
+
+    def _find(self,target_l,target_r,val,l,r,i):
+        if self.tree[i].min_value>val or self.tree[i].max_value<val:
+            return -1
+        if l==r:
+            return l
+        self._pushdown(i)
+        mid=l+((r-l)>>1)
+        if target_r>=mid+1:
+            res=self._find(target_l,target_r,val,mid+1,r,(i<<1)|1)
+            if res!=-1:
+                return res
+        if l<=target_r and mid>=target_l:
+            return self._find(target_l,target_r,val,l,mid,i<<1)
+        return -1
+
+
+class Solution:
+    def longestBalanced(self, nums: List[int]) -> int:
+        occurrences=defaultdict(deque)
+
+        def sgn(x):
+            return 1 if x%2==0 else -1
+        
+        length=0
+        prefix_sum=[0]*len(nums)
+        prefix_sum[0]=sgn(nums[0])
+        occurrences[nums[0]].append(1)
+
+        for i in range(1,len(nums)):
+            prefix_sum[i]=prefix_sum[i-1]
+            occ=occurrences[nums[i]]
+            if not occ:
+                prefix_sum[i]+=sgn(nums[i])
+            occ.append(i+1)
+        
+        seg=SegmentTree(prefix_sum)
+        for i in range(len(nums)):
+            length=max(length,seg.find_last(i+length,0)-i)
+            next_pos=len(nums)+1
+            occurrences[nums[i]].popleft()
+            if occurrences[nums[i]]:
+                next_pos=occurrences[nums[i]][0]
+            seg.add(i+1,next_pos-1,-sgn(nums[i]))
+        return length
+    
+
+
+# Complexity Analysis
+# Let n be the length of nums.
+# Time complexity: O(nlogn).
+# Computing prefix sums and maintaining element positions require O(nlogn). Building the segment tree takes O(nlogn). Each iteration performs a constant number of segment tree operations and map accesses, each taking O(logn). Therefore, the total time complexity is O(nlogn).
+
+# Time complexity: O(n).
+# The segment tree, prefix sum array, and auxiliary data structures together require O(n) space.

Sorting/1200. Minimum Absolute Difference.py

@@ -0,0 +1,89 @@
+# https://leetcode.com/problems/minimum-absolute-difference/description/
+
+'''
+Given an array of distinct integers arr, find all pairs of elements with the minimum absolute difference of any two elements.
+Return a list of pairs in ascending order(with respect to pairs), each pair [a, b] follows
+a, b are from arr
+a < b
+b - a equals to the minimum absolute difference of any two elements in arr
+
+Example 1:
+Input: arr = [4,2,1,3]
+Output: [[1,2],[2,3],[3,4]]
+Explanation: The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.
+Example 2:
+Input: arr = [1,3,6,10,15]
+Output: [[1,3]]
+Example 3:
+Input: arr = [3,8,-10,23,19,-4,-14,27]
+Output: [[-14,-10],[19,23],[23,27]]
+
+Constraints:
+2 <= arr.length <= 105
+-106 <= arr[i] <= 106
+'''
+
+
+class Solution:
+    def minimumAbsDifference(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+
+        min_difference=math.inf
+        ans=[]
+
+        for i in range(len(nums)-1):
+            diff=abs(nums[i+1]-nums[i])
+            if diff<min_difference:
+                min_difference=diff
+                ans=[[nums[i],nums[i+1]]]
+            elif diff==min_difference:
+                ans.append([nums[i],nums[i+1]])
+        return ans
+
+# Complexity Analysis
+
+# Let n be the length of the array arr.
+# Time complexity: O(n⋅log(n))
+# First, we sort arr using comparision sorting, which takes O(n⋅log(n)).
+# We then traverse the array, which takes O(n) time.
+# To sum up, the overall time complexity is O(n⋅log(n)).
+
+# Space complexity: O(n).
+
+
+# Counting Sort
+class Solution:
+    def minimumAbsDifference(self, nums: List[int]) -> List[List[int]]:
+        min_element=min(nums)
+        max_element=max(nums)
+        shift=-min_element
+        line=[0]*(max_element-min_element+1)
+        min_diff=max_element-min_element
+        prev=0
+        ans=[]
+
+        for num in nums:
+            line[num+shift]=1
+
+        for curr in range(1,max_element+shift+1):
+            if line[curr]==0:
+                continue
+            current_diff=curr-prev
+            if current_diff<min_diff:
+                min_diff=current_diff
+                ans=[[prev-shift,curr-shift]]
+            elif current_diff==min_diff:
+                ans.append([prev-shift,curr-shift])
+            prev=curr
+        return ans 
+
+# Complexity Analysis
+
+# Let n be the size of the input array arr, and m be the range of values in arr.
+# Time complexity: O(m+n)
+# We initialize an auxiliary array of all zeros, which takes O(m) time.
+
+
+# Space complexity: O(m+n)
+# We used an auxiliary array line of size O(m).
+

System Design/362. Design Hit Counter.py

@@ -0,0 +1,98 @@
+# https://leetcode.com/problems/design-hit-counter/description/
+
+'''
+Design a hit counter which counts the number of hits received in the past 5 minutes (i.e., the past 300 seconds).
+Your system should accept a timestamp parameter (in seconds granularity), and you may assume that calls are being made to the system in chronological order (i.e., timestamp is monotonically increasing). Several hits may arrive roughly at the same time.
+Implement the HitCounter class:
+HitCounter() Initializes the object of the hit counter system.
+void hit(int timestamp) Records a hit that happened at timestamp (in seconds). Several hits may happen at the same timestamp.
+int getHits(int timestamp) Returns the number of hits in the past 5 minutes from timestamp (i.e., the past 300 seconds).
+
+Example 1:
+Input
+["HitCounter", "hit", "hit", "hit", "getHits", "hit", "getHits", "getHits"]
+[[], [1], [2], [3], [4], [300], [300], [301]]
+Output
+[null, null, null, null, 3, null, 4, 3]
+
+Explanation
+HitCounter hitCounter = new HitCounter();
+hitCounter.hit(1);       // hit at timestamp 1.
+hitCounter.hit(2);       // hit at timestamp 2.
+hitCounter.hit(3);       // hit at timestamp 3.
+hitCounter.getHits(4);   // get hits at timestamp 4, return 3.
+hitCounter.hit(300);     // hit at timestamp 300.
+hitCounter.getHits(300); // get hits at timestamp 300, return 4.
+hitCounter.getHits(301); // get hits at timestamp 301, return 3.
+
+Constraints:
+1 <= timestamp <= 2 * 109
+All the calls are being made to the system in chronological order (i.e., timestamp is monotonically increasing).
+At most 300 calls will be made to hit and getHits.
+ 
+Follow up: What if the number of hits per second could be huge? Does your design scale?
+'''
+
+
+
+class HitCounter:
+
+    def __init__(self):
+        self.timestamp_hits=deque()
+
+    def hit(self, timestamp: int) -> None:
+        self.timestamp_hits.append(timestamp)
+
+
+    def getHits(self, timestamp: int) -> int:
+        while self.timestamp_hits and self.timestamp_hits[0]<=timestamp-300:
+            self.timestamp_hits.popleft()
+        return len(self.timestamp_hits)
+
+# with bounded memory, amortized O(1) operations, and precise window semantics:
+
+
+# Space Efficiency:
+# Deque size ≤ hits in last 300 seconds → O(1) bounded space (e.g., max 300 hits if 1/sec)
+# Time Efficiency:
+# Each hit is added once and removed once → amortized O(1) per operation
+# Correctness:
+# Window = (timestamp - 300, timestamp] → hits at timestamp-300 are expired (excluded), so condition <= timestamp-300 is precise
+# Handles Duplicates:
+# Multiple hits at same timestamp? All expired together when window passes
+
+# Scenario	Steps	Result	Why Correct
+# Duplicate timestamps
+# hit(1)×3	getHits(300) → keeps all (1 > 0)
+# getHits(301) → removes all (1 ≤ 1)	3 → 0	Window = (timestamp-300, timestamp]
+# At 301: (1, 301] excludes timestamp=1
+# Boundary precision
+# hit(1), hit(300), hit(301)	getHits(301):
+# - Remove 1 (1 ≤ 1)
+# - Keep 300, 301	2	Window (1, 301] includes 300/301 ✅
+# Excludes 1 ✅
+# Burst traffic
+# 10,000 hits @ t=1	getHits(301):
+# - Pops all 10k hits in one pass
+# - Deque becomes empty	0	Memory freed immediately ✅
+# No leak even after massive burst
+# Stale hits + new hits
+# hit(1), hit(2), hit(400)	getHits(400):
+# - Remove 1,2 (≤100)
+# - Keep 400	1	Only hits in (100, 400] counted ✅
+# Back-to-back queries
+# hit(1), getHits(100), getHits(400)	First call: keeps 1 (1 > -200)
+# Second call: removes 1 (1 ≤ 100)	1 → 0	State persists correctly between calls ✅
+# No hits	getHits(100)	0	Empty deque handled safely ✅
+# 💡 Why This Scales
+# Metric	Behavior	Real-World Impact
+# Memory	Bounded by hits in last 300s	Handles 1M hits/sec → deque holds ≤ 300M entries (manageable)
+# Time per getHits	Amortized O(1)	Each hit pushed/popped once → total work = O(total hits)
+# Timestamp order	Relies on strictly increasing timestamps (per problem)	No sorting needed → optimal for streaming data
+# Window semantics	(timestamp-300, timestamp]	Matches problem spec: hits at timestamp-300 are excluded
+# 🌐 Real-World Context
+# This is the exact pattern used in:
+
+# Rate limiters (API gateways)
+# Sliding window analytics (Redis ZREMRANGEBYSCORE)
+# Network traffic monitors