add leetcode solutions

Author: Vikas Gola

.gitignore

@@ -127,3 +127,7 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+*.dat
+all.html
+
+.vscode/

1.two-sum.cpp

@@ -1,22 +1,12 @@
-/*
- * @lc app=leetcode id=1 lang=cpp
- *
- * [1] Two Sum
- */
-
-// @lc code=start
-
 class Solution {
 public:
     vector<int> twoSum(vector<int>& nums, int target) {
-        map<int, int> cont;
-        for(int i = 0; i < nums.size(); i++){
-            int n = nums[i];
-            if(cont.count(target-n)) return {i, cont[target-n]};
-            cont[n] = i;
+        map<int, int> exists;
+        for(int i=0;i<nums.size();i++){
+            auto n = exists.find(target-nums[i]);
+            if(n != exists.end()) return {exists[target-nums[i]], i};
+            exists[nums[i]] = i;
         }
         return {};
     }
-};
-// @lc code=end
-
+};

100.same-tree.cpp

@@ -1,10 +1,3 @@
-/*
- * @lc app=leetcode id=100 lang=cpp
- *
- * [100] Same Tree
- */
-
-// @lc code=start
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
@@ -22,6 +15,4 @@ class Solution {
         if(!p || !q) return p == q;
         return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
     }
-};
-// @lc code=end
-
+};

101.symmetric-tree.cpp

@@ -1,10 +1,3 @@
-/*
- * @lc app=leetcode id=101 lang=cpp
- *
- * [101] Symmetric Tree
- */
-
-// @lc code=start
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
@@ -23,8 +16,6 @@ class Solution {
         return p->val == q->val && isSameTree(p->left, q->right) && isSameTree(p->right, q->left);
     }
     bool isSymmetric(TreeNode* root) {
-        return isSameTree(root->left, root->right);   
+        return isSameTree(root->left, root->right);
     }
-};
-// @lc code=end
-
+};

1019.squares-of-a-sorted-array.cpp

@@ -0,0 +1,8 @@
+class Solution {
+public:
+    vector<int> sortedSquares(vector<int>& A) {
+        for_each(A.begin(), A.end(), [](int &a){a=a*a;});
+        sort(A.begin(), A.end());
+        return A;
+    }
+};

1032.satisfiability-of-equality-equations.cpp

@@ -0,0 +1,44 @@
+class Solution {
+public:
+
+    int getparent(int loc[], int a){
+        int t = loc[a];
+        while(t != loc[t]) t = loc[t];
+        return t;
+    }
+
+
+    bool check(int loc[], int a, int b){
+        int t = getparent(loc, a);
+        int t2 = getparent(loc, b);
+        return t != t2;
+    }
+
+    void add(int loc[], int a, int b){
+        loc[b] = loc[a];
+    }
+
+    bool equationsPossible(vector<string>& equations) {
+        int n = equations.size();
+        //if(n < 1) return true;
+        int loc[26];
+        for(int i=0;i<26;i++) loc[i] = i;
+
+        for(int i=0;i<n;i++){
+            int a = getparent(loc, equations[i][0] - 'a');
+            int b = getparent(loc, equations[i][3] - 'a');
+            if(equations[i][1] == '='){
+                a < b ? add(loc, a, b) : add(loc, b, a);
+            }
+	    }
+
+        for(int i=0;i<n;i++){
+            int a = equations[i][0] - 'a';
+            int b = equations[i][3] - 'a';
+            if(equations[i][1] == '!' && !check(loc, a, b)){
+                return false;
+            }
+        }
+        return true;
+    }
+};

1036.rotting-oranges.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    int orangesRotting(vector<vector<int>>& grid) {
+        bool progress, rot, completed;
+        int ans = 0;
+        while(true){
+            vector<vector<int>> grid2(grid);
+            progress = false;
+            completed = true;
+            for(int i=0;i<grid.size();i++){
+                for(int j=0;j<grid[i].size();j++){
+                    rot = false;
+                    if(grid[i][j] == 1){
+                        completed = false;
+                        rot |= j-1 >= 0 && grid[i][j-1] == 2 ? true: false;
+                        rot |= j+1 < grid[i].size() && grid[i][j+1] == 2 ? true: false;
+                        rot |= i-1 >= 0 && grid[i-1][j] == 2 ? true: false;
+                        rot |= i+1 < grid.size() && grid[i+1][j] == 2 ? true: false;
+                    }
+                    if(rot) grid2[i][j] = 2;
+                    progress |= rot;
+                }
+            }
+            if(!completed && !progress) return -1;
+            if(!progress) break;
+            ans++;
+            grid = grid2;
+        }
+        return ans;
+    }
+};

104.maximum-depth-of-binary-tree.cpp

