add python solutions for fast and slow pointers pattern

Author: ashishps1

python/find-the-duplicate-number.md

@@ -0,0 +1,171 @@
+
+# Find the Duplicate Number
+You are given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive. There is exactly one duplicate number in nums, return this duplicate number.
+
+You must solve the problem without modifying the array and use only constant extra space.
+
+### Constraints:
+- 1 <= n <= 10^5
+- nums.length == n + 1
+- 1 <= nums[i] <= n
+- All the integers in nums appear only once except for exactly one integer which appears twice.
+
+### Follow-up:
+- How can we prove that at least one duplicate number must exist?
+- Can you solve the problem in O(n) time and without modifying the array?
+
+### Examples
+```javascript
+Input: nums = [1,3,4,2,2]
+Output: 2
+
+Input: nums = [3,1,3,4,2]
+Output: 3
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Sort the Array (Not Optimal)
+##### Intuition:
+One of the simplest approaches is to sort the array. Once the array is sorted, the duplicate number will appear next to itself.
+
+1. Sort the array.
+2. Iterate through the sorted array, checking if any two consecutive elements are the same.
+##### Time Complexity:
+O(n log n), because sorting the array takes O(n log n).
+##### Space Complexity:
+O(1), if sorting is done in place, or O(n) if using additional memory for sorting.
+##### Python Code:
+```python
+def findDuplicate(nums):
+    nums.sort()  # Sort the array
+    
+    # Find the first pair of consecutive duplicate elements
+    for i in range(1, len(nums)):
+        if nums[i] == nums[i - 1]:
+            return nums[i]
+```
+### Approach 2: Hash Set to Track Seen Numbers
+##### Intuition: 
+We can use a hash set to keep track of numbers we have already encountered. As we iterate through the array, if a number is found in the set, it is the duplicate.
+
+1. Initialize an empty set.
+2. Traverse the array and check if the number is already in the set.
+3. If it is, return the duplicate number.
+##### Time Complexity:
+O(n), as we traverse the array once.
+##### Space Complexity:
+O(n), because we use a set to store the numbers we have seen.
+##### Python Code:
+```python
+def findDuplicate(nums):
+    seen = set()  # Set to track seen numbers
+    
+    for num in nums:
+        if num in seen:
+            return num  # Duplicate found
+        seen.add(num)
+```
+### Approach 3: Binary Search on the Value Range
+##### Intuition: 
+The key insight is that the array contains numbers in the range [1, n]. This allows us to apply binary search on the range of values instead of the array itself. For each mid-point of the range, count how many numbers in the array are less than or equal to mid. If this count exceeds mid, then the duplicate must be in the lower half. Otherwise, it must be in the upper half.
+
+1. Perform binary search on the range of numbers [1, n].
+2. For each mid value, count how many numbers in the array are less than or equal to mid.
+3. Based on the count, adjust the search range.
+##### Visualization:
+```rust
+For example, with nums = [1, 3, 4, 2, 2], we perform the following:
+
+- Initial range: 1 to 4 (n=4)
+- Mid = 2. Count of numbers <= 2 is 3 (1, 2, 2).
+  Since 3 > 2, the duplicate is in the lower half.
+- Narrow down the range to 1 to 2.
+- Mid = 1. Count of numbers <= 1 is 1.
+  The duplicate must be in the upper half.
+- Range becomes 2 to 2. Found duplicate = 2.
+```
+##### Time Complexity:
+O(n log n), because we perform binary search on the range and for each mid-point, we do a linear scan of the array.
+##### Space Complexity:
+O(1), since no extra space is used except for a few variables.
+##### Python Code:
+```python
+def findDuplicate(nums):
+    left, right = 1, len(nums) - 1
+    
+    while left < right:
+        mid = (left + right) // 2
+        count = sum(num <= mid for num in nums)
+        
+        if count > mid:
+            right = mid  # Duplicate is in the lower half
+        else:
+            left = mid + 1  # Duplicate is in the upper half
+    
+    return left  # The duplicate number
+```
+### Approach 4: Floyd’s Tortoise and Hare (Cycle Detection)
+##### Intuition: 
+This approach treats the problem as detecting a cycle in a linked list. Imagine the array as a linked list where each element points to another element in the array (the value at that index). The duplicate number creates a cycle. Using Floyd's Tortoise and Hare algorithm, we can detect this cycle.
+
+1. Initialize two pointers, slow and fast.
+2. Move slow one step at a time and fast two steps at a time.
+3. If a cycle exists, slow and fast will meet at some point.
+4. Reset one pointer to the start and move both pointers one step at a time until they meet again, which will be at the duplicate number.
+##### Why This Works:
+- The duplicate number creates a cycle because it points to a number already visited. The cycle detection method will find the duplicate as the entry point of the cycle.
+##### Visualization:
+```rust
+Array: [1, 3, 4, 2, 2]
+
+1 -> 3 -> 2 -> 4 -> 2 (cycle starts at 2)
+
+Step 1:
+- slow = 1, fast = 3
+
+Step 2:
+- slow = 3, fast = 4
+
+Step 3:
+- slow = 2, fast = 2 (they meet)
+
+Reset slow to the start, then move both pointers one step at a time:
+- slow = 1, fast = 2
+- slow = 3, fast = 2
+- slow = 2, fast = 2 (found duplicate = 2)
+```
+##### Time Complexity:
+O(n), as we traverse the array once.
+##### Space Complexity:
+O(1), since we only use constant extra space.
+##### Python Code:
+```python
+def findDuplicate(nums):
+    slow = nums[0]
+    fast = nums[0]
+    
+    # First phase: detect the cycle
+    while True:
+        slow = nums[slow]
+        fast = nums[nums[fast]]
+        if slow == fast:
+            break
+    
+    # Second phase: find the entrance to the cycle
+    slow = nums[0]
+    while slow != fast:
+        slow = nums[slow]
+        fast = nums[fast]
+    
+    return slow  # The duplicate number
+```
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Sort the Array                    | O(n log n)      | O(1)             |
+| Hash Set                          | O(n)            | O(n)             |
+| Binary Search on Value Range      | O(n log n)      | O(1)             |
+| Floyd’s Tortoise and Hare         | O(n)            | O(1)             |
+
+The Floyd’s Tortoise and Hare approach is the most optimal, providing O(n) time complexity and O(1) space complexity without modifying the array

python/happy-number.md

@@ -0,0 +1,146 @@
+
+# Happy Number
+Write an algorithm to determine if a number n is a "happy number."
+
+A happy number is defined by the following process:
+
+- Starting with any positive integer, replace the number by the sum of the squares of its digits.
+- Repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle that does not include 1.
+- Those numbers for which this process ends in 1 are happy numbers.
+
+### Constraints:
+1 <= n <= 2^31 - 1
+
+### Examples
+```javascript
+Input: n = 19
+Output: true
+Explanation: 
+1² + 9² = 82
+8² + 2² = 68
+6² + 8² = 100
+1² + 0² + 0² = 1
+
+Input: n = 2
+Output: false
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Hash Set to Track Seen Numbers
+##### Intuition:
+One way to detect a cycle is by keeping track of all numbers we've already seen. If we see the same number again, it means we are in a cycle, and the number is not happy. If the process eventually reaches 1, it is a happy number.
+
+1. Initialize an empty set to store previously seen numbers.
+2. Repeatedly compute the sum of the squares of the digits of the number.
+3. If the sum equals 1, return True.
+4. If the sum is already in the set, return False (indicating a cycle).
+5. Add the sum to the set and repeat.
+##### Time Complexity:
+O(log n), where n is the input number. We break down the number into digits and repeatedly compute their squares.
+##### Space Complexity:
+O(log n), since we store previously seen numbers in a set, which can grow based on the number of digits of n.
+##### Python Code:
+```python
+def isHappy(n: int) -> bool:
+    def sum_of_squares(num):
+        total = 0
+        while num:
+            digit = num % 10  # Extract the last digit
+            total += digit ** 2  # Add square of the digit to total
+            num //= 10  # Remove the last digit
+        return total
+
+    seen = set()  # Set to store numbers we have seen
+    
+    while n != 1 and n not in seen:
+        seen.add(n)  # Add current number to the seen set
+        n = sum_of_squares(n)  # Compute the sum of squares of digits
+    
+    return n == 1  # Return True if 1 is reached, else False
+```
+### Approach 2: Two Pointers (Floyd’s Cycle Detection Algorithm)
+##### Intuition: 
+A more efficient way to detect a cycle is by using two pointers—slow and fast. This is similar to Floyd's Cycle Detection algorithm (used for detecting cycles in linked lists). The slow pointer moves one step at a time (computing the sum of squares once), while the fast pointer moves two steps at a time. If there is a cycle, the two pointers will eventually meet. If the fast pointer reaches 1, then the number is happy.
+
+1. Initialize two pointers slow and fast at n.
+2. Move slow by one step (compute sum of squares once).
+3. Move fast by two steps (compute sum of squares twice).
+4. If slow and fast meet, there is a cycle (return False).
+5. If fast reaches 1, return True.
+##### Why This Works:
+- If a cycle exists, the slow and fast pointers will meet within the cycle. If the number is happy, the fast pointer will eventually reach 1.
+##### Time Complexity:
+O(log n), since the sum of the squares of digits is computed repeatedly.
+##### Space Complexity:
+O(1), since only a constant amount of space is used for the pointers.
+##### Visualization:
+```rust
+Example: n = 19
+
+Initial: slow = 19, fast = 19
+
+Step 1: slow = sum_of_squares(19) = 82
+        fast = sum_of_squares(sum_of_squares(19)) = sum_of_squares(82) = 68
+
+Step 2: slow = sum_of_squares(82) = 68
+        fast = sum_of_squares(sum_of_squares(68)) = sum_of_squares(100) = 1
+
+Since fast reached 1, the number is happy (return True).
+```
+##### Python Code:
+```python
+def isHappy(n: int) -> bool:
+    def sum_of_squares(num):
+        total = 0
+        while num:
+            digit = num % 10
+            total += digit ** 2
+            num //= 10
+        return total
+
+    slow = n
+    fast = sum_of_squares(n)
+    
+    while fast != 1 and slow != fast:
+        slow = sum_of_squares(slow)  # Slow pointer moves one step
+        fast = sum_of_squares(sum_of_squares(fast))  # Fast pointer moves two steps
+    
+    return fast == 1  # If fast reaches 1, it's a happy number
+```
+### Approach 3: Recursive Approach
+##### Intuition: 
+We can also implement the solution recursively. At each step, compute the sum of squares of the digits and recursively check if this number is happy. To detect cycles, we use a set to keep track of previously seen numbers.
+
+1. Create a recursive function to compute the sum of squares.
+2. If the current number is 1, return True.
+3. If the number is in the set, return False (cycle detected).
+4. Add the number to the set and continue the process.
+##### Time Complexity:
+O(log n), since the number is broken down into its digits recursively.
+##### Space Complexity:
+O(log n), because of the recursion depth and the set used to track seen numbers.
+##### Python Code:
+```python
+def isHappy(n: int, seen=None) -> bool:
+    if seen is None:
+        seen = set()  # Set to track seen numbers
+    
+    if n == 1:
+        return True  # Base case: if n is 1, it's a happy number
+    if n in seen:
+        return False  # If n is already seen, it's a cycle
+    
+    seen.add(n)  # Add current number to the seen set
+    sum_of_squares = sum(int(digit) ** 2 for digit in str(n))  # Compute sum of squares
+    
+    return isHappy(sum_of_squares, seen)  # Recurse with the new number
+```
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Hash Set (Tracking Seen Numbers)   | O(log n)            | O(log n)             |
+| Two Pointers (Floyd’s Algorithm)        | O(log n)            | O(1)             |
+| Recursive Approach	        | O(logn)            | O(log n)             |
+
+The Two Pointers (Floyd’s Algorithm) is the most optimal solution as it uses constant space and efficiently detects cycles.