🚀 03-Sep-2020

Author: sureshmangs

competitive programming/leetcode/1347. Minimum Number of Steps to Make Two Strings Anagram.cpp

@@ -0,0 +1,72 @@
+Given two equal-size strings s and t. In one step you can choose any character of t and replace it with another character.
+
+Return the minimum number of steps to make t an anagram of s.
+
+An Anagram of a string is a string that contains the same characters with a different (or the same) ordering.
+
+
+
+Example 1:
+
+Input: s = "bab", t = "aba"
+Output: 1
+Explanation: Replace the first 'a' in t with b, t = "bba" which is anagram of s.
+Example 2:
+
+Input: s = "leetcode", t = "practice"
+Output: 5
+Explanation: Replace 'p', 'r', 'a', 'i' and 'c' from t with proper characters to make t anagram of s.
+Example 3:
+
+Input: s = "anagram", t = "mangaar"
+Output: 0
+Explanation: "anagram" and "mangaar" are anagrams.
+Example 4:
+
+Input: s = "xxyyzz", t = "xxyyzz"
+Output: 0
+Example 5:
+
+Input: s = "friend", t = "family"
+Output: 4
+
+
+Constraints:
+
+1 <= s.length <= 50000
+s.length == t.length
+s and t contain lower-case English letters only.
+
+
+
+
+
+
+
+
+
+
+// Using hash table
+
+class Solution {
+public:
+    int minSteps(string s, string t) {
+        int slen=s.length();
+        int tlen=t.length();
+
+        vector<int> freq(26, 0);
+
+        for(int i=0;i<slen;i++) freq[s[i]-'a']++;
+
+        int cnt=0;
+
+        for(int i=0;i<tlen;i++){
+            if(freq[t[i]-'a']<=0){
+                cnt++;
+            } else freq[t[i]-'a']--;
+        }
+
+        return cnt;
+
+    }
+};

competitive programming/leetcode/165. Compare Version Numbers.cpp

@@ -0,0 +1,79 @@
+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 version1, string version2) {
+        int n1=version1.length();
+        int n2=version2.length();
+
+        int num1=0, num2=0;
+        int i=0, j=0;
+        while(i<n1 || j<n2){
+            while(i< n1 && version1[i]!='.'){
+                num1=(num1*10)+(version1[i]-'0');
+                i++;
+            }
+            while(j<n2 && version2[j]!='.'){
+                num2=(num2*10)+(version2[j]-'0');
+                j++;
+            }
+
+            if(num1>num2) return 1;
+            if(num1<num2) return -1;
+
+            num1=0;
+            num2=0;
+
+            i++;
+            j++;
+        }
+        return 0;
+    }
+};

competitive programming/leetcode/2020-September-Challenge/Day-02-Contains Duplicate III.cpp

@@ -0,0 +1,47 @@
+Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.
+
+Example 1:
+
+Input: nums = [1,2,3,1], k = 3, t = 0
+Output: true
+Example 2:
+
+Input: nums = [1,0,1,1], k = 1, t = 2
+Output: true
+Example 3:
+
+Input: nums = [1,5,9,1,5,9], k = 2, t = 3
+Output: false
+   Hide Hint #1
+Time complexity O(n logk) - This will give an indication that sorting is involved for k elements.
+   Hide Hint #2
+Use already existing state to evaluate next state - Like, a set of k sorted numbers are only needed to be tracked. When we are processing the next number in array, then we can utilize the existing sorted state and it is not necessary to sort next overlapping set of k numbers again.
+
+
+
+
+
+
+// O(n2)
+
+class Solution {
+public:
+    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
+       vector<vector<int>> v;
+
+        for(int i=0;i<nums.size();i++)
+        {
+            v.push_back({nums[i],i});
+        }
+        sort(v.begin(),v.end());
+        for(int i=0;i<v.size();i++)
+        {
+            for(int j=i+1;j<v.size();j++)
+            {
+                if(v[j][0]>v[i][0]+t) break;
+                if(abs(v[j][1]-v[i][1])<=k) return 1;
+            }
+        }
+        return 0;
+    }
+};

competitive programming/leetcode/220. Contains Duplicate III.cpp

