🚀 09-Oct-2020

Author: sureshmangs

competitive programming/leetcode/1021. Remove Outermost Parentheses.cpp

@@ -0,0 +1,81 @@
+A valid parentheses string is either empty (""), "(" + A + ")", or A + B, where A and B are valid parentheses strings, and + represents string concatenation.  For example, "", "()", "(())()", and "(()(()))" are all valid parentheses strings.
+
+A valid parentheses string S is primitive if it is nonempty, and there does not exist a way to split it into S = A+B, with A and B nonempty valid parentheses strings.
+
+Given a valid parentheses string S, consider its primitive decomposition: S = P_1 + P_2 + ... + P_k, where P_i are primitive valid parentheses strings.
+
+Return S after removing the outermost parentheses of every primitive string in the primitive decomposition of S.
+
+
+
+Example 1:
+
+Input: "(()())(())"
+Output: "()()()"
+Explanation:
+The input string is "(()())(())", with primitive decomposition "(()())" + "(())".
+After removing outer parentheses of each part, this is "()()" + "()" = "()()()".
+Example 2:
+
+Input: "(()())(())(()(()))"
+Output: "()()()()(())"
+Explanation:
+The input string is "(()())(())(()(()))", with primitive decomposition "(()())" + "(())" + "(()(()))".
+After removing outer parentheses of each part, this is "()()" + "()" + "()(())" = "()()()()(())".
+Example 3:
+
+Input: "()()"
+Output: ""
+Explanation:
+The input string is "()()", with primitive decomposition "()" + "()".
+After removing outer parentheses of each part, this is "" + "" = "".
+
+
+Note:
+
+S.length <= 10000
+S[i] is "(" or ")"
+S is a valid parentheses string
+
+
+
+
+
+A valid parentheses string is either empty (""), "(" + A + ")", or A + B, where A and B are valid parentheses strings, and + represents string concatenation.  For example, "", "()", "(())()", and "(()(()))" are all valid parentheses strings.
+
+A valid parentheses string S is primitive if it is nonempty, and there does not exist a way to split it into S = A+B, with A and B nonempty valid parentheses strings.
+
+Given a valid parentheses string S, consider its primitive decomposition: S = P_1 + P_2 + ... + P_k, where P_i are primitive valid parentheses strings.
+
+Return S after removing the outermost parentheses of every primitive string in the primitive decomposition of S.
+
+
+
+Example 1:
+
+Input: "(()())(())"
+Output: "()()()"
+Explanation:
+The input string is "(()())(())", with primitive decomposition "(()())" + "(())".
+After removing outer parentheses of each part, this is "()()" + "()" = "()()()".
+Example 2:
+
+Input: "(()())(())(()(()))"
+Output: "()()()()(())"
+Explanation:
+The input string is "(()())(())(()(()))", with primitive decomposition "(()())" + "(())" + "(()(()))".
+After removing outer parentheses of each part, this is "()()" + "()" + "()(())" = "()()()()(())".
+Example 3:
+
+Input: "()()"
+Output: ""
+Explanation:
+The input string is "()()", with primitive decomposition "()" + "()".
+After removing outer parentheses of each part, this is "" + "" = "".
+
+
+Note:
+
+S.length <= 10000
+S[i] is "(" or ")"
+S is a valid parentheses string

competitive programming/leetcode/1047. Remove All Adjacent Duplicates In String.cpp

@@ -0,0 +1,65 @@
+Given a string S of lowercase letters, a duplicate removal consists of choosing two adjacent and equal letters, and removing them.
+
+We repeatedly make duplicate removals on S until we no longer can.
+
+Return the final string after all such duplicate removals have been made.  It is guaranteed the answer is unique.
+
+
+
+Example 1:
+
+Input: "abbaca"
+Output: "ca"
+Explanation:
+For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move.  The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
+
+
+Note:
+
+1 <= S.length <= 20000
+S consists only of English lowercase letters.
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    string removeDuplicates(string S) {
+        stack<char> s;
+        int n=S.length();
+        s.push(S[0]);
+        for(int i=1;i<n;i++){
+            if(!s.empty() && s.top()==S[i])
+                s.pop();
+            else s.push(S[i]);
+        }
+        string res="";
+
+        while(!s.empty()){
+            res=s.top()+res;
+            s.pop();
+        }
+        return res;
+    }
+};
+
+
+class Solution {
+public:
+    string removeDuplicates(string S) {
+        int k=0, n=S.length();
+        for(int i=0;i<n;i++, k++){
+            S[k]=S[i];
+            if(k>0 && S[k-1]==S[k]) k-=2;
+        }
+        return S.substr(0, k);
+    }
+};

competitive programming/leetcode/1323. Maximum 69 Number.cpp

