Passed coding challenge of WAP R&D engr. position. Preparing for live coding round

Author: kaidul

.DS_Store

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    string convertToBase7(int num) {
+        int sign = (num >= 0) ? 1 : -1;
+        num = abs(num);
+        string result;
+        while(num > 0) {
+            result += to_string(num % 7);
+            num /= 7;
+        }
+        reverse(result.begin(), result.end());
+        if(sign < 0) {
+            result = "-" + result;
+        }
+        if(result.empty()) {
+            result = "0";
+        }
+        return result;
+    }
+};

Base_7.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
+        vector<int> result;
+        int n = matrix.size();
+        if(n == 0) return result;
+        int m = matrix[0].size();
+        if(m == 0) return result;
+        result.resize(m * n);
+        int row = 0, col = 0, d = 0;
+        int dir[2][2] = {{-1, 1}, {1, -1}};
+        
+        for (int i = 0; i < m * n; i++) {
+            result[i] = matrix[row][col];
+            row += dir[d][0];
+            col += dir[d][1];
+            
+            if (row >= n) { row = n - 1; col += 2; d = 1 - d;}
+            if (col >= m) { col = m - 1; row += 2; d = 1 - d;}
+            if (row < 0)  { row = 0; d = 1 - d;}
+            if (col < 0)  { col = 0; d = 1 - d;}
+        }
+        return result;
+    }
+};

Diagonal_Traverse.cpp

