initial commit

Author: Priyanshu-Ganatra

CS_29_CommonElementsIn3SortedArrays.cpp

@@ -0,0 +1,62 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<int> findCommonElements(vector<int> &a, vector<int> &b, vector<int> &c)
+{
+    vector<int> ans;
+    set<int> s;
+    int i, j, k;
+    i = j = k = 0;
+    int n1 = a.size();
+    int n2 = b.size();
+    int n3 = c.size();
+    while (i < n1 && j < n2 && k < n3)
+    {
+        if (a[i] == b[j] && b[j] == c[k])
+        {
+            s.insert(a[i]);
+            i++, j++, k++;
+        }
+        else if (a[i] < b[j])
+        {
+            i++;
+        }
+        else if (b[j] < c[k])
+        {
+            j++;
+        }
+        else
+        {
+            k++;
+        }
+    }
+    for (auto i : s)
+    {
+        ans.push_back(i);
+    }
+    return ans;
+}
+
+int main()
+{
+    cout << "Array 1: ";
+    vector<int> a = {1, 5, 10, 20, 40, 80};
+    for (int i = 0; i < a.size(); i++)
+        cout << a[i] << " ";
+    cout << endl;
+    cout << "Array 2: ";
+    vector<int> b = {6, 7, 20, 80, 100};
+    for (int i = 0; i < b.size(); i++)
+        cout << b[i] << " ";
+    cout << endl;
+    cout << "Array 3: ";
+    vector<int> c = {3, 4, 15, 20, 30, 70, 80, 120};
+    for (int i = 0; i < c.size(); i++)
+        cout << c[i] << " ";
+    cout << endl;
+    cout << "Common elements: ";
+    vector<int> ans = findCommonElements(a, b, c);
+    for (int i = 0; i < ans.size(); i++)
+        cout << ans[i] << " ";
+    return 0;
+} 

CS_30_SumOfTwoArrays.cpp

@@ -0,0 +1,62 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<int> findArraySum(vector<int> &a, int n, vector<int> &b, int m)
+{
+    vector<int> ans;
+    int sum = 0;
+    int carry = 0;
+    int i = n - 1;
+    int j = m - 1;
+    while (i >= 0 && j >= 0)
+    {
+        int val1 = a[i];
+        int val2 = b[j];
+
+        sum = val1 + val2 + carry;
+        carry = sum / 10;
+        sum = sum % 10;
+        ans.push_back(sum);
+        i--;
+        j--;
+    }
+    while (i >= 0 || j >= 0 || carry != 0)
+    {
+        if (i >= 0)
+        {
+            int sum = a[i] + carry;
+            carry = sum / 10;
+            sum = sum % 10;
+            ans.push_back(sum);
+            i--;
+        }
+        else if (j >= 0)
+        {
+            int sum = b[j] + carry;
+            carry = sum / 10;
+            sum = sum % 10;
+            ans.push_back(sum);
+            j--;
+        }
+        else if (carry != 0)
+        {
+            int sum = carry;
+            carry = sum / 10;
+            sum = sum % 10;
+            ans.push_back(sum);
+        }
+    }
+    reverse(ans.begin(), ans.end());
+    return ans;
+}
+
+int main()
+{
+    vector<int> a = {9, 9, 9, 9, 9, 9, 9};
+    vector<int> b = {1, 6, 8, 9, 9, 9, 9, 9};
+    vector<int> ans = findArraySum(a, a.size(), b, b.size());
+    for (int i = 0; i < ans.size(); i++)
+        cout << ans[i] << " ";
+    cout << endl;
+    return 0;
+}

CS_31_FactorialOfALargeNumber.cpp

@@ -0,0 +1,66 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// On GFG, this is the solution:
+// vector<int> factorial(int N)
+// {
+//     // code here
+//     vector<int> ans;
+//     ans.push_back(1);
+//     int carry = 0;
+//     for (int i = 2; i <= N; i++)
+//     {
+//         for (int j = 0; j < ans.size(); j++)
+//         {
+//             int val = ans[j] * i + carry;
+//             ans[j] = val % 10;
+//             carry = val / 10;
+//         }
+
+//         // if carry exits
+//         while (carry)
+//         {
+//             ans.push_back(carry % 10);
+//             carry /= 10;
+//         }
+//     }
+//     reverse(ans.begin(), ans.end());
+//     return ans;
+// }
+
+// On codestudio, this is the solution:
+void multiply(string &s, int x)
+{
+    int carry = 0, prod = 1;
+    for (int i = 0; i < s.length(); i++)
+    {
+        prod = (x * (s[i] - '0')) + carry;
+        carry = prod / 10;
+        prod = prod % 10;
+        s[i] = char(prod + '0');
+    }
+    while (carry)
+    {
+        s.push_back(char((carry % 10) + '0'));
+        carry /= 10;
+    }
+}
+string calculateFactorial(int n)
+{
+    string ans = "1";
+    for (int i = 2; i <= n; i++)
+    {
+        multiply(ans, i);
+    }
+    reverse(ans.begin(), ans.end());
+    return ans;
+}
+
+int main()
+{
+    int n;
+    cin >> n;
+    string ans = calculateFactorial(n);
+    cout << ans << endl;
+    return 0;
+}