@@ -1,10 +1,3 @@
-/*
- * @lc app=leetcode id=104 lang=cpp
- *
- * [104] Maximum Depth of Binary Tree
- */
-
-// @lc code=start
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
@@ -20,8 +13,6 @@ class Solution {
 public:
     int maxDepth(TreeNode* root) {
         if(!root) return 0;
-        return 1+max(maxDepth(root->left), maxDepth(root->right));
+        return max(maxDepth(root->left), maxDepth(root->right))+1;
     }
-};
-// @lc code=end
-
+};

108.convert-sorted-array-to-binary-search-tree.cpp

@@ -1,10 +1,3 @@
-/*
- * @lc app=leetcode id=108 lang=cpp
- *
- * [108] Convert Sorted Array to Binary Search Tree
- */
-
-// @lc code=start
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
@@ -31,6 +24,4 @@ class Solution {
         return root;
     }
 
-};
-// @lc code=end
-
+};

11.container-with-most-water.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int l=0, r=height.size()-1;
+        int maxA = 0;
+        while(l<r){
+            maxA = max(maxA, min(height[l], height[r])*abs(l-r));
+            if(height[l] < height[r]){
+                l++;
+            }else{
+                r--;
+            }
+        }
+        return maxA;
+    }
+};

110.balanced-binary-tree.cpp

@@ -1,10 +1,3 @@
-/*
- * @lc app=leetcode id=110 lang=cpp
- *
- * [110] Balanced Binary Tree
- */
-
-// @lc code=start
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
@@ -31,6 +24,4 @@ class Solution {
         if(abs(ldepth-rdepth) > 1) return -1;
         return 1+max(ldepth, rdepth);
     }
-};
-// @lc code=end
-
+};

111.minimum-depth-of-binary-tree.cpp

@@ -1,10 +1,3 @@
-/*
- * @lc app=leetcode id=111 lang=cpp
- *
- * [111] Minimum Depth of Binary Tree
- */
-
-// @lc code=start
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
@@ -25,6 +18,4 @@ class Solution {
         if(!ml || !mr) return max(mr, ml)+1;
         return 1+min(ml, mr);
     }
-};
-// @lc code=end
-
+};

112.path-sum.cpp

@@ -0,0 +1,20 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasPathSum(TreeNode* root, int targetSum) {
+        if(!root) return false;
+        targetSum = targetSum-root->val;
+        if(targetSum==0&&!root->left&&!root->right) return true;
+        return hasPathSum(root->left, targetSum) || hasPathSum(root->right, targetSum);
+    }
+};

1137.height-checker.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int heightChecker(vector<int>& heights) {
+        vector<int> temp(heights);
+        sort(temp.begin(), temp.end());
+        int ans =0;
+        for(int i=0;i<heights.size();i++){
+            if(heights[i]!=temp[i]){
+                ans++;
+            }
+        }
+        return ans;
+    }
+};

1146.greatest-common-divisor-of-strings.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    string gcdOfStrings(string str1, string str2) {
+        while(str1 != str2){
+            int i=0;
+            while(i < min(str1.length(), str2.length()) && str1[i] == str2[i]){
+                i++;
+            }
+            if(i != str1.length() && i != str2.length()) return "";
+
+            if(str1.length() < str2.length()){
+                str2 = str2.substr(i);
+                continue;
+            }
+            if(str1.length() > str2.length()) str1 = str1.substr(i);
+        }
+
+        return str1;
+    }
+};

118.pascals-triangle.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    vector<vector<int>> generate(int numRows) {
+        vector<vector<int>> pascal;
+        pascal.push_back({1});
+        for(int i=0;i<numRows-1;i++){
+            vector<int> row;
+            row.push_back(1);
+            for(int j=0;j<pascal[i].size()-1;j++){
+                row.push_back(pascal[i][j]+pascal[i][j+1]);
+            }
+            row.push_back(1);
+            pascal.push_back(row);
+        }
+        return pascal;
+    }
+};

1187.print-foobar-alternately.cpp

@@ -0,0 +1,32 @@
+class FooBar {
+private:
+    int n;
+    mutex f;
+    mutex b;
+
+public:
+    FooBar(int n) {
+        this->n = n;
+        b.lock();
+    }
+
+    void foo(function<void()> printFoo) {
+
+        for (int i = 0; i < n; i++) {
+            f.lock();
+        	// printFoo() outputs "foo". Do not change or remove this line.
+        	printFoo();
+            b.unlock();
+        }
+    }
+
+    void bar(function<void()> printBar) {
+
+        for (int i = 0; i < n; i++) {
+            b.lock();
+        	// printBar() outputs "bar". Do not change or remove this line.
+            printBar();
+            f.unlock();
+        }
+    }
+};