Merge branch 'main' into main

Author: xDido

README.md

@@ -0,0 +1,17 @@
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* getConcatenation(int* nums, int numsSize, int* returnSize){
+    // dynamically allocate a new int array that is double the size of the
+    // input array
+    int *ans = (int*)malloc(2*numsSize*sizeof(int));
+
+    // loop over input array
+    for (int i = 0; i < numsSize; i++) {
+        ans[i] = ans[i+numsSize] = nums[i];
+    }
+
+    // Set returnSize to double the input size
+    *returnSize = 2 * numsSize;
+    return ans;
+}

c/1929-concatenation-of-array.c

@@ -0,0 +1,27 @@
+// Time: O(logN)
+// Space: O(1)
+
+class Solution {
+public:
+    int findPeakElement(vector<int>& nums) {
+        int n = nums.size();
+
+        if(n == 1) return 0;
+
+        int left = 0, right = n - 1;
+        while(left <= right) {
+            int mid = left + (right-left)/2;
+
+            if(mid > 0 && nums[mid] < nums[mid-1]) {
+                right = mid - 1;
+            }
+            else if(mid < n-1 && nums[mid] < nums[mid+1]) {
+                left = mid + 1;
+            }
+            else {
+                return mid;
+            }
+        }
+        return -1;
+    }
+};

cpp/0162-find-peak-element.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    int rec(vector<pair<int, int>>& oz, int i, int m, int n, vector<vector<vector<int>>>& dp)
+    {
+        if (i >= oz.size())
+            return 0;
+
+        if (oz[i].first > m || oz[i].second > n)
+            return rec(oz, i + 1, m, n, dp);
+        
+        if (dp[i][m][n] != -1)
+            return dp[i][m][n];
+        
+        int take = 1 + rec(oz, i + 1, m - oz[i].first, n - oz[i].second, dp);
+        int notTake = rec(oz, i + 1, m, n, dp);
+
+        return dp[i][m][n] = max(take, notTake);
+    }
+    int findMaxForm(vector<string>& strs, int m, int n) {
+        vector<pair<int, int>> oz(strs.size());
+        vector<vector<vector<int>>> dp (strs.size() + 1, vector<vector<int>>(m + 1, vector<int> (n + 1, -1)));
+
+        for (int i = 0; i < strs.size(); i++)
+        {
+            int one = 0, zero = 0;
+            for (int j = 0; j < strs[i].size(); j++)
+            {
+                if (strs[i][j] == '1')
+                    one++;
+                else
+                    zero++;
+            }
+            oz[i] = {zero, one};
+        }
+        
+        return rec(oz, 0, m, n, dp);
+    }
+};

cpp/0474-ones-and-zeroes.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    vector<int> asteroidCollision(vector<int>& asteroids) {
+        vector<int> stk;
+
+        for (auto ast: asteroids)
+        {
+            while (!stk.empty() && stk.back() > 0 && ast < 0)
+            {
+                int diff = ast + stk.back();
+                if (diff > 0)
+                {
+                    ast = 0;
+                }
+                else if (diff < 0)
+                {
+                    stk.pop_back();
+                }
+                else
+                {
+                    ast = 0;
+                    stk.pop_back();
+                } 
+            }
+            if (ast != 0)
+                stk.push_back(ast);
+        }
+        return stk;
+    }
+};

cpp/0735-asteroid-collision.cpp

@@ -0,0 +1,49 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+
+// Time: O(n)
+// Space: O(1)
+class Solution {
+public:
+    int pairSum(ListNode* head) {
+        ListNode *fast = head, *slow = head;
+
+        while(fast && fast->next) {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        slow = reverseList(slow);
+        
+        int mx = 0;
+        while(head && slow) {
+            mx = max(mx, head->val + slow->val);
+            head = head->next;
+            slow = slow->next;
+        }
+        
+        return mx;
+    }
+private:
+    ListNode* reverseList(ListNode* head) {
+        ListNode* prev = NULL;
+        ListNode* curr = head;
+        ListNode* NEXT = NULL;
+        
+        while(curr) {
+            NEXT = curr->next;
+            curr->next = prev;
+            prev = curr;
+            curr = NEXT;
+        }
+        
+        return prev;
+    }
+};

cpp/2130-maximum-twin-sum-of-a-linked-list.cpp

@@ -0,0 +1,34 @@
+// Time: O(N * logN)
+// Space: O(N)
+
+class Solution {
+public:
+    vector<int> successfulPairs(vector<int>& spells, vector<int>& potions, long long success) {
+        sort(potions.begin(), potions.end());
+
+        int n = spells.size();
+        int m = potions.size();
+        vector<int> pairs(n);
+
+        for(int i = 0; i < n; i++) {
+            int spell = spells[i];
+
+            int start = 0, end = m - 1;
+            int curr;
+
+            while(start <= end) {
+                curr = start + (end-start)/2;
+                long long strength = (long long)potions[curr] * (long long)spell;
+                if(strength < success) {
+                    start = curr + 1;
+                }
+                else {
+                    end = curr - 1;
+                }
+            }
+            pairs[i] = m - start;
+        }
+
+        return pairs;
+    }
+};

cpp/2300-successful-pairs-of-spells-and-potions.cpp

@@ -4,9 +4,13 @@ class Solution {
     public boolean searchMatrix(int[][] matrix, int target) {
         int i = 0, j = matrix[0].length - 1;
         while (i < matrix.length && j >= 0) {
-            if (matrix[i][j] == target) return true; else if (
-                matrix[i][j] > target
-            ) j--; else i++;
+            if (matrix[i][j] == target) {
+		 return true;
+	    } else if (matrix[i][j] > target) {
+		 j--;
+	    } else {
+		 i++;
+	    }
         }
         return false;
     }

java/0074-search-a-2d-matrix.java

@@ -0,0 +1,23 @@
+class Solution {
+    public String mergeAlternately(String word1, String word2) {
+        int i = 0;
+        StringBuilder res = new StringBuilder();
+
+        while (i < word1.length() || i < word2.length()) {
+            if (i < word1.length()) {
+                res.append(word1.charAt(i));
+            }
+            if (i < word2.length()) {
+                res.append(word2.charAt(i));
+            }
+            i++;
+        }
+
+        return res.toString();
+    }
+}
+
+/**
+ * Time Complexity : O(n+m)
+ * Space Complexity : O(n+m)
+ */

java/1768-merge-strings-alternately.java

@@ -0,0 +1,47 @@
+/**
+ * Binary Search
+ * https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/
+ * Time O(log(n)) | Space O(1)
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var searchRange = function(nums, target) {
+    
+    const result = [];
+
+    result.push(binarySearch(true, nums, target));
+    result.push(binarySearch(false, nums, target));
+
+    return result;
+};
+
+var binarySearch = (isLeftBias, nums, target) => {
+      let left = 0;
+      let right = nums.length - 1;
+      let index = -1;
+
+      while(left <= right) {
+        
+        const mid = (left + right) >> 1;
+
+        if(target > nums[mid]) {
+          left = mid+1;
+        }
+        if(target < nums[mid]) {
+          right = mid-1;
+        }
+        
+        const isTarget = target === nums[mid];
+        if(isTarget) {
+          if(isLeftBias) {
+            index = mid;
+            right = mid - 1;
+          } else {
+            index = mid;
+            left = mid + 1;
+          }
+        }
+      }
+      return index;
+}