🚀 25-Sep-2020

Author: sureshmangs

competitive programming/leetcode/1002. Find Common Characters.cpp

@@ -0,0 +1,60 @@
+Given an array A of strings made only from lowercase letters, return a list of all characters that show up in all strings within the list (including duplicates).  For example, if a character occurs 3 times in all strings but not 4 times, you need to include that character three times in the final answer.
+
+You may return the answer in any order.
+
+
+
+Example 1:
+
+Input: ["bella","label","roller"]
+Output: ["e","l","l"]
+Example 2:
+
+Input: ["cool","lock","cook"]
+Output: ["c","o"]
+
+
+Note:
+
+1 <= A.length <= 100
+1 <= A[i].length <= 100
+A[i][j] is a lowercase letter
+
+
+
+
+
+
+class Solution {
+public:
+    vector<string> commonChars(vector<string>& A) {
+        vector<string> res;
+
+        vector<int> freq(26, 0);
+
+        string first=A[0];
+
+        for(int i=0;i<first.length();i++)
+            freq[first[i]-'a']++;
+
+        for(int i=1;i<A.size();i++){
+            vector<int> ftmp(26, 0);
+            string tmp=A[i];
+
+            for(int i=0;i<tmp.length();i++)
+                ftmp[tmp[i]-'a']++;
+
+            for(int i=0;i<26;i++)
+                freq[i]=min(freq[i], ftmp[i]);
+        }
+
+        for(int i=0;i<26;i++){
+                while(freq[i]>0){
+                    res.push_back(string(1, i+'a'));
+                    freq[i]--;
+                }
+            }
+
+            return res;
+    }
+};

competitive programming/leetcode/1051. Height Checker.cpp

@@ -0,0 +1,59 @@
+Students are asked to stand in non-decreasing order of heights for an annual photo.
+
+Return the minimum number of students that must move in order for all students to be standing in non-decreasing order of height.
+
+Notice that when a group of students is selected they can reorder in any possible way between themselves and the non selected students remain on their seats.
+
+
+
+Example 1:
+
+Input: heights = [1,1,4,2,1,3]
+Output: 3
+Explanation:
+Current array : [1,1,4,2,1,3]
+Target array  : [1,1,1,2,3,4]
+On index 2 (0-based) we have 4 vs 1 so we have to move this student.
+On index 4 (0-based) we have 1 vs 3 so we have to move this student.
+On index 5 (0-based) we have 3 vs 4 so we have to move this student.
+Example 2:
+
+Input: heights = [5,1,2,3,4]
+Output: 5
+Example 3:
+
+Input: heights = [1,2,3,4,5]
+Output: 0
+
+
+Constraints:
+
+1 <= heights.length <= 100
+1 <= heights[i] <= 100
+
+
+
+
+
+
+
+class Solution {
+public:
+    int heightChecker(vector<int>& heights) {
+        int n=heights.size();
+        vector<int> target(n);
+
+        for(int i=0;i<n;i++)
+            target[i]=heights[i];
+
+        sort(target.begin(), target.end());
+
+        int cnt=0;
+
+        for(int i=0;i<n;i++){
+            if(heights[i]!=target[i])
+                cnt++;
+        }
+        return cnt;
+    }
+};

competitive programming/leetcode/1122. Relative Sort Array.cpp

@@ -0,0 +1,51 @@
+Given two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1.
+
+Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2.  Elements that don't appear in arr2 should be placed at the end of arr1 in ascending order.
+
+
+
+Example 1:
+
+Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
+Output: [2,2,2,1,4,3,3,9,6,7,19]
+
+
+Constraints:
+
+arr1.length, arr2.length <= 1000
+0 <= arr1[i], arr2[i] <= 1000
+Each arr2[i] is distinct.
+Each arr2[i] is in arr1.
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
+        vector<int> res;
+        map<int, int> m;
+
+        for(auto x: arr1)
+            m[x]++;
+
+        for(auto x: arr2){
+            while(m[x]>0){
+                res.push_back(x);
+                m[x]--;
+            }
+        }
+
+        for(auto [a, b]: m){
+            while(b>0){
+                res.push_back(a);
+                b--;
+            }
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/1160. Find Words That Can Be Formed by Characters.cpp

@@ -0,0 +1,57 @@
+You are given an array of strings words and a string chars.
+
+A string is good if it can be formed by characters from chars (each character can only be used once).
+
+Return the sum of lengths of all good strings in words.
+
+
+
+Example 1:
+
+Input: words = ["cat","bt","hat","tree"], chars = "atach"
+Output: 6
+Explanation:
+The strings that can be formed are "cat" and "hat" so the answer is 3 + 3 = 6.
+Example 2:
+
+Input: words = ["hello","world","leetcode"], chars = "welldonehoneyr"
+Output: 10
+Explanation:
+The strings that can be formed are "hello" and "world" so the answer is 5 + 5 = 10.
+
+
+Note:
+
+1 <= words.length <= 1000
+1 <= words[i].length, chars.length <= 100
+All strings contain lowercase English letters only.
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    int countCharacters(vector<string>& words, string chars) {
+        vector<int>  freq(26, 0);
+
+        int res=0;
+
+        for(auto x: chars) freq[x-'a']++;
+
+        for(auto word: words){
+            vector<int> tmp=freq;
+            bool flag=true;
+            for(auto ch: word){
+                if(tmp[ch-'a']<=0){ flag=false; break;}
+                tmp[ch-'a']--;
+            }
+            if(flag) res+=word.length();
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/1299. Replace Elements with Greatest Element on Right Side.cpp

@@ -0,0 +1,43 @@
+Given an array arr, replace every element in that array with the greatest element among the elements to its right, and replace the last element with -1.
+
+After doing so, return the array.
+
+
+
+Example 1:
+
+Input: arr = [17,18,5,4,6,1]
+Output: [18,6,6,6,1,-1]
+
+
+Constraints:
+
+1 <= arr.length <= 10^4
+1 <= arr[i] <= 10^5
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> replaceElements(vector<int>& arr) {
+        int n=arr.size();
+
+        vector<int> res(n);
+
+        int maxi=arr[n-1];
+
+        res[n-1]=-1;
+
+        for(int i=n-2;i>=0;i--){
+            res[i]=maxi;
+            if(arr[i]>maxi) maxi=arr[i];
+        }
+
+        return res;
+    }
+};

competitive programming/leetcode/1304. Find N Unique Integers Sum up to Zero.cpp

@@ -0,0 +1,57 @@
+Given an integer n, return any array containing n unique integers such that they add up to 0.
+
+
+
+Example 1:
+
+Input: n = 5
+Output: [-7,-1,1,3,4]
+Explanation: These arrays also are accepted [-5,-1,1,2,3] , [-3,-1,2,-2,4].
+Example 2:
+
+Input: n = 3
+Output: [-1,0,1]
+Example 3:
+
+Input: n = 1
+Output: [0]
+
+
+Constraints:
+
+1 <= n <= 1000
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> sumZero(int n) {
+        vector<int> res;
+        int i=1;
+
+        if(n%2!=0){
+            res.push_back(0);
+            n--;
+            while(n){
+                res.push_back(i);
+                res.push_back(-i);
+                i++;
+                n-=2;
+            }
+        } else {
+            while(n){
+                res.push_back(i);
+                res.push_back(-i);
+                i++;
+                n-=2;
+            }
+        }
+
+        return res;
+    }
+};