add python solutions for binary search variants pattern

Author: ashishps1

python/find-peak-element.md

@@ -0,0 +1,96 @@
+# Find Peak Element
+A peak element is an element that is strictly greater than its neighbors.
+
+Given an integer array nums, find a peak element, and return its index. If the array contains multiple peaks, return the index to any of the peaks.
+
+You may imagine that nums[-1] = -∞ and nums[n] = -∞ (i.e., the boundary elements are considered lower than all elements).
+
+You must write an algorithm that runs in O(log n) time.
+### Constraints:
+- 1 <= nums.length <= 1000
+- -2^31 <= nums[i] <= 2^31 - 1
+- nums[i] != nums[i + 1] for all valid i.
+
+### Examples
+```javascript
+Input: nums = [1,2,3,1]
+Output: 2
+Explanation: 3 is a peak element and its index is 2.
+
+Input: nums = [1,2,1,3,5,6,4]
+Output: 5
+Explanation: Your function can return index 5 (the element 6 is a peak) or index 1 (the element 2 is a peak).
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Linear Search (Brute Force)
+##### Intuition:
+A simple approach is to traverse the array linearly and check for each element if it is greater than both of its neighbors. If such an element is found, return its index.
+
+Steps:
+1. Iterate through the array from 0 to n - 1.
+2. For each element nums[i], check if it is greater than both nums[i-1] and nums[i+1] (handling boundary cases where i == 0 or i == n - 1).
+3. If an element satisfies this condition, return the index i.
+##### Time Complexity:
+O(n), where n is the length of the array. In the worst case, we may need to scan the entire array.
+##### Space Complexity:
+O(1), because we only use a few variables to track indices and comparisons.
+##### Python Code:
+```python
+def findPeakElement(nums):
+    for i in range(len(nums)):
+        if (i == 0 or nums[i] > nums[i - 1]) and (i == len(nums) - 1 or nums[i] > nums[i + 1]):
+            return i
+```
+### Approach 2: Binary Search (Optimal Solution)
+##### Intuition: 
+We can use binary search to find a peak element efficiently in O(log n) time. The key observation is that if nums[mid] is greater than nums[mid + 1], then the peak must lie on the left side (including mid), and if nums[mid] is less than nums[mid + 1], then the peak must lie on the right side (excluding mid).
+
+The reason behind this is that if the middle element is smaller than its neighbor, there must be a peak on the side with the larger neighbor, because eventually the array must "fall" to the boundaries where we consider the elements as -∞.
+
+Steps:
+1. Initialize two pointers left = 0 and right = len(nums) - 1.
+2. While left < right:
+   - Calculate the midpoint: mid = (left + right) // 2.
+   - If nums[mid] > nums[mid + 1], it means the peak is in the left half (including mid), so move the right pointer to mid.
+   - If nums[mid] < nums[mid + 1], it means the peak is in the right half (excluding mid), so move the left pointer to mid + 1.
+3. Once left == right, return left (or right), which points to a peak element.
+##### Visualization:
+For nums = [1, 2, 1, 3, 5, 6, 4]:
+
+```perl
+Initial: left = 0, right = 6
+Iteration 1: mid = 3 → nums[mid] = 3, nums[mid + 1] = 5 → move left to mid + 1
+Iteration 2: mid = 5 → nums[mid] = 6, nums[mid + 1] = 4 → move right to mid
+Final result: left = 5, right = 5 → peak is at index 5 with value 6
+```
+##### Time Complexity:
+O(log n), where n is the length of the array. We reduce the search space by half with each iteration.
+##### Space Complexity:
+O(1), because we only use a few variables for the binary search process.
+##### Python Code:
+```python
+def findPeakElement(nums):
+    left, right = 0, len(nums) - 1
+    
+    while left < right:
+        mid = (left + right) // 2
+        if nums[mid] > nums[mid + 1]:
+            right = mid
+        else:
+            left = mid + 1
+    
+    return left  # or return right, both will point to the peak
+```
+### Edge Cases:
+1. Single Element: If the array has only one element, that element is trivially the peak.
+2. Two Elements: If the array has two elements, the peak is the larger of the two.
+3. All Increasing or Decreasing: If the array is strictly increasing, the last element is the peak. If the array is strictly decreasing, the first element is the peak.
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                    | O(n)      | O(1)             |
+| Binary Search with Pivot Handling	                          | 	O(log n)            | O(1)             |
+
+The Binary Search approach is the most efficient solution, achieving O(log n) time complexity while using constant space. This solution takes advantage of the properties of the array and uses binary search logic to efficiently find a peak.

python/koko-eating-bananas.md

@@ -0,0 +1,107 @@
+# Koko Eating Bananas
+Koko loves to eat bananas. There are n piles of bananas, and the i-th pile has piles[i] bananas. The guards have gone, and Koko has h hours to eat all the bananas. Each hour, she chooses a pile of bananas and eats k bananas from that pile. If the pile has fewer than k bananas, she eats all of them instead, and there will be no bananas left in that pile for the next hour.
+
+Return the minimum integer k such that Koko can eat all the bananas within h hours.
+### Constraints:
+- 1 <= piles.length <= 10^4
+- piles.length <= h <= 10^9
+- 1 <= piles[i] <= 10^9
+
+### Examples
+```javascript
+Input: piles = [3,6,7,11], h = 8
+Output: 4
+
+Input: piles = [30,11,23,4,20], h = 5
+Output: 30
+
+Input: piles = [30,11,23,4,20], h = 6
+Output: 23
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Inefficient)
+##### Intuition:
+In a brute-force approach, we can iterate over all possible eating speeds k from 1 to the maximum number of bananas in the largest pile, checking for each speed if Koko can eat all the bananas in h hours. However, this approach is inefficient because it involves checking many values of k and can lead to a time complexity of O(n * max(piles)), where n is the number of piles.
+
+Steps:
+1. Iterate through possible values of k starting from 1.
+2. For each k, simulate the process to see if Koko can finish eating all piles within h hours.
+3. Return the smallest k that satisfies the condition.
+##### Time Complexity:
+O(n * max(piles)), where n is the number of piles and max(piles) is the largest pile size.
+##### Space Complexity:
+O(1), because we only use a few variables to track the possible values of k and time.
+##### Python Code:
+```python
+def can_eat_in_time(piles, h, k):
+    hours = 0
+    for pile in piles:
+        hours += (pile + k - 1) // k  # Equivalent to ceil(pile / k)
+    return hours <= h
+
+def minEatingSpeed(piles, h):
+    for k in range(1, max(piles) + 1):
+        if can_eat_in_time(piles, h, k):
+            return k
+```
+### Approach 2: Binary Search on Eating Speed (Optimal Solution)
+##### Intuition: 
+We can use binary search to efficiently find the minimum possible eating speed k. The possible values for k range from 1 to the largest pile size in piles. The idea is to apply binary search over this range to minimize k while ensuring that Koko can finish all bananas within h hours.
+
+- Lower bound (low): The smallest possible speed is 1 banana per hour.
+- Upper bound (high): The maximum possible speed is the size of the largest pile (max(piles)), since Koko can finish the largest pile in one hour at this speed.
+
+Steps:
+1. Initialize low = 1 and high = max(piles).
+2. Perform binary search:
+   - Calculate the middle point mid = (low + high) // 2.
+   - Check if Koko can finish all the bananas at speed mid using the helper function can_eat_in_time(piles, h, mid).
+   - If she can finish, update high = mid to try smaller values.
+   - If she cannot finish, update low = mid + 1 to increase the eating speed.
+3. The binary search will converge, and low will be the minimum speed k.
+##### Time Complexity:
+O(n log max(piles)), where n is the number of piles, and log max(piles) comes from the binary search.
+##### Space Complexity:
+O(1), because we only use a few variables for binary search and time calculations.
+##### Python Code:
+```python
+def can_eat_in_time(piles, h, k):
+    hours = 0
+    for pile in piles:
+        hours += (pile + k - 1) // k  # Equivalent to ceil(pile / k)
+    return hours <= h
+
+def minEatingSpeed(piles, h):
+    # Binary search on the possible values of k
+    low, high = 1, max(piles)
+    
+    while low < high:
+        mid = (low + high) // 2
+        if can_eat_in_time(piles, h, mid):
+            high = mid  # Try for smaller k
+        else:
+            low = mid + 1  # Increase k
+    
+    return low
+```
+### Explanation of Code:
+- Binary Search:
+The binary search starts with a range of possible eating speeds from 1 to max(piles). We progressively narrow down this range by checking the midpoint (mid) using the can_eat_in_time function, which simulates the process of eating bananas at speed mid.
+
+- Helper Function can_eat_in_time(piles, h, k):
+This function calculates how many hours it would take Koko to finish eating all the piles if she eats k bananas per hour. For each pile, the time taken is ceil(pile / k), which is computed as (pile + k - 1) // k (this avoids using floating-point division).
+
+- Binary Search Condition:
+If Koko can finish eating all bananas at speed mid, we reduce the search space to find a potentially smaller value of k. Otherwise, we increase the speed and continue searching.
+### Edge Cases:
+1. Single Pile: If there is only one pile, the eating speed is equal to the size of the pile if h == 1. Otherwise, it will depend on how many hours Koko has.
+2. Many Small Piles, Few Hours: When there are many small piles but few hours, the binary search should quickly find the largest k needed to eat all piles in the limited time.
+3. Large Pile, Many Hours: If there's a very large pile and many hours, Koko can eat slowly, so the binary search should return a small k.
+## Summary
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                    | O(n * max(piles))      | O(1)             |
+| Binary Search (Optimal)	     | 	O(n log max(piles))            | O(1)             |
+
+The Binary Search approach is the most efficient, reducing the time complexity to O(n log max(piles)) while using constant space.

