Bloomberg onsite ahead. Solved all problems asked in Bloomberg

Author: kaidul

README.md

@@ -0,0 +1,49 @@
+/**
+ * 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 {
+    vector<TreeNode*> allPossibleFBT(int n, vector<TreeNode*>& result) {
+        if(n == 0) {
+            result.push_back(nullptr);
+            return result;
+        }
+        if(n % 2 == 0) {
+            return vector<TreeNode*>();
+        }
+        for(int i = 1; i <= n; i++) {
+            int leftTreeNodeCount = i - 1;
+            int rightTreeNodeCount = n - i;
+            
+            vector<TreeNode*> leftSubTrees;
+            allPossibleFBT(leftTreeNodeCount, leftSubTrees);
+            
+            vector<TreeNode*> rightSubTrees;
+            allPossibleFBT(rightTreeNodeCount, rightSubTrees);
+            
+            for(TreeNode* leftSubTree : leftSubTrees) {
+                for(TreeNode* rightSubTree : rightSubTrees) {
+                    TreeNode* root = new TreeNode(0);
+                    root->left = leftSubTree;
+                    root->right = rightSubTree;
+            
+                    result.push_back(root);
+                }
+            }
+            
+        }
+        return result;
+    }
+    
+public:
+    vector<TreeNode*> allPossibleFBT(int N) {
+        vector<TreeNode*> result;
+        allPossibleFBT(N, result);
+        return result;
+    }
+};

source-code/All_Possible_Full_Binary_Trees.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    vector<int> dailyTemperatures(vector<int>& temperatures) {
+        int n = temperatures.size();
+        vector<int> result(n);
+        stack<int> indexStack;
+        indexStack.push(0);
+        for(int i = 1; i < n; i++) {
+            if(temperatures[i] > temperatures[i - 1]) {
+                while(!indexStack.empty() and temperatures[indexStack.top()] < temperatures[i]) {
+                    int indx = indexStack.top();
+                    result[indx] = i - indx;
+                    indexStack.pop();
+                }
+            }
+            indexStack.push(i);
+        }
+        while(!indexStack.empty()) {
+            int indx = indexStack.top();
+            result[indx] = 0;
+            indexStack.pop();
+        }
+        
+        return result;
+    }
+};

source-code/Daily_Temperatures.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int pivotIndex(vector<int>& nums) {
+        if(nums.empty())
+            return -1;
+        
+        int n = (int) nums.size();
+        vector<int> suffixSum(n + 1, 0);
+        suffixSum[n - 1] = nums[n - 1];
+        for(int i = n - 2; i >= 0; i--) {
+            suffixSum[i] = nums[i] + suffixSum[i + 1];
+        }
+        int prefixSum = 0;
+        for(int i = 0; i < n; i++) {
+            if(prefixSum == suffixSum[i + 1]) {
+                return i;
+            }
+            prefixSum += nums[i];
+        }
+        
+        return -1;
+    }
+};

source-code/Find_Pivot_Index.cpp

@@ -0,0 +1,33 @@
+class Solution {
+    bool isSpecialEquivalent(string const& s, string const& t) {
+        int freqOdd[26] = {0}, freqEven[26] = {0};
+        for(int i = 0; i < s.length(); i++) {
+            if(i & 1) {
+                freqEven[s[i] - 'a']++;
+                freqEven[t[i] - 'a']--; 
+            } else {
+                freqOdd[s[i] - 'a']++;
+                freqOdd[t[i] - 'a']--;
+            }
+        }
+        for(int i = 0; i < 26; i++) {
+            if(freqEven[i] < 0 or freqOdd[i] < 0) return false;
+        }
+        return true;
+    }
+public:
+    int numSpecialEquivGroups(vector<string>& A) {
+        int groupCount = 0;
+        vector<bool> isGrouped(A.size(), false);
+        for(int i = 0; i < (int)A.size(); i++) {
+            if(isGrouped[i]) continue;
+            groupCount++;
+            for(int k = i + 1; k < (int)A.size(); k++) {
+                if(isSpecialEquivalent(A[i], A[k])) {
+                    isGrouped[k] = true;
+                }
+            }
+        }
+        return groupCount;
+    }
+};

source-code/Groups_of_Special-Equivalent_Strings.cpp

@@ -0,0 +1,33 @@
+/**
+ * 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 increasingBSTRecur(TreeNode* root, TreeNode*& parent, TreeNode*& newRoot) {
+        if(!root) return;
+        
+        increasingBSTRecur(root->left, parent, newRoot);
+        
+        if(!newRoot) {
+            newRoot = root;
+        }
+        root->left = nullptr;
+        if(parent) parent->right = root;
+        parent = root;
+        
+        increasingBSTRecur(root->right, parent, newRoot);
+    }
+public:
+    TreeNode* increasingBST(TreeNode* root) {
+        TreeNode* newRoot = nullptr;
+        TreeNode* parent = nullptr;
+        increasingBSTRecur(root, parent, newRoot);
+        
+        return newRoot;
+    }
+};

source-code/Increasing_Order_Search_Tree.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    bool isMonotonic(vector<int>& A) {
+        bool isDecreasing = true;
+        for(int i = 0; i < A.size() - 1; i++) {
+            if(A[i] < A[i + 1]) {
+                isDecreasing = false;
+                break;
+            }
+        }
+        if(isDecreasing)
+            return true;
+        
+        bool isIncreasing = true;
+        for(int i = 0; i < A.size() - 1; i++) {
+            if(A[i] > A[i + 1]) {
+                isIncreasing = false;
+                break;
+            }
+        }
+        if(isIncreasing)
+            return true;
+        
+        return false;
+        
+    }
+};

source-code/Monotonic_Array.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    bool isRectangleOverlap(vector<int>& rec1, vector<int>& rec2) {
+        int x11 = rec1[0], y11 = rec1[1];
+        int x12 = rec1[2], y12 = rec1[3];
+        
+        int x21 = rec2[0], y21 = rec2[1];
+        int x22 = rec2[2], y22 = rec2[3];
+        
+        return x11 < x22 and x21 < x12 and y11 < y22 and y21 < y12;
+    }
+};

source-code/Rectangle_Overlap.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    bool rotateString(string A, string B) {
+        if(A.length() != B.length())
+            return false;
+        if(A.empty())
+            return true;
+        int n = A.length();
+        for(int i = 0; i < n; i++) {
+            bool flag = true;
+            for(int k = 0, j = i; k < n and flag; j++, k++) {
+                int indx = j % n;
+                if(A[k] != B[indx]) {
+                    flag = false;
+                }
+            }
+            if(flag) return true;
+        }
+        return false;
+    }
+};

source-code/Rotate_String.cpp

@@ -9,21 +9,9 @@
  */
 class Solution {
 public:
-    bool isSameTree(TreeNode *p, TreeNode *q) {
+    bool isSameTree(TreeNode* p, TreeNode* q) {
         if(!p and !q) return true;
         if((!p and q) or (p and !q)) return false;
-        /*
-        if((p and !p->left and !p->right) and (q and !q->left and !q->right))
-            if(p->val == q->val)
-                return true;
-            else 
-                return false;
-        if(p->val == q->val) {
-            return isSameTree(p->left, q->left) and isSameTree(p->right, q->right);
-        } else
-            return false;
-        */
-        if(p->val != q->val) return false;
-        return isSameTree(p->left, q->left) and isSameTree(p->right, q->right); 
+        return p->val == q->val and isSameTree(p->left, q->left) and isSameTree(p->right, q->right);
     }
 };

source-code/Same_Tree.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    vector<int> shortestToChar(string S, char C) {
+        int latestPositionOfC = INT_MAX;
+        vector<int> result(S.length(), INT_MAX);
+        for(int i = 0; i < S.length(); i++) {
+            if(S[i] == C) { 
+                latestPositionOfC = i;
+            }
+            if(latestPositionOfC != INT_MAX) {
+                result[i] = i - latestPositionOfC;
+            }
+        }
+        latestPositionOfC = INT_MAX;
+        for(int i = S.length() - 1; i >= 0; i--) {
+            if(S[i] == C) { 
+                latestPositionOfC = i;
+            }
+            if(latestPositionOfC != INT_MAX) {
+                result[i] = min(result[i], latestPositionOfC - i);
+            }
+        }
+        
+        return result;
+    }
+};

