🚀 09-Sep-2020

Author: sureshmangs

competitive programming/cses/Introductory Problems/Weird Algorithm.cpp

@@ -0,0 +1,6 @@
+#include<bits/stdc++.h>
+using namesapce std;
+
+int main(){
+
+}

competitive programming/leetcode/1022. Sum of Root To Leaf Binary Numbers.cpp

@@ -0,0 +1,74 @@
+Given a binary tree, each node has value 0 or 1.
+Each root-to-leaf path represents a binary number starting with the most significant bit.
+For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13.
+
+For all leaves in the tree, consider the numbers represented by the path from the root to that leaf.
+
+Return the sum of these numbers.
+
+
+
+Example 1:
+
+
+
+Input: [1,0,1,0,1,0,1]
+Output: 22
+Explanation: (100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
+
+
+Note:
+
+The number of nodes in the tree is between 1 and 1000.
+node.val is 0 or 1.
+The answer will not exceed 2^31 - 1.
+   Hide Hint #1
+Find each path, then transform that path to an integer in base 10.
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * 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:
+
+    void solve(TreeNode* root, int num, int &sum){
+        if(!root) return;
+
+        num=2 * num + root->val;
+
+        solve(root->left, num, sum);
+        solve(root->right, num, sum);
+
+        if(!root->left && !root->right)
+            sum+=num;
+
+
+
+    }
+
+    int sumRootToLeaf(TreeNode* root) {
+        int sum=0;
+        if(!root) return 0;
+        solve(root, 0, sum);  // <root, decimal number, sum>
+
+        return sum;
+    }
+};

competitive programming/leetcode/2020-September-Challenge/Day-08-Sum of Root To Leaf Binary Numbers.cpp

@@ -0,0 +1,74 @@
+Given a binary tree, each node has value 0 or 1.
+Each root-to-leaf path represents a binary number starting with the most significant bit.
+For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13.
+
+For all leaves in the tree, consider the numbers represented by the path from the root to that leaf.
+
+Return the sum of these numbers.
+
+
+
+Example 1:
+
+
+
+Input: [1,0,1,0,1,0,1]
+Output: 22
+Explanation: (100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
+
+
+Note:
+
+The number of nodes in the tree is between 1 and 1000.
+node.val is 0 or 1.
+The answer will not exceed 2^31 - 1.
+   Hide Hint #1
+Find each path, then transform that path to an integer in base 10.
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * 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:
+
+    void solve(TreeNode* root, int num, int &sum){
+        if(!root) return;
+
+        num=2 * num + root->val;
+
+        solve(root->left, num, sum);
+        solve(root->right, num, sum);
+
+        if(!root->left && !root->right)
+            sum+=num;
+
+
+
+    }
+
+    int sumRootToLeaf(TreeNode* root) {
+        int sum=0;
+        if(!root) return 0;
+        solve(root, 0, sum);  // <root, decimal number, sum>
+
+        return sum;
+    }
+};

competitive programming/leetcode/2020-September-Challenge/Day-09-Compare Version Numbers.cpp

@@ -0,0 +1,75 @@
+Compare two version numbers version1 and version2.
+If version1 > version2 return 1; if version1 < version2 return -1;otherwise return 0.
+
+You may assume that the version strings are non-empty and contain only digits and the . character.
+
+The . character does not represent a decimal point and is used to separate number sequences.
+
+For instance, 2.5 is not "two and a half" or "half way to version three", it is the fifth second-level revision of the second first-level revision.
+
+You may assume the default revision number for each level of a version number to be 0. For example, version number 3.4 has a revision number of 3 and 4 for its first and second level revision number. Its third and fourth level revision number are both 0.
+
+
+
+Example 1:
+
+Input: version1 = "0.1", version2 = "1.1"
+Output: -1
+Example 2:
+
+Input: version1 = "1.0.1", version2 = "1"
+Output: 1
+Example 3:
+
+Input: version1 = "7.5.2.4", version2 = "7.5.3"
+Output: -1
+Example 4:
+
+Input: version1 = "1.01", version2 = "1.001"
+Output: 0
+Explanation: Ignoring leading zeroes, both “01” and “001" represent the same number “1”
+Example 5:
+
+Input: version1 = "1.0", version2 = "1.0.0"
+Output: 0
+Explanation: The first version number does not have a third level revision number, which means its third level revision number is default to "0"
+
+
+Note:
+
+Version strings are composed of numeric strings separated by dots . and this numeric strings may have leading zeroes.
+Version strings do not start or end with dots, and they will not be two consecutive dots.
+
+
+
+
+
+
+class Solution {
+public:
+    int compareVersion(string ver1, string ver2) {
+        int n1=ver1.length();
+        int n2=ver2.length();
+
+        int i=0, j=0;
+
+        while(i<n1 || j<n2){
+            int num1=0, num2=0;
+            while(i<n1 && ver1[i]!='.'){
+                num1=(num1*10)+(ver1[i]-'0');
+                i++;
+            }
+            while(j<n2 && ver2[j]!='.'){
+                num2=(num2*10)+(ver2[j]-'0');
+                j++;
+            }
+
+            if(num1>num2) return 1;
+            if(num1<num2) return -1;
+
+            i++;
+            j++;
+        }
+        return 0;
+    }
+};