Merge branch 'master' into feature/search-insert-position

Author: AbdulWahab938

Arrays & Strings/#169 - Majority Element - Easy/Explanation.md

@@ -0,0 +1,126 @@
+# 169. Majority Element
+
+**Difficulty:** *Easy*  
+**Category:** *Arrays, Hash Table, Divide and Conquer*  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/majority-element/)
+
+---
+
+## 📝 Introduction
+
+*Given an array nums of size n, return the majority element — the element that appears more than ⌊n / 2⌋ times.*
+
+*Constraints typically include:<br>
+- It is guaranteed that the majority element always exists in the array.*
+
+---
+
+## 💡 Approach & Key Insights
+
+*The problem centers on identifying an element that occurs more than n/2 times. Three approaches are commonly used:<br>
+- Brute-force with nested loops.<br>
+- Better approach using hash map frequency counting.<br>
+- Optimal approach using Moore’s Voting Algorithm for O(n) time and O(1) space.*
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:** *For each element, count its frequency using a nested loop. If any element occurs more than ⌊n/2⌋ times, return it.*
+- **Time Complexity:** O(n²) – due to nested iterations.
+- **Space Complexity:** O(1)
+- **Example/Dry Run:**
+
+```plaintext
+Input: [3, 2, 3]
+Step 1: Check 3 → appears 2 times → not > 1.5
+Step 2: Check 2 → appears 1 time → not > 1.5
+Return 3
+```
+
+---
+
+### 2️⃣ Better Approach
+
+- **Explanation:** *Use a hash map to store frequencies of each number. As you update counts, if any value exceeds ⌊n/2⌋, return it.*
+- **Time Complexity:** O(n) – single pass to count.
+- **Space Complexity:** O(n) – for storing frequencies.
+- **Example/Dry Run:**
+
+```plaintext
+Input: [2, 2, 1, 1, 1, 2, 2]
+Count Map:
+{2: 1}
+{2: 2}
+{2: 2, 1: 1}
+...
+{2: 4, 1: 3}
+Check: 4 > floor(7/2) = 3 → return 2
+```
+
+---
+
+### 3️⃣ Optimal Approach
+
+- **Explanation:** *Use Moore’s Voting Algorithm. Keep a count and a candidate. If count is zero, pick a new candidate. If current number equals candidate, increment count. Else decrement. At the end, the candidate is the majority element.*
+- **Time Complexity:** O(n) – single pass.
+- **Space Complexity:** O(1) – constant space.
+- **Example/Dry Run:**
+
+```plaintext
+Input: [2, 2, 1, 1, 1, 2, 2]
+Step-by-step:
+candidate = 2, count = 1
+2 == 2 → count = 2
+1 != 2 → count = 1
+1 != 2 → count = 0 → candidate = 1, count = 1
+1 == 1 → count = 2
+2 != 1 → count = 1
+2 != 1 → count = 0 → candidate = 2, count = 1
+Final candidate = 2 → return 2
+```
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach             | Time Complexity | Space Complexity |
+| -------------------- | --------------- | ---------------- |
+| Brute Force          | O(n²)           | O(1)             |
+| Hash Map Counting    | O(n)            | O(n)             |
+| Moore’s Voting Algo  | O(n)            | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+*The Moore’s Voting Algorithm is already optimal, with a single pass and constant space. If the array does not guarantee a majority element, a second pass is needed to verify the candidate.*
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+```plaintext
+Example: [3, 3, 4, 2, 4, 4, 2, 4, 4]
+Step-by-step:
+candidate = 3, count = 1
+3 == 3 → count = 2
+4 != 3 → count = 1
+2 != 3 → count = 0 → candidate = 2
+...
+Final candidate = 4 → verify by count = 5
+n = 9 → ⌊9/2⌋ = 4 → 5 > 4 → return 4
+```
+
+---
+
+## 🔗 Additional Resources
+
+- [Moore's Voting Algorithm - GeeksforGeeks](https://www.geeksforgeeks.org/theory-of-computation/boyer-moore-majority-voting-algorithm/)
+
+---
+
+Author: Neha Amin <br>
+Date: 19/07/2025

Arrays & Strings/#169 - Majority Element - Easy/majorityElement.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int majorityElement(vector<int>& nums) {
+        int n = nums.size();
+        int cnt = 0;
+        int el;
+
+        // Boyer-Moore Voting Algorithm
+        for (int i = 0; i < n; i++) {
+            if (cnt == 0) {
+                cnt = 1;
+                el = nums[i];
+            } else if (nums[i] == el) {
+                cnt++;
+            } else {
+                cnt--;
+            }
+        }
+
+        // Optional: Verify if the candidate is actually the majority
+        int cnt1 = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] == el)
+                cnt1++;
+        }
+        if (cnt1 > n / 2)
+            return el;
+        return -1;
+    }
+};

Arrays & Strings/#169 - Majority Element - Easy/majorityElement.py

@@ -0,0 +1,24 @@
+class Solution:
+    def majorityElement(self, nums: List[int]) -> int:
+        n = len(nums)
+        cnt = 0
+        el = None
+
+        # Boyer-Moore Voting Algorithm
+        for i in range(n):
+            if cnt == 0:
+                cnt = 1
+                el = nums[i]
+            elif nums[i] == el:
+                cnt += 1
+            else:
+                cnt -= 1
+
+        # Optional: Verify if el is actually the majority element.
+        cnt1 = 0
+        for i in range(n):
+            if nums[i] == el:
+                cnt1 += 1
+        if cnt1 > n // 2:
+            return el
+        return -1

Arrays & Strings/#31 - Next Permutation - Medium/Explanation.md