source-code/Shortest_Distance_to_a_Character.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
+        if(nums.empty())
+            return 0;
+        int result = 0;
+        int product = 1;
+        int left = 0, right = 0;
+        while(right < nums.size()) {
+            product *= nums[right];
+            while(left <= right and product >= k) {
+                product /= nums[left++];
+            }
+            result += (right - left + 1);
+            right++;
+        }
+        
+        return result;
+    }
+};

source-code/Subarray_Product_Less_Than_K.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    vector<string> subdomainVisits(vector<string>& cpdomains) {
+        unordered_map<string, int> visitFreq;
+        for(string cpDomain : cpdomains) {
+            int spacePos = cpDomain.find(" ");
+            int noOfVisit = atoi(cpDomain.substr(0, spacePos).c_str());
+            string domain = cpDomain.substr(spacePos + 1);
+            vector<string> subDomains;
+            while(true) {
+                subDomains.push_back(domain);
+                int dotPos = domain.find(".");
+                if(dotPos == string::npos) {
+                    dotPos = domain.length();
+                    break;
+                }
+                domain = domain.substr(dotPos + 1);
+            }
+            for(string subDomain : subDomains) {
+                visitFreq[subDomain] += noOfVisit;
+            }
+        }
+        vector<string> result;
+        for(auto entry : visitFreq) {
+            result.push_back(to_string(entry.second) + " " + entry.first);
+        }
+        
+        return result;
+    }
+};