Careem 2nd Phone interview successfully completed. Stood 16th in Topcoder SRM 722 division two with 3 problems solved and 3 successful challenges.

Author: kaidul

README.md

@@ -28,6 +28,10 @@ int main(void) {
             }
             filename[n] = '\0';
             string sFileName = string(filename);
+            // ignoring Mac's .DS_Store
+            if(sFileName == ".DS_Store") {
+		continue;
+	    }
             int dot = sFileName.find('.');
             assert(dot != string::npos);
             sFileName = sFileName.substr(0, dot); // trimming extension

readme-generator.cpp

@@ -0,0 +1,45 @@
+/**
+ * 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<double> averageOfLevels(TreeNode* root) {
+        vector<double> result;
+        if(!root) {
+            return result;
+        }
+        unordered_map<int, long long> sum;
+        unordered_map<int, int> nodeCount;
+        queue<pair<TreeNode*, int>> Q;
+        int level = 0;
+        Q.push({root, level});
+        while(!Q.empty()) {
+            TreeNode* curr = Q.front().first;
+            int currLevel = Q.front().second;
+            Q.pop();
+            if(currLevel > level) {
+                double avg = (double) sum[level] / nodeCount[level];
+                result.push_back(avg);
+                level = currLevel;
+            }
+            sum[level] += curr->val;
+            nodeCount[level]++;
+            if(curr->left) {
+               Q.push({curr->left, currLevel + 1}); 
+            }
+            if(curr->right) {
+               Q.push({curr->right, currLevel + 1}); 
+            }
+        }
+        double avg = (double) sum[level] / nodeCount[level];
+        result.push_back(avg);
+
+        return result;
+    }
+};

source-code/Average_of_Levels_in_Binary_Tree.cpp

@@ -26,17 +26,17 @@ class Solution {
         return -1;
     }
     */
-    int jump(int A[], int n) {
+
+    int jump(vector<int>& A) {
+        int n = (int)A.size();
         if(n < 2) return 0;
-        int curr = 0;
         int steps = 0;
         for(int i = 0; i < n; ) {
-            curr = max(curr, A[i] + i);
-            if (curr > 0) steps++;
-
-            if (curr >= n - 1) return steps;
+            int maxDistance = A[i] + i;
+            steps++;
+            if (maxDistance >= n - 1) return steps;
             int tmp = 0;
-            for (int j = i + 1; j <= curr; j++) {
+            for (int j = i + 1; j <= maxDistance; j++) {
                 if (j + A[j] > tmp) {
                     tmp = A[j] + j;
                     i = j;

source-code/Jump_Game_II.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int maximumProduct(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        int n = (int)nums.size();
+        int X = nums[n - 1] * nums[n - 2] * nums[n - 3];
+        int Y = nums[0] * nums[1] * nums[n - 1];
+        return max(X, Y);
+    }
+};

source-code/Maximum_Product_of_Three_Numbers.cpp

@@ -2,12 +2,12 @@ class Solution {
 public:
     int removeDuplicates(vector<int>& nums) {
         if(nums.size() <= 2) return nums.size();
-        int len = 2;
+        int k = 1;
         for(int i = 2; i < nums.size(); i++) {
-            if(nums[len - 2] < nums[i]) {
-                nums[len++] = nums[i];
+            if(nums[i] != nums[k - 1]) {
+                nums[++k] = nums[i];
             }
         }
-        return len;
+        return k + 1;
     }
 };

source-code/Remove_Duplicates_from_Sorted_Array_II.cpp

@@ -7,6 +7,7 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
+// using level order traversal
 class Solution {
 public:
     bool isPalindrome(vector<int> &container) {
@@ -51,4 +52,21 @@ class Solution {
         }
         return true;
     }
+};
+
+// using recursion
+class Solution {
+    bool isSymmetric(TreeNode* root1, TreeNode* root2) {
+        if(!root1 and !root2) {
+            return true;
+        }
+        if(!root1 or !root2) {
+            return false;
+        }
+        return root1->val == root2->val and isSymmetric(root1->left, root2->right) and isSymmetric(root1->right, root2->left);
+    }
+public:
+    bool isSymmetric(TreeNode* root) {
+        return isSymmetric(root, root);
+    }
 };

source-code/Symmetric_Tree.cpp

@@ -1,5 +1,4 @@
 class Solution {
-    // AC :) did pruning as much as I can, but still very laggy in cpu time graph
     bool isMatchRecur(string const& txt, int p, string const& pattern, int q, vector<vector<bool>>& visited, vector<vector<bool>>& dp) {
         if(p == txt.length() and q == pattern.length()) return true;
         if(q == pattern.length()) return false; 
@@ -18,7 +17,7 @@ class Solution {
         if(pattern[q] == '?') {
             return dp[p][q] = isMatchRecur(txt, p + 1, pattern, q + 1, visited, dp);
         } else if(pattern[q] == '*') {
-            for(int i = 0; i <= txt.length(); ++i) {
+            for(int i = 0; i <= txt.length() - p; ++i) {
                 if(isMatchRecur(txt, p + i, pattern, q + 1, visited, dp)) {
                     return dp[p][q] = true;
                 }