@@ -0,0 +1,47 @@
+Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.
+
+Example 1:
+
+Input: nums = [1,2,3,1], k = 3, t = 0
+Output: true
+Example 2:
+
+Input: nums = [1,0,1,1], k = 1, t = 2
+Output: true
+Example 3:
+
+Input: nums = [1,5,9,1,5,9], k = 2, t = 3
+Output: false
+   Hide Hint #1
+Time complexity O(n logk) - This will give an indication that sorting is involved for k elements.
+   Hide Hint #2
+Use already existing state to evaluate next state - Like, a set of k sorted numbers are only needed to be tracked. When we are processing the next number in array, then we can utilize the existing sorted state and it is not necessary to sort next overlapping set of k numbers again.
+
+
+
+
+
+
+// O(n2)
+
+class Solution {
+public:
+    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
+       vector<vector<int>> v;
+
+        for(int i=0;i<nums.size();i++)
+        {
+            v.push_back({nums[i],i});
+        }
+        sort(v.begin(),v.end());
+        for(int i=0;i<v.size();i++)
+        {
+            for(int j=i+1;j<v.size();j++)
+            {
+                if(v[j][0]>v[i][0]+t) break;
+                if(abs(v[j][1]-v[i][1])<=k) return 1;
+            }
+        }
+        return 0;
+    }
+};

competitive programming/leetcode/242. Valid Anagram.cpp

@@ -0,0 +1,52 @@
+Given two strings s and t , write a function to determine if t is an anagram of s.
+
+Example 1:
+
+Input: s = "anagram", t = "nagaram"
+Output: true
+Example 2:
+
+Input: s = "rat", t = "car"
+Output: false
+Note:
+You may assume the string contains only lowercase alphabets.
+
+Follow up:
+What if the inputs contain unicode characters? How would you adapt your solution to such case?
+
+
+
+
+
+
+
+
+
+// Use hash table
+
+class Solution {
+public:
+    bool isAnagram(string s, string t) {
+        vector<int> freq(256, 0);
+        int tlen=t.length();
+        int slen=s.length();
+
+        if(slen!=tlen) return false;
+
+        for(int i=0;i<tlen;i++)
+            freq[t[i]]++;
+
+        for(int i=0;i<slen;i++){
+            if(freq[s[i]]<=0) return false;
+            freq[s[i]]--;
+        }
+        return true;
+    }
+};
+
+
+
+
+
+// Alter
+// Sorting : Sort the two anagrams and check if they are equal or not O(logN)

competitive programming/leetcode/38. Count and Say.cpp

@@ -0,0 +1,82 @@
+The count-and-say sequence is the sequence of integers with the first five terms as following:
+
+1.     1
+2.     11
+3.     21
+4.     1211
+5.     111221
+1 is read off as "one 1" or 11.
+11 is read off as "two 1s" or 21.
+21 is read off as "one 2, then one 1" or 1211.
+
+Given an integer n where 1 ≤ n ≤ 30, generate the nth term of the count-and-say sequence.
+You can do so recursively, in other words from the previous member read off the digits,
+counting the number of digits in groups of the same digit.
+
+Note: Each term of the sequence of integers will be represented as a string.
+
+
+
+Example 1:
+
+Input: 1
+Output: "1"
+Explanation: This is the base case.
+Example 2:
+
+Input: 4
+Output: "1211"
+Explanation: For n = 3 the term was "21" in which we have two groups "2" and "1", "2" can be read as "12"
+which means frequency = 1 and value = 2, the same way "1" is read as "11",
+so the answer is the concatenation of "12" and "11" which is "1211".
+
+
+
+
+
+
+
+
+// Iterative
+
+class Solution {
+public:
+    string countAndSay(int n) {
+        if(n == 0) return "";
+        string res = "1";
+        while (--n) {
+            string cur="";
+            for (int i = 0; i < res.size(); i++) {
+                int count = 1;
+                 while ((i + 1 < res.size()) && (res[i] == res[i + 1])){
+                    count++;
+                    i++;
+                }
+                cur += to_string(count) + res[i];
+            }
+            res = cur;
+        }
+        return res;
+    }
+};
+
+
+
+// Recursive
+
+class Solution {
+public:
+    string countAndSay(int n) {
+        if(n == 1) return "1";
+        if(n == 2)  return "11";
+        string s = countAndSay(n-1), res = "";
+        int i = 0;
+        while(i < s.size()) {
+            int j = i;
+            while(j < s.size() and s[j] == s[i]) j++;
+            res += to_string(j - i) + s[i];
+            i = j;
+        }
+        return res;
+    }
+};