@@ -0,0 +1,126 @@
+# 31. Next Permutation
+
+**Difficulty:** *Medium*  
+**Category:** *Arrays, Permutations, Greedy*  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/next-permutation/)
+
+---
+
+## 📝 Introduction
+
+*Given an array Arr[] of integers, rearrange the numbers into the lexicographically next greater permutation of numbers.  
+If such an arrangement is not possible, rearrange it to the lowest possible order (i.e., sorted in ascending order).*
+
+*Constraints typically include:<br>
+- All integers may be distinct or contain duplicates.<br>
+- The transformation must be done in-place with only constant extra memory.*
+
+---
+
+## 💡 Approach & Key Insights
+
+*There are three main approaches to solve this problem:<br>
+- Brute Force: Generate all permutations and pick the next.<br>
+- In-Built Function: Use next_permutation() if language provides it.<br>
+- Optimal: Use the standard algorithm to compute the next permutation by identifying a break point, swapping, and reversing.*
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:** *Generate all permutations of the array, sort them, and locate the input permutation. Return the next one in sequence. If not found or if it's the last permutation, return the first (sorted array).*
+- **Time Complexity:** *O(N! × N) – N! permutations each of length N.*
+- **Space Complexity:** *O(1) – ignoring recursion stack used for generating permutations.*
+- **Example/Dry Run:**
+
+```plaintext
+Input: [1, 2, 3]
+All permutations: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]
+Current permutation: [1,2,3]
+Next permutation: [1,3,2]
+```
+
+### 2️⃣ Language Built-in (C++ std::next_permutation)
+
+- **Explanation:** *C++ provides next_permutation() which directly modifies the array to the next permutation.*
+- **Time Complexity:** *O(N) – internally optimized.*
+- **Space Complexity:** *O(1).*
+- **Example:**
+
+```cpp
+std::vector<int> nums = {1, 2, 3};
+std::next_permutation(nums.begin(), nums.end());
+// nums is now [1, 3, 2]
+```
+
+### 3️⃣ Optimal Approach
+
+- **Explanation:**  
+  1. Find the break-point: The first index i from the back where arr[i] < arr[i+1].  
+  2. If no such index exists, reverse the whole array (it was the last permutation).  
+  3. Else, find the smallest number greater than arr[i] from the right half, swap it with arr[i].  
+  4. Reverse the subarray from i+1 to end.
+
+- **Time Complexity:** *O(3N) = O(N) – each of the three steps (finding break-point, finding next greater, reversing) takes O(N).*
+- **Space Complexity:** *O(1) – all operations are done in-place.*
+- **Example/Dry Run:**
+
+```plaintext
+Input: [1, 2, 3]
+
+Step 1: Find break-point: 2 < 3 at index 1 → i = 1  
+Step 2: Find element just greater than arr[i]: 3 at index 2  
+Step 3: Swap 2 and 3 → [1, 3, 2]  
+Step 4: Reverse from i+1 = 2 to end → Already sorted
+
+Output: [1, 3, 2]
+```
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach       | Time Complexity   | Space Complexity |
+| -------------- | ----------------- | ---------------- |
+| Brute Force    | O(N! × N)         | O(1)             |
+| In-Built       | O(N)              | O(1)             |
+| Optimal        | O(N)              | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+*The optimal solution is already efficient for all constraints.  
+You may consider early exits in case the array is already in decreasing order to avoid redundant operations.*
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+```plaintext
+Example 1:
+Input: [1, 3, 2]
+Break-point: index 0 (1 < 3)
+Swap with next greater: swap 1 and 2 → [2, 3, 1]
+Reverse after index 0 → [2, 1, 3]
+Output: [2, 1, 3]
+
+Example 2:
+Input: [3, 2, 1]
+Break-point: None (fully decreasing)
+Reverse entire array → [1, 2, 3]
+Output: [1, 2, 3]
+```
+
+---
+
+## 🔗 Additional Resources
+
+- [C++ next_permutation documentation](https://en.cppreference.com/w/cpp/algorithm/next_permutation)
+
+---
+
+Author: Neha Amin <br>
+Date: 19/07/2025

Arrays & Strings/#31 - Next Permutation - Medium/nextPermutation.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    void nextPermutation(vector<int>& nums) {
+        int n = nums.size();
+        int ind = -1;
+        // Step 1: Find the break point
+        for (int i = n - 2; i >= 0; i--) {
+            if (nums[i] < nums[i + 1]) {
+                ind = i;
+                break;
+            }
+        }
+        // If break point does not exist, reverse the whole array
+        if (ind == -1) {
+            reverse(nums.begin(), nums.end());
+            return;
+        }
+        // Step 2: Find element just greater than nums[ind] and swap
+        for (int i = n - 1; i > ind; i--) {
+            if (nums[i] > nums[ind]) {
+                swap(nums[i], nums[ind]);
+                break;
+            }
+        }
+        // Step 3: Reverse the right half
+        reverse(nums.begin() + ind + 1, nums.end());
+    }
+};

Arrays & Strings/#31 - Next Permutation - Medium/nextPermutation.py

@@ -0,0 +1,23 @@
+class Solution:
+    def nextPermutation(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        n = len(nums)
+        ind = -1
+        # Step 1: Find the break point
+        for i in range(n-2, -1, -1):
+            if nums[i] < nums[i + 1]:
+                ind = i
+                break
+        # If break point does not exist, reverse the whole array
+        if ind == -1:
+            nums.reverse()
+            return
+        # Step 2: Find the next greater element and swap
+        for i in range(n - 1, ind, -1):
+            if nums[i] > nums[ind]:
+                nums[i], nums[ind] = nums[ind], nums[i]
+                break
+        # Step 3: Reverse the right half
+        nums[ind+1:] = reversed(nums[ind+1:])