added on 23/05/24

Author: Priyanshu-Ganatra

CS_54_Sort01.cpp

@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void sortZeroesAndOne(int input[], int size)
+{
+    int i = 0;
+    int l = size - 1;
+    while (i < l)
+    {
+        if (input[i] == 0)
+        {
+            i++;
+        }
+        else
+        {
+            swap(input[i], input[l]);
+            l--;
+        }
+    }
+}
+
+int main()
+{
+    int input[] = {0, 1, 0, 1, 0, 0, 1, 1, 1, 0};
+    int size = sizeof(input) / sizeof(input[0]);
+    sortZeroesAndOne(input, size);
+    for (int i = 0; i < size; i++)
+    {
+        cout << input[i] << " ";
+    }
+    return 0;
+}

LC_173_RotateArray.cpp

@@ -0,0 +1,48 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    // tc : O(n), sc : O(n)
+    void method1(vector<int> &nums, int n, int k)
+    {
+        vector<int> ans(n);
+
+        for (int i = 0; i < n; i++)
+        {
+            int newi = (i + k) % n;
+            ans[newi] = nums[i];
+        }
+        nums = ans;
+    }
+
+    // tc : O(n), sc : O(1)
+    void method2(vector<int> &nums, int n, int k)
+    {
+        reverse(nums.begin(), nums.begin() + n - k);
+        reverse(nums.begin() + n - k, nums.begin() + n);
+        reverse(nums.begin(), nums.end());
+    }
+
+    void rotate(vector<int> &nums, int k)
+    {
+        int n = nums.size();
+        k = k % n;
+        // method1(nums, n, k);
+        method2(nums, n, k);
+    }
+};
+
+int main()
+{
+    Solution sol;
+    vector<int> nums = {1, 2, 3, 4, 5, 6, 7};
+    int k = 3;
+    sol.rotate(nums, k);
+    for (int i = 0; i < nums.size(); i++)
+    {
+        cout << nums[i] << " ";
+    }
+    return 0;
+}

LC_174_SortColors.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+    // tc : O(n), sc : O(1)
+    void sortColors(vector<int>& arr) {
+        int n = arr.size();
+        int low = 0, mid = 0, high = n - 1;
+        while (mid <= high)
+        {
+            if (arr[mid] == 0)
+            {
+                swap(arr[mid], arr[low]);
+                low++;
+                mid++;
+            }
+            else if (arr[mid] == 1)
+                mid++;
+            else
+            {
+                swap(arr[mid], arr[high]);
+                high--;
+            }
+        }
+    }
+};
+
+int main() {
+    Solution sol;
+    vector<int> arr = {2, 0, 2, 1, 1, 0};
+    sol.sortColors(arr);
+    for (int i = 0; i < arr.size(); i++)
+    {
+        cout << arr[i] << " ";
+    }
+    return 0;
+}

LC_175_3Sum.cpp

@@ -0,0 +1,93 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& arr) {
+        int n = arr.size();
+        // brute
+        // set<vector<int>> ans;
+        // for(int i = 0; i<n; i++){
+        //     for(int j = 0; j<n; j++){
+        //         for(int k = 0; k<n; k++){
+        //             if(i==j || i==k || j==k) continue;
+
+        //             if(arr[i] + arr[j] + arr[k] == 0){
+        //                 vector<int> trip = {arr[i], arr[j], arr[k]};
+        //                 sort(trip.begin(), trip.end());
+        //                 ans.insert(trip);
+        //             }
+        //         }
+        //     }
+        // }
+        // return vector<vector<int>>(ans.begin(), ans.end());
+
+        // better
+        // set<vector<int>> st;
+
+        // for (int i = 0; i < n; i++) {
+        //     set<int> hashset;
+        //     for (int j = i + 1; j < n; j++) {
+        //         // Calculate the 3rd element:
+        //         int third = -(arr[i] + arr[j]);
+
+        //         // Find the element in the set:
+        //         if (hashset.find(third) != hashset.end()) {
+        //             vector<int> temp = {arr[i], arr[j], third};
+        //             sort(temp.begin(), temp.end());
+        //             st.insert(temp);
+        //         }
+        //         hashset.insert(arr[j]);
+        //     }
+        // }
+
+        // // store the set in the answer:
+        // vector<vector<int>> ans(st.begin(), st.end());
+        // return ans;
+
+        // optimal
+        vector<vector<int>> ans;
+        sort(arr.begin(), arr.end());
+        for (int i = 0; i < n; i++) {
+            // remove duplicates:
+            if (i != 0 && arr[i] == arr[i - 1])
+                continue;
+
+            // moving 2 pointers:
+            int j = i + 1;
+            int k = n - 1;
+            while (j < k) {
+                int sum = arr[i] + arr[j] + arr[k];
+                if (sum < 0) {
+                    j++;
+                } else if (sum > 0) {
+                    k--;
+                } else {
+                    vector<int> temp = {arr[i], arr[j], arr[k]};
+                    ans.push_back(temp);
+                    j++;
+                    k--;
+                    // skip the duplicates:
+                    while (j < k && arr[j] == arr[j - 1])
+                        j++;
+                    while (j < k && arr[k] == arr[k + 1])
+                        k--;
+                }
+            }
+        }
+        return ans;
+    }
+};
+
+int main() {
+    Solution sol;
+    vector<int> arr = {-1, 0, 1, 2, -1, -4};
+    vector<vector<int>> ans = sol.threeSum(arr);
+    for (auto v : ans) {
+        for (int i : v) {
+            cout << i << " ";
+        }
+        cout << endl;
+    }
+    return 0;
+}

RotateArrayByOne.cpp

@@ -0,0 +1,33 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void rightRotateByOne(int arr[], int n){
+    int lastVal = arr[n-1];
+    for(int i = n-1; i>0; i--){
+        arr[i] = arr[i-1];
+    }
+    arr[0] = lastVal;
+}
+
+void leftRotateByOne(int arr[], int n){
+    int firstVal = arr[0];
+    for(int i = 0; i<n-1; i++){
+        arr[i] = arr[i+1];
+    }
+    arr[n-1] = firstVal;
+}
+
+int main(){
+    int arr[] = {1, 2, 3, 4, 5};
+    int n = sizeof(arr)/sizeof(int);
+    rightRotateByOne(arr, n);
+    for(auto it: arr){
+        cout << it << " ";
+    }
+    cout << endl;
+    leftRotateByOne(arr, n);
+    for(auto it: arr){
+        cout << it << " ";
+    }
+    return 0;
+}