🚀 11-Aug-2020

Author: sureshmangs

.gitignore

@@ -1,2 +1,5 @@
 temporary/
-Notes.md
+Notes.md
+.cph
+.vscode
+Personal.cpp

competitive programming/leetcode/1221. Split a String in Balanced Strings.cpp

@@ -0,0 +1,58 @@
+Balanced strings are those who have equal quantity of 'L' and 'R' characters.
+
+Given a balanced string s split it in the maximum amount of balanced strings.
+
+Return the maximum amount of splitted balanced strings.
+
+
+
+Example 1:
+
+Input: s = "RLRRLLRLRL"
+Output: 4
+Explanation: s can be split into "RL", "RRLL", "RL", "RL", each substring contains same number of 'L' and 'R'.
+Example 2:
+
+Input: s = "RLLLLRRRLR"
+Output: 3
+Explanation: s can be split into "RL", "LLLRRR", "LR", each substring contains same number of 'L' and 'R'.
+Example 3:
+
+Input: s = "LLLLRRRR"
+Output: 1
+Explanation: s can be split into "LLLLRRRR".
+Example 4:
+
+Input: s = "RLRRRLLRLL"
+Output: 2
+Explanation: s can be split into "RL", "RRRLLRLL", since each substring contains an equal number of 'L' and 'R'
+
+
+Constraints:
+
+1 <= s.length <= 1000
+s[i] = 'L' or 'R'
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int balancedStringSplit(string s) {
+        int n=s.length();
+        int cnt=0, tmp=0;
+        for(int i=0;i<n;i++){
+            if(s[i]=='L') tmp-=1;
+            else if(s[i]=='R') tmp+=1;
+            if(tmp==0) cnt++;
+        }
+        return cnt;
+    }
+};

competitive programming/leetcode/1309. Decrypt String from Alphabet to Integer Mapping.cpp

@@ -0,0 +1,61 @@
+Given a string s formed by digits ('0' - '9') and '#' . We want to map s to English lowercase characters as follows:
+
+Characters ('a' to 'i') are represented by ('1' to '9') respectively.
+Characters ('j' to 'z') are represented by ('10#' to '26#') respectively.
+Return the string formed after mapping.
+
+It's guaranteed that a unique mapping will always exist.
+
+
+
+Example 1:
+
+Input: s = "10#11#12"
+Output: "jkab"
+Explanation: "j" -> "10#" , "k" -> "11#" , "a" -> "1" , "b" -> "2".
+Example 2:
+
+Input: s = "1326#"
+Output: "acz"
+Example 3:
+
+Input: s = "25#"
+Output: "y"
+Example 4:
+
+Input: s = "12345678910#11#12#13#14#15#16#17#18#19#20#21#22#23#24#25#26#"
+Output: "abcdefghijklmnopqrstuvwxyz"
+
+
+Constraints:
+
+1 <= s.length <= 1000
+s[i] only contains digits letters ('0'-'9') and '#' letter.
+s will be valid string such that mapping is always possible.
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    string freqAlphabets(string s) {
+        string res;
+        int n=s.length();
+        for(int i=n-1;i>=0;i--){
+            if(s[i]=='#'){
+                int index=(s[i-2]-'0')*10 + s[i-1]-'0';
+                res+=char('a'-1+index);
+                i-=2; // moving two steps
+            } else{
+                res+=char('a'-1+s[i]-'0');  // -1 as 'a' starts from 1 and not zero
+            }
+        }
+        reverse(res.begin(), res.end());
+        return res;
+    }
+};

competitive programming/leetcode/1370. Increasing Decreasing String.cpp

@@ -0,0 +1,92 @@
+Given a string s. You should re-order the string using the following algorithm:
+
+Pick the smallest character from s and append it to the result.
+Pick the smallest character from s which is greater than the last appended character to the result and append it.
+Repeat step 2 until you cannot pick more characters.
+Pick the largest character from s and append it to the result.
+Pick the largest character from s which is smaller than the last appended character to the result and append it.
+Repeat step 5 until you cannot pick more characters.
+Repeat the steps from 1 to 6 until you pick all characters from s.
+In each step, If the smallest or the largest character appears more than once you can choose any occurrence and append it to the result.
+
+Return the result string after sorting s with this algorithm.
+
+
+
+Example 1:
+
+Input: s = "aaaabbbbcccc"
+Output: "abccbaabccba"
+Explanation: After steps 1, 2 and 3 of the first iteration, result = "abc"
+After steps 4, 5 and 6 of the first iteration, result = "abccba"
+First iteration is done. Now s = "aabbcc" and we go back to step 1
+After steps 1, 2 and 3 of the second iteration, result = "abccbaabc"
+After steps 4, 5 and 6 of the second iteration, result = "abccbaabccba"
+Example 2:
+
+Input: s = "rat"
+Output: "art"
+Explanation: The word "rat" becomes "art" after re-ordering it with the mentioned algorithm.
+Example 3:
+
+Input: s = "leetcode"
+Output: "cdelotee"
+Example 4:
+
+Input: s = "ggggggg"
+Output: "ggggggg"
+Example 5:
+
+Input: s = "spo"
+Output: "ops"
+
+
+Constraints:
+
+1 <= s.length <= 500
+s contains only lower-case English letters.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    string sortString(string s) {
+        string res;
+        int freq[26];
+        int n=s.length();
+        fill(freq, freq+26, 0);
+
+        for(int i=0;i<n;i++){
+            freq[s[i]-'a']++;
+        }
+
+        while(n){
+            for(int i=0;i<26;i++){
+                if(freq[i]>0){
+                    res+=char('a'+i);
+                    freq[i]--;
+                    n--;
+                }
+            }
+            for(int i=25;i>=0;i--){
+                if(freq[i]>0){
+                    res+=char('a'+i);
+                    freq[i]--;
+                    n--;
+                }
+            }
+        }
+        return res;
+    }
+};

