Merge branch 'neetcode-gh:main' into patch-2

Author: tharunkanna14

.github/workflows/build-readme.yml

@@ -10,27 +10,23 @@ jobs:
     Build:
         runs-on: ubuntu-latest
 
-        strategy:
-            matrix:
-                node-version: [16.x]
-
         steps:
             - uses: actions/checkout@v3
               with:
                   ref: ${{ github.head_ref }}
                   fetch-depth: 1
 
             - name: Use Node.js (dependency)
-              uses: actions/setup-node@v1
+              uses: actions/setup-node@v3
               with:
-                  node-version: ${{ matrix.node-version }}
+                  node-version: 16
 
             - name: Completion Table
               run: node ./.github/workflows/updateCompletionTable.js;
 
             - name: Check for modified files
               id: git-check
-              run: echo ::set-output name=modified::$(if git diff-index --quiet HEAD --; then echo "false"; else echo "true"; fi)
+              run: echo modified=$(if git diff-index --quiet HEAD --; then echo "false"; else echo "true"; fi) >> $GITHUB_OUTPUT
 
             - name: Push
               if: steps.git-check.outputs.modified == 'true'

README.md

@@ -0,0 +1,62 @@
+/*
+    Time: log(min(n, m))
+    Space: O(1)
+*/
+
+#define min(x, y) ((x < y) ? (x) : (y))
+#define max(x, y) ((x > y) ? (x) : (y))
+
+double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size){
+        int* A = nums1;
+        int* B = nums2;
+        int ASize = nums1Size;
+        int BSize = nums2Size;
+    
+        int total = nums1Size + nums2Size;
+        int half = total / 2;
+        
+        if(nums2Size < nums1Size)
+        {
+            A = nums2;
+            B = nums1;
+            ASize = nums2Size;
+            BSize = nums1Size;
+        }
+        
+        int l = 0;
+        int r = ASize - 1;
+        
+        while(true)
+        {
+            int i = l + ((r - l - 2 + 1) / 2); // A Mid, round down instead of rounding towards 0
+            int j = half - i - 2;      // B Mid
+            
+            
+            int Aleft = i >= 0 ? A[i] : INT_MIN;
+            int Aright = (i + 1) < ASize ? A[i + 1] : INT_MAX;
+            int Bleft = j >= 0 ? B[j] : INT_MIN;
+            int Bright = (j + 1) < BSize ? B[j + 1] : INT_MAX;
+            
+            // partition is correct
+            if(Aleft <= Bright && Bleft <= Aright)
+            {
+                // Odd
+                if(total % 2)
+                {
+                    return min(Aright, Bright);
+                }
+                
+                // Even
+                return (max(Aleft, Bleft) + min(Aright, Bright)) / 2.0;
+            }
+            else if(Aleft > Bright)
+            {
+                r = i - 1;
+            }
+            else
+            {
+                l = i + 1;
+            }
+        }
+        
+}

c/4-Median-of-Two-Sorted-Arrays.c

@@ -0,0 +1,39 @@
+// Time and space complexity is O(n) where n is the size of the input string.
+class Solution {
+public:
+    string removeDuplicates(string s, int k) {
+      stack<pair<char , int>> st;
+      
+      for(int i = 0 ; i < s.size(); i++)
+      {
+        int count = 1;
+        if(!st.empty() && st.top().first == s[i])
+        {
+          count += st.top().second;
+          st.pop();
+        }
+        
+        st.push({s[i] , count});
+        
+        if(count == k) st.pop();
+        
+      }
+      
+      string ans = "";
+      while(!st.empty())
+      {
+        int freq = st.top().second;
+        int c = st.top().first;
+        while(freq > 0)
+        {
+           ans += c;
+           freq--;
+        }
+        
+        st.pop();
+      }
+      
+      reverse(ans.begin() , ans.end());
+      return ans;
+    }
+};

cpp/1209-Remove-All-Adjacent-Duplicates-in-String-II.cpp

