hyperdrive before interviews

Author: piyushkhemka

Diff for: 153. Find Minimum in Rotated Sorted Array.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int findMin(vector<int>& nums) {
+
+        if(nums.empty())
+            return -1;
+
+        int low = 0;
+        int high = nums.size()-1;
+
+        while(low < high) {
+            int mid = low + (high-low)/2;
+
+            if(nums[low] <= nums[mid] && nums[mid] >= nums[high])
+                low = mid+1;
+
+            else
+                high = mid;
+
+        }
+
+        return nums[low];
+
+    }
+};

Diff for: 209. Minimum Size Subarray Sum.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    int minSubArrayLen(int s, vector<int>& nums) {
+
+        int n = nums.size();
+
+        if(!n)
+            return 0;
+
+        int start = 0;
+        int end = 0;
+        int sum = 0;
+        int minlen = INT_MAX;
+
+        while(start < n) {
+
+            if (sum < s) {
+                sum += nums[start];
+                start++;
+            }
+
+            while (sum >=s) {
+                minlen = min(minlen, start-end);
+                sum -= nums[end];
+                end++;
+            }
+
+        }
+
+        if(minlen == INT_MAX)
+            minlen = 0;
+
+        return minlen;
+
+
+
+    }
+};

Diff for: 252. Meeting Rooms.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for an interval.
+ * struct Interval {
+ *     int start;
+ *     int end;
+ *     Interval() : start(0), end(0) {}
+ *     Interval(int s, int e) : start(s), end(e) {}
+ * };
+ */
+class Solution {
+public:
+    bool canAttendMeetings(vector<Interval>& intervals) {
+
+        if (intervals.empty())
+            return true;
+
+        sort(intervals.begin(), intervals.end(), [] (Interval &i1, Interval &i2 ) { return i1.start < i2.start;});
+
+        for(int i = 0; i<intervals.size()-1; ++i) {
+
+           if(intervals[i].end > intervals[i+1].start)
+                return false;
+
+        }
+
+        return true;
+
+
+    }
+};

Diff for: 285. Inorder Successor in BST.cpp

@@ -0,0 +1,51 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+
+    void succ(TreeNode *root, TreeNode *p, TreeNode* &s) {
+
+        if (!root)
+            return;
+
+        if (p->val < root->val) {
+            s = root;
+            succ(root->left, p, s);
+        }
+
+        else
+            succ(root->right, p, s);
+
+        return;
+    }
+
+
+
+public:
+    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
+
+       TreeNode *s = nullptr;
+
+       if (p->right) {
+
+            s = p->right;
+
+            while (s->left)
+                s = s->left;
+
+            return s;
+        }
+
+       else
+            succ(root, p, s);
+
+       return s;
+
+    }
+};

Diff for: 314. Binary Tree Vertical Order Traversal.cpp

@@ -0,0 +1,52 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+
+public:
+    vector<vector<int>> verticalOrder(TreeNode* root) {
+
+        vector<vector<int> > result;
+
+        if(!root)
+            return result;
+
+        map<int,vector<int> > m;
+
+        queue<pair<TreeNode *,int> > q;
+
+        q.push(make_pair(root, 0));
+
+        while(!q.empty()) {
+
+            auto top = q.front();
+            q.pop();
+
+            if(m.find(top.second) == m.end())
+                m.insert(make_pair(top.second, vector<int> ()));
+
+            m[top.second].push_back(top.first->val);
+
+            if(top.first->left)
+                q.push(make_pair(top.first->left, top.second-1));
+
+            if(top.first->right)
+                q.push(make_pair(top.first->right, top.second+1));
+
+        }
+
+        for(auto vec: m) {
+            result.push_back(vector<int> ());
+            result.back() = vec.second;
+        }
+
+        return result;
+
+    }
+};

Diff for: 325. Maximum Size Subarray Sum Equals k.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    int maxSubArrayLen(vector<int>& nums, int k) {
+
+        unordered_map<int, int> m;
+        int maxlen = 0;
+        int cursum = 0;
+
+        for(int i = 0;i<nums.size();++i) {
+
+            cursum += nums[i];
+
+            if(cursum == k)
+                maxlen = max(maxlen, i+1);
+
+            if (m.find(cursum-k)!=m.end())
+                maxlen = max(maxlen, i-m[cursum-k]);
+
+            else
+                m.insert(make_pair(cursum, i));
+
+        }
+        
+        return maxlen;
+
+
+    }
+};