🚀 07-Oct-2020

Author: sureshmangs

competitive programming/leetcode/1009. Complement of Base 10 Integer.cpp

@@ -47,3 +47,47 @@ class Solution {
         return N ^ tmp;
     }
 };
+
+
+
+
+// num + comlement = all onesa
+
+class Solution {
+public:
+    int bitwiseComplement(int n) {
+        if(n==0) return 1;
+        int digits=log2(n)+1;
+        return pow(2, digits)-1-n;
+    }
+};
+
+
+
+
+
+class Solution {
+public:
+    int bitwiseComplement(int n) {
+        if(n==0) return 1;
+        string binary;
+        while(n){
+            binary+=to_string(n%2);
+            n/=2;
+        }
+        int len=binary.length();
+
+        for(int i=0;i<len;i++){
+            if(binary[i]=='0') binary[i]='1';
+            else binary[i]='0';
+        }
+
+        int res=0;
+
+        for(int i=0;i<len;i++){
+            res+=pow(2, i)*(binary[i]-'0');
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/1170. Compare Strings by Frequency of the Smallest Character.cpp

@@ -0,0 +1,81 @@
+Let's define a function f(s) over a non-empty string s, which calculates the frequency of the smallest character in s. For example, if s = "dcce" then f(s) = 2 because the smallest character is "c" and its frequency is 2.
+
+Now, given string arrays queries and words, return an integer array answer, where each answer[i] is the number of words such that f(queries[i]) < f(W), where W is a word in words.
+
+
+
+Example 1:
+
+Input: queries = ["cbd"], words = ["zaaaz"]
+Output: [1]
+Explanation: On the first query we have f("cbd") = 1, f("zaaaz") = 3 so f("cbd") < f("zaaaz").
+Example 2:
+
+Input: queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
+Output: [1,2]
+Explanation: On the first query only f("bbb") < f("aaaa"). On the second query both f("aaa") and f("aaaa") are both > f("cc").
+
+
+Constraints:
+
+1 <= queries.length <= 2000
+1 <= words.length <= 2000
+1 <= queries[i].length, words[i].length <= 10
+queries[i][j], words[i][j] are English lowercase letters.
+
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> numSmallerByFrequency(vector<string>& queries, vector<string>& words) {
+        vector<int> res;
+
+        vector<int> wordFreq;
+
+        for(auto word: words){
+            vector<int> freq(26, 0);
+            for(int i=0;i<word.length();i++){
+                freq[word[i]-'a']++;
+            }
+            for(int i=0;i<26;i++){
+                if(freq[i]>0){
+                    wordFreq.push_back(freq[i]);
+                    break;
+                }
+            }
+        }
+
+        for(auto query: queries){
+            vector<int> freq(26, 0);
+            for(int i=0;i<query.length();i++){
+                freq[query[i]-'a']++;
+            }
+            int tmp=0, mini=0;
+            for(int i=0;i<26;i++){
+                if(freq[i]>0){
+                   mini=freq[i];
+                    break;
+                }
+            }
+            int cnt=0;
+
+            for(int i=0;i<wordFreq.size();i++){
+                if(mini<wordFreq[i])
+                    cnt++;
+            }
+
+            res.push_back(cnt);
+
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/1189. Maximum Number of Balloons.cpp

@@ -0,0 +1,89 @@
+Given a string text, you want to use the characters of text to form as many instances of the word "balloon" as possible.
+
+You can use each character in text at most once. Return the maximum number of instances that can be formed.
+
+
+
+Example 1:
+
+
+
+Input: text = "nlaebolko"
+Output: 1
+Example 2:
+
+
+
+Input: text = "loonbalxballpoon"
+Output: 2
+Example 3:
+
+Input: text = "leetcode"
+Output: 0
+
+
+Constraints:
+
+1 <= text.length <= 10^4
+text consists of lower case English letters only.
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int maxNumberOfBalloons(string text) {
+        if(text.length()==0) return 0;
+
+        unordered_map<char, int> mp;
+
+        for(auto ch: text)
+            mp[ch]++;
+
+        string tmp="balloon";
+        int n=tmp.length();
+
+        int res=0;
+
+        while(1){
+            for(int i=0;i<n;i++){
+                if(mp[tmp[i]]>0){
+                    mp[tmp[i]]--;
+                } else return res;
+            }
+            res++;
+        }
+        return res;
+    }
+};
+
+
+
+
+
+
+class Solution {
+public:
+    int maxNumberOfBalloons(string text) {
+        if(text.length()==0) return 0;
+
+        unordered_map<char, int> mp;
+
+        for(auto ch: text)
+            mp[ch]++;
+
+        int res=INT_MAX;
+
+        res=min(res,mp['b']);
+        res=min(res,mp['a']);
+        res=min(res,mp['l']/2);
+        res=min(res,mp['o']/2);
+        res=min(res,mp['n']);
+
+        return res;
+    }
+};

competitive programming/leetcode/1288. Remove Covered Intervals.cpp

@@ -0,0 +1,80 @@
+Given a list of intervals, remove all intervals that are covered by another interval in the list.
+
+Interval [a,b) is covered by interval [c,d) if and only if c <= a and b <= d.
+
+After doing so, return the number of remaining intervals.
+
+
+
+Example 1:
+
+Input: intervals = [[1,4],[3,6],[2,8]]
+Output: 2
+Explanation: Interval [3,6] is covered by [2,8], therefore it is removed.
+Example 2:
+
+Input: intervals = [[1,4],[2,3]]
+Output: 1
+Example 3:
+
+Input: intervals = [[0,10],[5,12]]
+Output: 2
+Example 4:
+
+Input: intervals = [[3,10],[4,10],[5,11]]
+Output: 2
+Example 5:
+
+Input: intervals = [[1,2],[1,4],[3,4]]
+Output: 1
+
+
+Constraints:
+
+1 <= intervals.length <= 1000
+intervals[i].length == 2
+0 <= intervals[i][0] < intervals[i][1] <= 10^5
+All the intervals are unique.
+   Show Hint #1
+   Hide Hint #2
+Compare each interval to all others and check if it is covered by any interval.
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    static bool comp(vector<int> a, vector<int> b){
+         if(a[0]==b[0])
+             return a[1]>b[1];
+        return a[0]<b[0];
+    }
+
+    int removeCoveredIntervals(vector<vector<int>>& intervals) {
+        sort(intervals.begin(), intervals.end(), comp);
+
+        int n=intervals.size();
+
+        int cnt=0;
+
+        int start=intervals[0][0], end=intervals[0][1];
+
+        for(int i=1;i<n;i++){
+            if(intervals[i][0]>=start  && intervals[i][1]<=end){
+                cnt++;
+                start=min(start, intervals[i][0]);
+                end=max(end, intervals[i][1]);
+            } else {
+                start=intervals[i][0];
+                end=intervals[i][1];
+            }
+
+        }
+
+        return n-cnt;
+    }
+};

competitive programming/leetcode/1332. Remove Palindromic Subsequences.cpp

@@ -0,0 +1,74 @@
+Given a string s consisting only of letters 'a' and 'b'. In a single step you can remove one palindromic subsequence from s.
+
+Return the minimum number of steps to make the given string empty.
+
+A string is a subsequence of a given string, if it is generated by deleting some characters of a given string without changing its order.
+
+A string is called palindrome if is one that reads the same backward as well as forward.
+
+
+
+Example 1:
+
+Input: s = "ababa"
+Output: 1
+Explanation: String is already palindrome
+Example 2:
+
+Input: s = "abb"
+Output: 2
+Explanation: "abb" -> "bb" -> "".
+Remove palindromic subsequence "a" then "bb".
+Example 3:
+
+Input: s = "baabb"
+Output: 2
+Explanation: "baabb" -> "b" -> "".
+Remove palindromic subsequence "baab" then "b".
+Example 4:
+
+Input: s = ""
+Output: 0
+
+
+Constraints:
+
+0 <= s.length <= 1000
+s only consists of letters 'a' and 'b'
+
+
+
+
+
+
+
+class Solution {
+public:
+
+    bool isPalindrome(string s){
+        int start=0, end=s.length()-1;
+        while(start<end){
+            if(s[start]!=s[end])
+                return false;
+            start++;
+            end--;
+        }
+        return true;
+    }
+
+    int removePalindromeSub(string s) {
+        if(s.length()==0) return 0;
+        if(isPalindrome(s)) return 1;
+        return 2;
+    }
+};
+
+/*
+If it's empty sting, return 0;
+If it's palindrome, return 1;
+Otherwise, we need at least 2 operation.
+
+We can delete all characters 'a' in the 1st operation,
+and then all characters 'b' in the 2nd operation.
+So return 2 in this case
+*/