Merge branch 'CodeHarborHub:main' into patch-1

Author: vivekvardhan2810

dsa-problems/gfg-problems/medium/0401-0500.md

@@ -0,0 +1,122 @@
+---
+id: Counting-Sort
+title: Counting Sort (Geeks for Geeks)
+sidebar_label: Counting Sort
+tags:
+  - Beginner
+  - Sorting Algorithms
+  - Geeks for Geeks
+  - CPP
+  - Python
+  - Java
+  - JavaScript
+  - DSA
+description: "This is a solution to the Counting Sort problem on Geeks for Geeks."
+---
+
+## 1. What is Counting Sort?
+
+Counting Sort is a non-comparison-based sorting algorithm. It works by counting the number of occurrences of each unique element in the input array. The algorithm uses this count information to place the elements in their correct positions in the output array.
+
+## 2. Algorithm for Counting Sort
+
+1. Find the maximum element in the input array.
+2. Create a count array of size (maximum element + 1) and initialize all elements to 0.
+3. Count the occurrences of each element in the input array and store it in the count array.
+4. Modify the count array such that each element at each index stores the sum of previous counts.
+5. Output each element from the input array into the correct sorted position in the output array.
+
+## 3. How does Counting Sort work?
+
+- Counting Sort calculates the position of each element in the sorted array by using the count array.
+- The count array stores the count of each unique element.
+- By iterating through the input array and the count array, elements are placed into their correct positions in the output array.
+
+## 4. Problem Description
+
+Given an array of integers, implement the Counting Sort algorithm to sort the array in ascending order.
+
+## 5. Examples
+
+**Example 1:**
+```markdown
+Input: [4, 2, 2, 8, 3, 3, 1]
+Output: [1, 2, 2, 3, 3, 4, 8]
+
+**Example 2:**
+```markdown
+Input: [7, 4, 4, 6, 2, 1, 5, 3, 8, 5]
+Output: [1, 2, 3, 4, 4, 5, 5, 6, 7, 8]
+```
+
+**Explanation of Example 1:**
+- The initial array is [4, 2, 2, 8, 3, 3, 1].
+- Count array: [0, 1, 2, 2, 1, 0, 0, 0, 1]
+- Sorted array: [1, 2, 2, 3, 3, 4, 8]
+
+## 6. Constraints
+
+- The array can have any number of elements.
+- All elements in the array are non-negative integers.
+
+## 7. Implementation
+
+```java
+public class CountingSort {
+    public static void countingSort(int arr[]) {
+        int largest = Integer.MIN_VALUE;
+        for (int i = 0; i < arr.length; i++) {
+            largest = Math.max(largest, arr[i]);
+        }
+
+        int count[] = new int[largest + 1];
+
+        for (int i = 0; i < arr.length; i++) {
+            count[arr[i]]++;
+        }
+
+        int j = 0;
+        for (int i = 0; i < count.length; i++) {
+            while (count[i] > 0) {
+                arr[j] = i;
+                j++;
+                count[i]--;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {4, 2, 2, 8, 3, 3, 1};
+        countingSort(arr);
+        for (int num : arr) {
+            System.out.print(num + " ");
+        }
+    }
+}
+```
+
+## 8. Complexity Analysis
+
+- **Time Complexity**:
+  - Best case: $O(n + k)$  
+  - Average case: $O(n + k)$  
+  - Worst case: $O(n + k)$
+  - where (n) is the number of elements in the input array and (k) is the range of the input.
+
+- **Space Complexity**: $O(n + k)$
+
+## 9. Advantages and Disadvantages
+
+**Advantages:**
+- Simple to implement.
+- Efficient for sorting integers when the range of the input values is not significantly greater than the number of elements.
+
+**Disadvantages:**
+- Not suitable for sorting strings or floating-point numbers.
+- The space complexity can be high if the range of input values is very large.
+
+## 10. References
+
+- **GFG Article on Counting Sort:** [Geeks for Geeks Counting Sort](https://www.geeksforgeeks.org/counting-sort/)
+- **GFG Problem** [Counting Sort Problem](https://www.geeksforgeeks.org/problems/counting-sort/1)
+- **Wikipedia Article on Counting Sort:** [Counting Sort - Wikipedia](https://en.wikipedia.org/wiki/Counting_sort)

dsa-solutions/Sorting-Algorithms/Counting-Sort.md

@@ -0,0 +1,161 @@
+---
+id: FourSum
+title: 4Sum (LeetCode)
+sidebar_label: 0018-FourSum
+tags:
+  - Two Pointers
+description: "Given an array nums of n integers, return an array of all the unique quadruplets [nums[a], nums[b], nums[c], nums[d]]"
+---
+
+## Problem Description
+
+| Problem Statement                                       | Solution Link                                                              | LeetCode Profile                                        |
+| :------------------------------------------------------ | :------------------------------------------------------------------------- | :------------------------------------------------------ |
+| [4Sum](https://leetcode.com/problems/4sum/description/) | [4Sum Solution on LeetCode](https://leetcode.com/problems/4sum/solutions/) | [Abhinash Singh](https://leetcode.com/u/singhabhinash/) |
+
+### Problem Description
+
+Given an array `nums` of `n` integers, return an array of all the unique quadruplets `[nums[a], nums[b], nums[c], nums[d]]` such that:
+
+- `0 <= a, b, c, d < n`
+- `a, b, c, and d are distinct`
+- `nums[a] + nums[b] + nums[c] + nums[d] == target`
+
+You may return the answer in any order.
+
+### Examples
+
+#### Example 1
+
+- **Input:** `nums = [1,0,-1,0,-2,2], target = 0`
+- **Output:** `[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]`
+
+#### Example 2
+
+- **Input:** `nums = [2,2,2,2,2], target = 8`
+- **Output:** `[[2,2,2,2]]`
+
+### Constraints
+
+- $1 <= nums.length <= 200$
+- $-10^9 <= nums[i] <= 10^9$
+- $-10^9 <= target <= 10^9$
+
+### Approach
+
+To solve the problem, we can use the following approach:
+
+1. Sort the input array of integers `nums`.
+2. Initialize an empty set `s`, and an empty list `output`.
+3. Use nested loops to iterate through all possible combinations of quadruplets in `nums`.
+4. For each combination, use two pointers (`k` and `l`) to traverse the sub-array between the second and second-to-last elements of the combination.
+5. At each iteration of the innermost while loop, calculate the sum of the current quadruplet and check if it is equal to the target.
+6. If the sum is equal to the target, insert the quadruplet into the set `s` and increment both pointers (`k` and `l`).
+7. If the sum is less than the target, increment the pointer `k`.
+8. If the sum is greater than the target, decrement the pointer `l`.
+9. After all quadruplets have been checked, iterate through the set `s` and add each quadruplet to the `output` list.
+10. Return the `output` list.
+
+### Solution Code
+
+#### Python
+
+```python
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        nums.sort()
+        s = set()
+        output = []
+        for i in range(len(nums)):
+            for j in range(i + 1, len(nums)):
+                k = j + 1
+                l = len(nums) - 1
+                while k < l:
+                    sum = nums[i] + nums[j] + nums[k] + nums[l]
+                    if sum == target:
+                        s.add((nums[i], nums[j], nums[k], nums[l]))
+                        k += 1
+                        l -= 1
+                    elif sum < target:
+                        k += 1
+                    else:
+                        l -= 1
+        output = list(s)
+        return output
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        sort(nums.begin(), nums.end());
+        set<vector<int>> s;
+        vector<vector<int>> output;
+        for (int i = 0; i < nums.size(); i++) {
+            for(int j = i + 1; j < nums.size(); j++) {
+                int k = j + 1;
+                int l = nums.size() - 1;
+                while (k < l) {
+                    long long sum = nums[i];
+                    sum += nums[j];
+                    sum += nums[k];
+                    sum += nums[l];
+                    if (sum == target) {
+                        s.insert({nums[i], nums[j], nums[k], nums[l]});
+                        k++;
+                        l--;
+                    } else if (sum < target) {
+                        k++;
+                    } else {
+                        l--;
+                    }
+                }
+            }
+        }
+        for(auto quadruplets : s)
+            output.push_back(quadruplets);
+        return output;
+    }
+};
+```
+
+#### Java
+
+```java
+class Solution {
+    public List<List<Integer>> fourSum(int[] nums, int target) {
+        Arrays.sort(nums);
+        Set<List<Integer>> s = new HashSet<>();
+        List<List<Integer>> output = new ArrayList<>();
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                int k = j + 1;
+                int l = nums.length - 1;
+                while (k < l) {
+                    long sum = nums[i];
+                    sum += nums[j];
+                    sum += nums[k];
+                    sum += nums[l];
+                    if (sum == target) {
+                        s.add(Arrays.asList(nums[i], nums[j], nums[k], nums[l]));
+                        k++;
+                        l--;
+                    } else if (sum < target) {
+                        k++;
+                    } else {
+                        l--;
+                    }
+                }
+            }
+        }
+        output.addAll(s);
+        return output;
+    }
+}
+```
+
+### Conclusion
+
+The given solution sorts the input list and uses a nested loop structure with two pointers to find all unique quadruplets that sum up to the target. By using a set to store the quadruplets, it ensures that duplicates are avoided. The solution efficiently narrows down potential combinations by adjusting the pointers based on the current sum relative to the target. This approach is effective for generating the required output while maintaining uniqueness.