competitive programming/leetcode/1374. Generate a String With Characters That Have Odd Counts.cpp

@@ -0,0 +1,53 @@
+Share
+Given an integer n, return a string with n characters such that each character in such string occurs an odd number of times.
+
+The returned string must contain only lowercase English letters. If there are multiples valid strings, return any of them.
+
+
+
+Example 1:
+
+Input: n = 4
+Output: "pppz"
+Explanation: "pppz" is a valid string since the character 'p' occurs three times and the character 'z' occurs once. Note that there are many other valid strings such as "ohhh" and "love".
+Example 2:
+
+Input: n = 2
+Output: "xy"
+Explanation: "xy" is a valid string since the characters 'x' and 'y' occur once. Note that there are many other valid strings such as "ag" and "ur".
+Example 3:
+
+Input: n = 7
+Output: "holasss"
+
+
+Constraints:
+
+1 <= n <= 500
+
+
+
+
+
+
+
+class Solution {
+public:
+    string generateTheString(int n) {
+        // Just going to use 'a' and 'b' in the string
+        string res;
+        if(n%2==0){
+            for(int i=0;i<n-1;i++)
+                res+='a';
+            res+='b';
+        } else {
+            for(int i=0;i<n;i++)
+                 res+='a';
+        }
+        return res;
+    }
+};
+
+
+// if n is odd then 'a' will be added odd times
+// if n is even then we add 1 'b' and n-1 becomes odd, so we add 'a' n-1 times

competitive programming/leetcode/1436. Destination City.cpp

@@ -0,0 +1,63 @@
+You are given the array paths, where paths[i] = [cityAi, cityBi] means there exists a direct path going from cityAi to cityBi. Return the destination city, that is, the city without any path outgoing to another city.
+
+It is guaranteed that the graph of paths forms a line without any loop, therefore, there will be exactly one destination city.
+
+
+
+Example 1:
+
+Input: paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
+Output: "Sao Paulo"
+Explanation: Starting at "London" city you will reach "Sao Paulo" city which is the destination city. Your trip consist of: "London" -> "New York" -> "Lima" -> "Sao Paulo".
+Example 2:
+
+Input: paths = [["B","C"],["D","B"],["C","A"]]
+Output: "A"
+Explanation: All possible trips are:
+"D" -> "B" -> "C" -> "A".
+"B" -> "C" -> "A".
+"C" -> "A".
+"A".
+Clearly the destination city is "A".
+Example 3:
+
+Input: paths = [["A","Z"]]
+Output: "Z"
+
+
+Constraints:
+
+1 <= paths.length <= 100
+paths[i].length == 2
+1 <= cityAi.length, cityBi.length <= 10
+cityAi != cityBi
+All strings consist of lowercase and uppercase English letters and the space character.
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    string destCity(vector<vector<string>>& paths) {
+        int n=paths.size();
+        unordered_map<string, string> mp;     // <cityA, cityB>
+        for(int i=0;i<n;i++){
+            mp.insert({paths[i][0], paths[i][1]});
+        }
+        string src=paths[0][0], dst="";
+        while(1){
+            if(mp.find(src)!=mp.end()){
+                dst=mp[src];
+                src=dst;
+            } else break;
+        }
+        return dst;
+    }
+};

competitive programming/leetcode/557. Reverse Words in a String III.cpp

@@ -0,0 +1,37 @@
+Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.
+
+Example 1:
+Input: "Let's take LeetCode contest"
+Output: "s'teL ekat edoCteeL tsetnoc"
+Note: In the string, each word is separated by single space and there will not be any extra space in the string.
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    string reverseWords(string s) {
+        int n=s.length();
+        string res, tmp;
+        for(int i=0;i<n;i++){
+            if(s[i]==' '){
+                res+=tmp+ ' ';
+                tmp="";
+                continue;
+            }
+            tmp=s[i]+tmp;
+        }
+        res+=tmp;  // adding tmp again as we don't have space in the end
+        return res;
+    }
+};
+
+
+
+
+// Alter
+// We can also use stack