@@ -0,0 +1,69 @@
+Given a positive integer num consisting only of digits 6 and 9.
+
+Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).
+
+
+
+Example 1:
+
+Input: num = 9669
+Output: 9969
+Explanation:
+Changing the first digit results in 6669.
+Changing the second digit results in 9969.
+Changing the third digit results in 9699.
+Changing the fourth digit results in 9666.
+The maximum number is 9969.
+Example 2:
+
+Input: num = 9996
+Output: 9999
+Explanation: Changing the last digit 6 to 9 results in the maximum number.
+Example 3:
+
+Input: num = 9999
+Output: 9999
+Explanation: It is better not to apply any change.
+
+
+Constraints:
+
+1 <= num <= 10^4
+num's digits are 6 or 9.
+
+
+
+
+
+
+
+class Solution {
+public:
+    int maximum69Number (int num) {
+        string s=to_string(num);
+        for(int i=0;i<s.length();i++){
+            if(s[i]=='6'){
+                s[i]='9';
+                break;
+            }
+        }
+        return stoi(s);
+    }
+};
+
+
+
+
+class Solution {
+public:
+    int maximum69Number (int num) {
+        int tmp=num, i=0, six=-1;
+        while(tmp){
+            if(tmp%10==6) six=i;
+            tmp/=10;
+            i++;
+        }
+
+        return six==-1 ? num : num + 3*pow(10, six);
+    }
+};

competitive programming/leetcode/1441. Build an Array With Stack Operations.cpp

@@ -0,0 +1,70 @@
+Given an array target and an integer n. In each iteration, you will read a number from  list = {1,2,3..., n}.
+
+Build the target array using the following operations:
+
+Push: Read a new element from the beginning list, and push it in the array.
+Pop: delete the last element of the array.
+If the target array is already built, stop reading more elements.
+You are guaranteed that the target array is strictly increasing, only containing numbers between 1 to n inclusive.
+
+Return the operations to build the target array.
+
+You are guaranteed that the answer is unique.
+
+
+
+Example 1:
+
+Input: target = [1,3], n = 3
+Output: ["Push","Push","Pop","Push"]
+Explanation:
+Read number 1 and automatically push in the array -> [1]
+Read number 2 and automatically push in the array then Pop it -> [1]
+Read number 3 and automatically push in the array -> [1,3]
+Example 2:
+
+Input: target = [1,2,3], n = 3
+Output: ["Push","Push","Push"]
+Example 3:
+
+Input: target = [1,2], n = 4
+Output: ["Push","Push"]
+Explanation: You only need to read the first 2 numbers and stop.
+Example 4:
+
+Input: target = [2,3,4], n = 4
+Output: ["Push","Pop","Push","Push","Push"]
+
+
+Constraints:
+
+1 <= target.length <= 100
+1 <= target[i] <= 100
+1 <= n <= 100
+target is strictly increasing.
+
+
+
+
+
+
+class Solution {
+public:
+    vector<string> buildArray(vector<int>& target, int n) {
+        string push="Push", pop="Pop";
+        vector<string> res;
+        int i=1;
+        while(i<=n){
+            for(auto &x: target){
+                while(i<x && i!=x){
+                    res.push_back(push);
+                    res.push_back(pop);
+                    i++;
+                }
+                if(i==x)res.push_back(push);
+                i++;
+            }
+        }
+        return res;
+    }
+};

competitive programming/leetcode/2020-October-Challenge/Day-09-Serialize and Deserialize BST.cpp

@@ -0,0 +1,77 @@
+Serialization is converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
+
+Design an algorithm to serialize and deserialize a binary search tree. There is no restriction on how your serialization/deserialization algorithm should work. You need to ensure that a binary search tree can be serialized to a string, and this string can be deserialized to the original tree structure.
+
+The encoded string should be as compact as possible.
+
+
+
+Example 1:
+
+Input: root = [2,1,3]
+Output: [2,1,3]
+Example 2:
+
+Input: root = []
+Output: []
+
+
+Constraints:
+
+The number of nodes in the tree is in the range [0, 104].
+0 <= Node.val <= 104
+The input tree is guaranteed to be a binary search tree.
+
+
+
+
+
+
+
+
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Codec {
+public:
+
+    TreeNode* deserializeUtil(stringstream &s){
+        string str;
+        getline(s, str, ',');
+        if(str=="#") return NULL;
+        else {
+            TreeNode* root= new TreeNode(stoi(str));
+            root->left=deserializeUtil(s);
+            root->right=deserializeUtil(s);
+            return root;
+        }
+    }
+
+    // Encodes a tree to a single string.
+    string serialize(TreeNode* root) {
+        if(!root) return "#";
+        return to_string(root->val) + "," + serialize(root->left) + "," + serialize(root->right);
+    }
+
+    // Decodes your encoded data to tree.
+    TreeNode* deserialize(string data) {
+        if(data=="#") return NULL;
+        stringstream s(data);
+        return deserializeUtil(s);
+    }
+};
+
+// Your Codec object will be instantiated and called as such:
+// Codec* ser = new Codec();
+// Codec* deser = new Codec();
+// string tree = ser->serialize(root);
+// TreeNode* ans = deser->deserialize(tree);
+// return ans;