python/random-pick-with-weight.md

@@ -0,0 +1,128 @@
+# Random Pick with Weight
+You are given an array of positive integers w where w[i] describes the weight of index i (0-indexed). You need to implement the function pickIndex(), which randomly picks an index in proportion to its weight.
+
+- pickIndex() should return an index such that the probability of picking index i is w[i] / sum(w).
+### Constraints:
+- 1 <= w.length <= 10^4
+- 1 <= w[i] <= 10^5
+- pickIndex will be called at most 10^5 times.
+
+### Examples
+```javascript
+Input:
+["Solution","pickIndex"]
+[[[1]],[]]
+
+Output:
+[null,0]
+
+Explanation:
+Solution solution = new Solution([1]);
+solution.pickIndex(); // return 0
+Since there is only one element, the function should always return 0.
+
+
+Input:
+["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
+[[[1,3]],[],[],[],[],[]]
+
+Output:
+[null,1,1,1,1,0]
+
+Explanation:
+Solution solution = new Solution([1,3]);
+solution.pickIndex(); // return 1 with probability 3/4, and return 0 with probability 1/4.
+The picks are made randomly, so this output is just an example.
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Inefficient)
+##### Intuition:
+The simplest solution is to map each index i to a number of occurrences proportional to its weight w[i]. Then, randomly select an index from this expanded array. This is very inefficient in terms of both space and time, especially for large weights.
+
+Steps:
+1. Create a list where each index i appears w[i] times.
+2. Randomly pick an index from this expanded list.
+##### Time Complexity:
+O(n * w_max), where n is the length of the input array and w_max is the maximum weight value. This is very inefficient for large arrays or large weights.
+##### Space Complexity:
+O(n * w_max), because we need to store the expanded list.
+##### Python Code:
+```python
+import random
+
+class Solution:
+    def __init__(self, w):
+        self.weights = []
+        for i in range(len(w)):
+            self.weights += [i] * w[i]
+    
+    def pickIndex(self):
+        return random.choice(self.weights)
+```
+### Approach 2: Prefix Sum + Binary Search (Optimal Solution)
+##### Intuition: 
+A more efficient solution involves using the prefix sum of the weights to create a cumulative sum array. The idea is to transform the weights into a continuous probability distribution, where each weight occupies a segment proportional to its size.
+
+- Construct a prefix sum array where each element at index i represents the cumulative weight up to that index.
+- Use binary search to efficiently find which segment of the cumulative sum a randomly generated number falls into.
+
+Steps:
+1. Precompute the prefix sum of the weights.
+   - Create a cumulative sum array where prefix_sum[i] = w[0] + w[1] + ... + w[i].
+   - This transforms the weights into a continuous range.
+2. Generate a random number r between 0 and total_sum (where total_sum is the sum of all weights).
+3. Use binary search to find the first index i such that prefix_sum[i] >= r.
+4. Return the index i.
+##### Visualization:
+```perl
+For w = [1, 3], the prefix sum array will be [1, 4], meaning:
+
+Index 0 has a range of [0, 1) (probability 1/4).
+Index 1 has a range of [1, 4) (probability 3/4).
+```
+##### Time Complexity:
+- O(n) for the precomputation step (building the prefix sum array).
+- O(log n) for each call to pickIndex() because of the binary search.
+##### Space Complexity:
+- O(n), where n is the length of the input array, for storing the prefix sum array.
+##### Python Code:
+```python
+import random
+import bisect
+
+class Solution:
+    def __init__(self, w):
+        self.prefix_sums = []
+        prefix_sum = 0
+        
+        for weight in w:
+            prefix_sum += weight
+            self.prefix_sums.append(prefix_sum)
+        
+        self.total_sum = prefix_sum
+    
+    def pickIndex(self):
+        # Generate a random number in the range [1, total_sum]
+        target = random.randint(1, self.total_sum)
+        
+        # Binary search to find the index where the random number fits
+        return bisect.bisect_left(self.prefix_sums, target)
+```
+### Explanation of Code:
+- Precomputation (Constructor):
+The constructor builds the prefix_sums array and calculates the total sum of weights. This preprocessing is done in O(n) time.
+
+- pickIndex() Function:
+In the pickIndex() function, a random integer between 1 and total_sum is generated, representing a point in the cumulative probability distribution. Then, bisect.bisect_left is used to perform binary search on the prefix_sums array to efficiently find the index corresponding to this point. This is done in O(log n) time.
+### Edge Cases:
+1. Single Weight: If the input array has only one element, pickIndex() should always return 0 because there's only one possible index.
+2. Large Weights: The solution efficiently handles large weights using the prefix sum approach without expanding the list.
+3. Small Weights: Even with small weights, the solution scales well because the binary search operates on the prefix sums rather than on the original weights.
+## Summary
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                    | O(n * w_max)      | O(n * w_max)             |
+| Prefix Sum + Binary Search (Optimal)	                          | 	O(n) for preprocessing, O(log n) for each pick            | O(n)             |
+
+The Prefix Sum + Binary Search approach is the most efficient solution. It achieves O(n) time for preprocessing and O(log n) time for each call to pickIndex().