Merge branch 'main' into 1630

Author: benmak11

.problemSiteData.json

@@ -1,15 +1,12 @@
-class Solution {
-public:
-    int removeDuplicates(vector<int>& nums) {
-        int left = 1;
-
-        for(int right = 1; right < nums.size(); right++){
-            if(nums[right] != nums[right - 1]){
-                nums[left] = nums[right];
-                left++;
-            }
+int removeDuplicates(int* nums, int numsSize){
+    int indx = 1;
+    
+    for(int i = 1; i < numsSize; i++){
+        if(nums[i] != nums[i-1]){
+            nums[indx] = nums[i];
+            indx++;
         }
-
-        return left;
     }
-};
+    return indx;
+}
+

README.md

@@ -1,22 +1,37 @@
+/*
+  Given a non-negative integer x, return the square root of x rounded down to the nearest integer. The returned integer should be non-negative as well.
+  You must not use any built-in exponent function or operator.
+
+  For example, do not use pow(x, 0.5) in c++ or x ** 0.5 in python.
+
+  Ex. Input: x = 4
+      Output: 2
+      Explanation: The square root of 4 is 2, so we return 2.
+
+  Time  : O(log N)
+  Space : O(1)
+*/
+
 class Solution {
 public:
     int mySqrt(int x) {
-
-        int l = 0;
-        int r = x;
-
-        while(l <= r){
-            long int m = (l + r) / 2;
-            if(m * m == x){
-                return m;
-            }
-            else if(m * m > x){
-                r = m - 1;
-            }
-            else{
-                l = m + 1;
-            }
+        if(x == 0 || x == 1)
+            return x;
+            
+        long long beg = 0, mid = 0, end = x/2;
+        while(beg <= end) {
+            mid = (beg + end)/2;
+            if(mid * mid < x) {
+                if((mid + 1) * (mid + 1) > x)
+                    return mid;
+                beg = mid+1;
+            } else if(mid * mid > x) {
+                if( (mid - 1) * (mid - 1) < x)
+                    return mid-1;
+                end = mid - 1;
+            } else 
+                return mid;
         }
-        return r;
+        return mid;
     }
-};
+};

cpp/0026-remove-duplicates-from-sorted-array.c

@@ -8,7 +8,7 @@ class Solution {
     At the end, which ever places are positive, add them to our answer.
     
     Time complexity: O(n)
-    Space complexity: O(1)
+    Space complexity: O(n)
     */
     vector<int> findDisappearedNumbers(vector<int>& nums) {
         vector<int> ans;
@@ -23,4 +23,4 @@ class Solution {
 
         return ans;
     }
-};
+};

cpp/0026-remove-duplicates-from-sorted-array.cpp

@@ -0,0 +1,46 @@
+//time O(n)
+//space O(n)
+
+class Solution {
+public:
+    long long distinctNames(vector<string>& ideas) {
+        
+        unordered_map<char,unordered_set<string>> dict;
+        
+        for(const string& idea : ideas){
+            dict[idea[0]].insert(idea.substr(1));
+        } 
+        
+        if(dict.size() < 2){
+            return 0;
+        }
+         
+        long long count = 0;
+        
+        for(char a = 'a'; a <= 'z' ; a++){
+             
+            if(dict.find(a) == dict.end())
+                continue;
+                        
+            for(char b = a+1; b <= 'z'; b++){
+                
+                if(dict.find(b) == dict.end())
+                    continue;
+                
+                int aKeys = dict[a].size();
+                int bKeys = dict[b].size();
+                 
+                for(const string& suffix : dict[a]){
+                    if(dict[b].find(suffix) != dict[b].end()){
+                        aKeys--;
+                        bKeys--;
+                    }
+                }
+                
+                count += 2 * (aKeys*bKeys);
+            }
+        }
+        
+        return count;
+    }
+};

cpp/0069-sqrt(x).cpp

@@ -0,0 +1,25 @@
+public class Solution
+{
+    public void Merge(int[] nums1, int m, int[] nums2, int n)
+    {
+        var index1 = m - 1;
+        var index2 = n - 1;
+        var targetIndex = m + n - 1;
+
+        for (; targetIndex >= 0; targetIndex--)
+        {
+            var useNums1 = (index2 < 0) || (index1 >= 0 && nums1[index1] >= nums2[index2]);
+
+            if (useNums1)
+            {
+                nums1[targetIndex] = nums1[index1];
+                index1 -= 1;
+            }
+            else
+            {
+                nums1[targetIndex] = nums2[index2];
+                index2 -= 1;
+            }
+        }
+    }
+}