LC_10_SearchInRotatedSortedArray.cpp

@@ -0,0 +1,87 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int findPivot(vector<int> &nums)
+{
+    int s = 0;
+    int n = nums.size();
+    int e = n - 1;
+    // Example (This function also works for non-rotated sorted array):
+    // 2 4 6 8 10 - arr
+    // 0 1 2 3 4 - index
+    // ans = 4, as 10 i.e. pivot is at index 4
+    while (s <= e)
+    {
+        int mid = s + (e - s) / 2;
+        // corner case
+        if (s == e)
+        {
+            return s;
+        }
+
+        if (mid + 1 < n && nums[mid] > nums[mid + 1])
+        {
+            return mid;
+        }
+        else if (mid - 1 >= 0 && nums[mid - 1] > nums[mid])
+        {
+            return mid - 1;
+        }
+        else if (nums[s] > nums[mid])
+        { // we're currently on portion B
+            // ans is in left portion
+            e = mid - 1;
+        }
+        else
+        { // we're currently on portion A
+            // ans is in right portion
+            s = mid + 1;
+        }
+    }
+    return -1;
+}
+
+int binarySearch(vector<int> &arr, int s, int e, int target)
+{
+    while (s <= e)
+    {
+        int mid = s + (e - s) / 2;
+        if (arr[mid] == target)
+            return mid;
+        else if (target > arr[mid])
+        {
+            s = mid + 1;
+        }
+        else
+        {
+            e = mid - 1;
+        }
+    }
+    return -1;
+}
+
+int search(vector<int> &arr, int target)
+{
+    int pivot = findPivot(arr);
+    int n = arr.size();
+    int ans = -1;
+
+    // search in A
+    if (target >= arr[0] && target <= arr[pivot])
+    {
+        ans = binarySearch(arr, 0, pivot, target);
+    }
+    else
+    {
+        ans = binarySearch(arr, pivot + 1, n - 1, target);
+    }
+    return ans;
+}
+
+int main()
+{
+    vector<int> arr = {4, 5, 6, 7, 0, 1, 2};
+    int target = 7;
+    cout << search(arr, target) << endl;
+    return 0;
+}

LC_11_Sqrt(x).cpp

@@ -0,0 +1,39 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int mySqrt(int x)
+{
+    int s = 0, e = x;
+    int ans = -1;
+    long long mid = 0;
+
+    while (s <= e)
+    {
+        mid = s + (e - s) / 2;
+        // ans found
+        if (mid * mid == x)
+        {
+            return mid;
+        }
+        else if (mid * mid < x)
+        {
+            // store ans
+            // and & move right
+            ans = mid;
+            s = mid + 1;
+        }
+        else
+        {
+            // move left
+            e = mid - 1;
+        }
+    }
+    return ans;
+}
+
+int main()
+{
+    int x = 2147395599;
+    cout << mySqrt(x) << endl;
+    return 0;
+}

LC_12_SearchInA2dMatrix.cpp

@@ -0,0 +1,47 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// tc: O(log (m*n))
+bool searchMatrix(vector<vector<int>> &m, int target)
+{
+    int row = m.size();
+    int col = m[0].size();
+    int n = row * col;
+
+    int s = 0;
+    int e = n - 1;
+
+    while (s <= e)
+    {
+        int mid = s + (e - s) / 2;
+        int rowIndex = mid / col;
+        int colIndex = mid % col;
+        int curr = m[rowIndex][colIndex];
+
+        if (curr == target)
+        {
+            return true;
+        }
+        else if (target > curr)
+        {
+            // right
+            s = mid + 1;
+        }
+        else
+        {
+            // left
+            e = mid - 1;
+        }
+    }
+    return false;
+}
+
+int main()
+{
+    vector<vector<int>> m = {{1, 3, 5, 7},
+                             {10, 11, 16, 20},
+                             {23, 30, 34, 60}};
+    int target = 3;
+    cout << searchMatrix(m, target) << endl;
+    return 0;
+}