sync

Vansh · Vansh · commit 6acf737bfbd6 · 2024-07-24T15:30:51.000+05:30
diff --git a/dsa-solutions/gfg-solutions/Easy problems/square-root.md b/dsa-solutions/gfg-solutions/Easy problems/square-root.md
@@ -1,16 +1,11 @@
 ---
 id: square-root
 title: Square Root
-sidebar_label: 9 Square Root
+sidebar_label: Square-Root
 tags:
 - Math
 - Binary Search
-- Python
-- Java
-- C++
-- JavaScript
-- TypeScript
-description: "This document provides solutions to the problem of finding the square root of a given integer using various programming languages."
+description: "This document provides solutions to the problem of finding the Square Root of an integer."
 ---
 
 ## Problem
@@ -43,7 +38,7 @@ You don't need to read input or print anything. The task is to complete the func
 **Expected Auxiliary Space:** $O(1)$
 
 **Constraints**
-- $1 ≤ x ≤ 10^7$
+- `1 ≤ x ≤ 10^7`
 
 ## Solution
 
@@ -190,11 +185,4 @@ class Solution {
 The provided solutions efficiently find the floor value of the square root of a given integer `x` using binary search. This approach ensures a time complexity of $ O(log N) and an auxiliary space complexity of $O(1)$. The algorithms are designed to handle large values of `x` up to 10^7 efficiently without relying on built-in square root functions.
 
 **Time Complexity:** $O(log N)$
-**Auxiliary Space:** $O(1)$
-
----
-
-## References
-
-- **GeeksforGeeks Problem:** [Square root](https://www.geeksforgeeks.org/problems/square-root/0)
-- **Author GeeksforGeeks Profile:** [GeeksforGeeks](https://www.geeksforgeeks.org/user/GeeksforGeeks/)
+**Auxiliary Space:** $O(1)$
diff --git a/dsa-solutions/lc-solutions/0900-0999/0905-sort-array-by-parity.md b/dsa-solutions/lc-solutions/0900-0999/0905-sort-array-by-parity.md
@@ -1,141 +1,188 @@
 ---
-id: sort-array-by-parity
+id: Sort-Array-By-Parity
 title: Sort Array By Parity
-sidebar_label: 0905 - Sort Array By Parity
-tags:
-  - easy
-  - Arrays
-  - Algorithms
+sidebar_label: Sort Array By Parity
+tags: 
+    - Arrays
+    - Sorting
 ---
 
 ## Problem Description
 
-Given an integer array `nums`, move all the even integers to the beginning of the array followed by all the odd integers.
+| Problem Statement                                       | Solution Link                                                              | LeetCode Profile                                        |
+| :------------------------------------------------------ | :------------------------------------------------------------------------- | :------------------------------------------------------ |
+| [Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/description/) | [Sort Array By Parity Solution on LeetCode](https://leetcode.com/problems/sort-array-by-parity/solutions/) | [Nikita Saini](https://leetcode.com/u/Saini_Nikita/) |
 
-Return any array that satisfies this condition.
+## Problem Description
 
-## Examples
+Given an integer array `nums`, move all the even integers at the beginning of the array followed by all the odd integers.
 
-**Example 1:**
+Return any array that satisfies this condition.
 
-```
-Input: nums = [3,1,2,4]
-Output: [2,4,3,1]
-Explanation: The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
-```
+### Example 1:
 
-**Example 2:**
+**Input:** `nums = [3, 1, 2, 4]`  
+**Output:** `[2, 4, 3, 1]`  
+**Explanation:** The outputs `[4, 2, 3, 1]`, `[2, 4, 1, 3]`, and `[4, 2, 1, 3]` would also be accepted.
 
-```
-Input: nums = [0]
-Output: [0]
-```
+### Example 2:
+
+**Input:** `nums = [0]`  
+**Output:** `[0]`
 
 ## Constraints
 
-```
-1 <= nums.length <= 5000
-0 <= nums[i] <= 5000
-```
+- `1 <= nums.length <= 5000`
+- `0 <= nums[i] <= 5000`
+
+## Approach
+
+1. **Identify even and odd integers**: Iterate through the array and separate the even and odd integers.
+2. **Rearrange the array**: Place all even integers at the beginning of the array followed by the odd integers.
 
 ## Solution
 
 ### Python
 
 ```python
-class Solution:
-    def sortArrayByParity(self, nums):
-        return [x for x in nums if x % 2 == 0] + [x for x in nums if x % 2 != 0]
-
-# Example usage:
-solution = Solution()
-print(solution.sortArrayByParity([3,1,2,4]))  # Output: [2,4,3,1]
+def sortArrayByParity(nums):
+    even = [x for x in nums if x % 2 == 0]
+    odd = [x for x in nums if x % 2 != 0]
+    return even + odd
+
+# Example usage
+nums = [3, 1, 2, 4]
+print(sortArrayByParity(nums))  # Output: [2, 4, 3, 1]
 ```
 
-### C++
+### Java
 
-```cpp
-#include <vector>
-#include <algorithm>
+```java
+import java.util.*;
 
-class Solution {
-public:
-    std::vector<int> sortArrayByParity(std::vector<int>& nums) {
-        std::vector<int> result;
+public class EvenOddArray {
+    public static int[] sortArrayByParity(int[] nums) {
+        List<Integer> even = new ArrayList<>();
+        List<Integer> odd = new ArrayList<>();
+        
         for (int num : nums) {
             if (num % 2 == 0) {
-                result.push_back(num);
+                even.add(num);
+            } else {
+                odd.add(num);
             }
         }
-        for (int num : nums) {
-            if (num % 2 != 0) {
-                result.push_back(num);
-            }
+        
+        even.addAll(odd);
+        return even.stream().mapToInt(i -> i).toArray();
+    }
+    
+    public static void main(String[] args) {
+        int[] nums = {3, 1, 2, 4};
+        System.out.println(Arrays.toString(sortArrayByParity(nums)));  // Output: [2, 4, 3, 1]
+    }
+}
+```
+
+### C++
+
+```cpp
+#include <vector>
+#include <iostream>
+
+std::vector<int> sortArrayByParity(std::vector<int>& nums) {
+    std::vector<int> even, odd;
+    for (int num : nums) {
+        if (num % 2 == 0) {
+            even.push_back(num);
+        } else {
+            odd.push_back(num);
         }
-        return result;
     }
-};
+    even.insert(even.end(), odd.begin(), odd.end());
+    return even;
+}
 
-// Example usage:
 int main() {
-    Solution solution;
     std::vector<int> nums = {3, 1, 2, 4};
-    std::vector<int> result = solution.sortArrayByParity(nums);  // Output: [2, 4, 3, 1]
-    return 0;
+    std::vector<int> result = sortArrayByParity(nums);
+    for (int num : result) {
+        std::cout << num << " ";
+    }
+    // Output: 2 4 3 1
 }
 ```
 
-### Java
-
-```java
-import java.util.ArrayList;
-import java.util.List;
-
-class Solution {
-    public int[] sortArrayByParity(int[] nums) {
-        List<Integer> result = new ArrayList<>();
-        for (int num : nums) {
-            if (num % 2 == 0) {
-                result.add(num);
-            }
-        }
-        for (int num : nums) {
-            if (num % 2 != 0) {
-                result.add(num);
-            }
+### C
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+void sortArrayByParity(int* nums, int numsSize, int* returnSize) {
+    int* result = (int*)malloc(numsSize * sizeof(int));
+    int evenIndex = 0, oddIndex = numsSize - 1;
+    
+    for (int i = 0; i < numsSize; ++i) {
+        if (nums[i] % 2 == 0) {
+            result[evenIndex++] = nums[i];
+        } else {
+            result[oddIndex--] = nums[i];
         }
-        return result.stream().mapToInt(i -> i).toArray();
     }
+    *returnSize = numsSize;
+    for (int i = 0; i < numsSize; ++i) {
+        nums[i] = result[i];
+    }
+    free(result);
+}
 
-    public static void main(String[] args) {
-        Solution solution = new Solution();
-        int[] nums = {3, 1, 2, 4};
-        int[] result = solution.sortArrayByParity(nums);  // Output: [2, 4, 3, 1]
-        for (int num : result) {
-            System.out.print(num + " ");
-        }
+int main() {
+    int nums[] = {3, 1, 2, 4};
+    int numsSize = sizeof(nums) / sizeof(nums[0]);
+    int returnSize;
+    sortArrayByParity(nums, numsSize, &returnSize);
+    
+    for (int i = 0; i < numsSize; ++i) {
+        printf("%d ", nums[i]);
     }
+    // Output: 2 4 3 1
+    return 0;
 }
 ```
 
 ### JavaScript
 
 ```javascript
-var sortArrayByParity = function (nums) {
-  let result = [];
-  for (let num of nums) {
-    if (num % 2 === 0) {
-      result.push(num);
-    }
-  }
-  for (let num of nums) {
-    if (num % 2 !== 0) {
-      result.push(num);
+function sortArrayByParity(nums) {
+    let even = [];
+    let odd = [];
+    
+    for (let num of nums) {
+        if (num % 2 === 0) {
+            even.push(num);
+        } else {
+            odd.push(num);
+        }
     }
-  }
-  return result;
-};
+    
+    return [...even, ...odd];
+}
 
-// Example usage:
-console.log(sortArrayByParity([3, 1, 2, 4])); // Output: [2, 4, 3, 1]
+// Example usage
+let nums = [3, 1, 2, 4];
+console.log(sortArrayByParity(nums));  // Output: [2, 4, 3, 1]
 ```
+
+## Step-by-Step Algorithm
+
+1. Initialize two empty lists/arrays: one for even integers and one for odd integers.
+2. Iterate through the given array:
+   - If the current integer is even, add it to the even list/array.
+   - If the current integer is odd, add it to the odd list/array.
+3. Concatenate the even list/array with the odd list/array.
+4. Return the concatenated list/array.
+
+## Conclusion
+
+This problem can be solved efficiently by iterating through the array once and separating the integers into even and odd lists/arrays. The time complexity is O(n), where n is the length of the array, making this approach optimal for the given constraints.