@@ -0,0 +1,59 @@
+class Solution {
+public:
+  vector<vector<int>> res;
+  
+  vector<vector<int>> fourSum(vector<int>& nums, int target) {
+    
+      if(nums.size() < 4) return res;
+    
+      vector<int>quad;
+      sort(nums.begin() , nums.end());
+      kSum(0,4,target,nums,quad);
+      return res;
+    }
+  
+  
+  void kSum (int index , int k , long long target, vector<int> nums , vector<int>&q)
+  {
+    
+    if(k == 2)
+    {
+      twoSum(index , target, q , nums);
+      return;
+    }
+ 
+    for(int i = index ; i < nums.size() - k + 1; i++)
+    {
+      if(i > index && nums[i] == nums[i-1]) continue;
+      q.push_back(nums[i]);
+      kSum(i+1 , k-1 , target-nums[i] , nums , q);
+      q.pop_back();
+    }      
+
+  }
+  
+  void twoSum (int start,long long target,vector<int>&ans,vector<int>& nums)
+  {
+    int lo = start;
+    int hi = nums.size()-1;
+    
+    while(lo < hi)
+    {
+      int sum = nums[lo]+nums[hi];
+      if(sum > target) hi--;
+      else if (sum < target) lo++;
+      
+      else 
+      {
+        ans.insert(ans.end() , {nums[lo] , nums[hi]});
+        res.push_back(ans);
+        
+        ans.pop_back();
+        ans.pop_back();
+        
+        lo++;
+        while (lo < hi && nums[lo] == nums[lo - 1]) lo++;
+      }
+    }    
+  }
+};

cpp/14-4Sum.cpp

@@ -7,7 +7,7 @@
     Differ by 1 bit, by removing LSB: f(x) = f(x / 2) + (x mod 2)
 
     Time: O(n)
-    Space: O(n)
+    Space: O(1), the output array does not count towards space
 */
 
 class Solution {

cpp/338-Counting-Bits.cpp

@@ -0,0 +1,37 @@
+// Time Complexity is O(N) where N is the size of the input string.
+// Space complexity is O(N) as well
+class Solution {
+public:
+    string removeKdigits(string num, int k) {
+      int n = num.size();
+      
+      stack<char>s;
+      int count = k;
+      
+      for(int i = 0 ; i < n; i++)
+      {
+        while(!s.empty() && count > 0 && s.top() > num[i])
+        {
+          s.pop();
+          count--;
+        }
+        s.push(num[i]);
+      }
+      
+      // In case the num was already in a non increasing order (e.x: 123456)
+      while(s.size() != n - k) s.pop();
+     
+      string res = "";
+      while(!s.empty())
+      {
+        res += s.top();
+        s.pop();
+      }
+      reverse(res.begin() , res.end());
+      // Remove the zeros from the left if they exist.
+      while (res[0] == '0') res.erase(0 , 1);
+    
+      
+      return (res == "") ? "0": res;
+    }
+};

cpp/402-Remove-K-Digits.cpp

@@ -0,0 +1,22 @@
+// Time Complexity is O(N).
+// Space Complexity is O(1).
+
+class Solution {
+public:
+    ListNode* deleteDuplicates(ListNode* head) {
+      ListNode * fast = head;
+      ListNode * slow = head;
+      
+      while(slow != NULL)
+      {
+        while(fast != NULL && slow->val == fast->val)
+          fast = fast -> next;
+        
+        slow->next = fast;
+        slow = slow -> next;
+      }
+      
+      return head;
+        
+    }
+};

cpp/83-Remove-Duplicates-from-Sorted-List.cpp

@@ -47,3 +47,41 @@ class Solution {
         return false;
     }
 };
+
+// Same approach with implicit array linearization
+// T(n) = O(log_2(mn)) = O(log_2(m) + log_2(n))
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+
+        int left = 0;
+        int m = matrix.size();
+        int n = matrix[0].size();
+        int right = m * n - 1;
+
+        while (left <= right){
+
+            int middle = right + (left - right) / 2;
+
+            // compute sub-indices using matrix structure
+            int row = middle / n;
+            int col = middle % n; 
+
+
+            //ordinary binary search
+            int middle_x = matrix[row][col];
+            if (target > middle_x){
+                left = ++middle;
+            } else if (target < middle_x){
+                right = --middle;
+            } else {
+                return true;
+            }
+
+
+        }
+
+        return false;
+        
+    }
+};