@@ -0,0 +1,34 @@
+/**
+ * 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:
+    int findBottomLeftValue(TreeNode* root) {
+        queue<pair<TreeNode*, int>> Q;
+        int currLevel = 1;
+        Q.push({root, currLevel});
+        int leftMost = root->val;
+        while(!Q.empty()) {
+            TreeNode* node = Q.front().first;
+            int level = Q.front().second;
+            Q.pop();
+            if(level > currLevel) {
+                leftMost = node->val;
+                currLevel = level;
+            }
+            if(node->left) {
+                Q.push({node->left, level + 1});
+            }
+            if(node->right) {
+                Q.push({node->right, level + 1});
+            }
+        }
+        return leftMost;
+    }
+};

Find_Bottom_Left_Tree_Value.cpp

@@ -0,0 +1,42 @@
+/**
+ * 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<int> largestValues(TreeNode* root) {
+        vector<int> result;
+        if(!root) return result;
+        queue<pair<TreeNode*, int>> Q;
+        int currLevel = 0;
+        Q.push({root, currLevel});
+        int maxElem = root->val;
+        while(!Q.empty()) {
+            TreeNode* node = Q.front().first;
+            int value = node->val;
+            int level = Q.front().second;
+            if(level > currLevel) {
+                result.push_back(maxElem);
+                currLevel = level;
+                maxElem = value;
+            } else {
+                maxElem = max(maxElem, value);
+            }
+            Q.pop();
+            if(node->left) {
+                Q.push({node->left, level + 1});
+            }
+            if(node->right) {
+                Q.push({node->right, level + 1});    
+            }
+        }
+        result.push_back(maxElem);
+        
+        return result;
+    }
+};

Find_Largest_Value_in_Each_Tree_Row.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    vector<string> findWords(vector<string>& words) {
+        unordered_map<int, int> keyRow;
+        string firstRow = "QWERTYUIOP";
+        for(int i = 0; i < firstRow.length(); i++) {
+            keyRow[firstRow[i]] = 1;    
+        }
+        string secondRow = "ASDFGHJKL";
+        for(int i = 0; i < secondRow.length(); i++) {
+            keyRow[secondRow[i]] = 2;    
+        }
+        string thirdRow = "ZXCVBNM";
+        for(int i = 0; i < thirdRow.length(); i++) {
+            keyRow[thirdRow[i]] = 3;    
+        }
+        vector<string> result;
+        for(int i = 0; i < words.size(); i++) {
+            string word = words[i];
+            unordered_set<int> rows;
+            for(int j = 0; j < (int)word.length(); j++) {
+                rows.insert(keyRow[toupper(word[j])]);
+            }
+            if(rows.size() == 1) {
+                result.push_back(word);
+            }
+        }
+        
+        return result;
+    }
+};

Keyboard_Row.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int longestPalindromeSubseq(string s) {
+        int n = (int)s.length();
+        vector<vector<int>> dp(n, vector<int>(n, 0));
+        for(int i = 0; i < n; i++) {
+            dp[i][i] = 1;
+        }
+        for(int len = 2; len <= n; len++) {
+            for(int i = 0; i < n - len + 1; i++) {
+                int j = i + len - 1;
+                dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
+                if(s[i] == s[j]) {
+                    dp[i][j] = max(dp[i][j], dp[i + 1][j - 1] + 2);
+                }
+            }
+        }
+        
+        return dp[0][n - 1];
+    }
+};

Longest_Palindromic_Subsequence.cpp

@@ -0,0 +1,41 @@
+/**
+ * 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 {
+    int findFrequentTreeSum(TreeNode* root, unordered_map<int, int>& freq) {
+        if(!root) {
+            return 0;
+        }
+        int sum = 0;
+        sum += root->val;
+        sum += findFrequentTreeSum(root->left, freq);
+        sum += findFrequentTreeSum(root->right, freq);
+        
+        freq[sum]++;
+        return sum;
+    }
+    
+public:
+    vector<int> findFrequentTreeSum(TreeNode* root) {
+        vector<int> result;
+        unordered_map<int, int> freq;
+        findFrequentTreeSum(root, freq);
+        int maxFreq = 0;
+        for(auto it = freq.begin(); it != freq.end(); ++it) {
+            maxFreq = max(maxFreq, it->second);
+        }
+        for(auto it = freq.begin(); it != freq.end(); ++it) {
+            if(it->second == maxFreq) {
+                result.push_back(it->first);
+            }
+        }
+        
+        return result;
+    }
+};

Most_Frequent_Subtree_Sum.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    vector<string> findRelativeRanks(vector<int>& nums) {
+        int n = (int)nums.size();
+        vector<pair<int, int>> arr;
+        for(int i = 0; i < n; i++) {
+            arr.push_back({nums[i], i});
+        }
+        sort(arr.begin(), arr.end(), greater<pair<int, int>>());
+        vector<string> result(n);
+        if(arr.size() > 0) {
+            int pos = arr[0].second;
+            result[pos] = "Gold Medal";
+        }
+        if(arr.size() > 1) {
+            int pos = arr[1].second;
+            result[pos] = "Silver Medal";
+        }
+        if(arr.size() > 2) {
+            int pos = arr[2].second;
+            result[pos] = "Bronze Medal";
+        }
+        for(int i = 3; i < n; i++) {
+            int pos = arr[i].second;
+            result[pos] = to_string(i + 1);
+        }
+        
+        return result;
+    }
+};

Relative_Ranks.cpp

@@ -0,0 +1,37 @@
+class Solution {
+    unsigned long long solve(unsigned long long n, int d) {
+        unsigned long long right = (unsigned long long)(pow(n, 1.0 / d) + 1);
+        unsigned long long left = 1ull;
+        while(left <= right) {
+            unsigned long long mid = left + (right - left) / 2;
+            unsigned long long num = 1ull, base = 1ull;
+            for(int i = 0; i < d; i++) {
+                base *= mid;
+                num += base;
+            }
+            if(num == n) {
+                return mid;
+            }
+            if(num < n) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        
+        return -1ull;
+    } 
+public:
+    string smallestGoodBase(string n) {
+        unsigned long long ulln = (unsigned long long)stoll(n);
+        for(int i = 62; i >= 1; i--) {
+            if((1ull << i) < ulln) {
+                unsigned long long curr = solve(ulln, i);
+                if(curr != -1) {
+                    return to_string(curr);
+                }
+            }
+        }
+        return to_string(ulln - 1);
+    }
+};