🚀 18-Dec-2020

Author: sureshmangs

competitive programming/codeforces/1450A - Avoid Trygub.cpp

@@ -0,0 +1,74 @@
+/*
+A string b is a subsequence of a string a if b can be obtained from a by deletion of several (possibly, zero or all) characters. For example, "xy" is a subsequence of "xzyw" and "xy", but not "yx".
+
+You are given a string a. Your task is to reorder the characters of a so that "trygub" is not a subsequence of the resulting string.
+
+In other words, you should find a string b which is a permutation of symbols of the string a and "trygub" is not a subsequence of b.
+
+We have a truly marvelous proof that any string can be arranged not to contain "trygub" as a subsequence, but this problem statement is too short to contain it.
+
+Input
+The first line contains a single integer t (1≤t≤100) — the number of test cases.
+
+The first line of each test case contains a single integer n (1≤n≤200) — the length of a.
+
+The next line contains the string a of length n, consisting of lowercase English letters.
+
+Output
+For each test case, output a string b of length n which is a permutation of characters of the string a, and such that "trygub" is not a subsequence of it.
+
+If there exist multiple possible strings b, you can print any.
+
+Example
+inputCopy
+3
+11
+antontrygub
+15
+bestcoordinator
+19
+trywatchinggurabruh
+outputCopy
+bugyrtnotna
+bestcoordinator
+bruhtrywatchinggura
+Note
+In the first test case, "bugyrtnotna" does not contain "trygub" as a subsequence. It does contain the letters of "trygub", but not in the correct order, so it is not a subsequence.
+
+In the second test case, we did not change the order of characters because it is not needed.
+
+In the third test case, "bruhtrywatchinggura" does contain "trygu" as a subsequence, but not "trygub".
+*/
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        string s;
+        cin>>s;
+        int cntb=0;
+        for(auto &ch: s)
+            if(ch=='b') cntb++;
+        string res="";
+        if(cntb==0) cout<<s<<endl;
+        else {
+            res.append(cntb, 'b');
+            for(auto &ch: s){
+                if(ch!='b') res+=ch;
+            }
+            cout<<res<<endl;
+        }
+    }
+
+
+    return 0;
+}

competitive programming/codeforces/1461A - String Generation.cpp

@@ -0,0 +1,70 @@
+/*
+One fall day Joe got bored because he couldn't find himself something interesting to do. Marty suggested Joe to generate a string of length n to entertain him somehow. It didn't seem particularly difficult, but Joe's generated string had to follow these rules:
+
+the string may only contain characters 'a', 'b', or 'c';
+the maximum length of a substring of this string that is a palindrome does not exceed k.
+
+A string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end. For example, strings "a", "bc", "abc" are substrings of a string "abc", while strings "ac", "ba", "cba" are not.
+
+A string is a palindrome if it reads the same from the left to the right and from the right to the left. For example, strings "abccba", "abbba", "aba", "abacaba", "a", and "bacab" are palindromes, while strings "abcbba", "abb", and "ab" are not.
+
+Now Joe wants to find any correct string. Help him! It can be proven that the answer always exists under the given constraints.
+
+Input
+Each test contains one or more test cases. The first line contains the number of test cases t (1≤t≤10).
+
+The only line of each test case contains two integers n and k (1≤k≤n≤1000) — the required string length and the maximum length of a palindrome substring, respectively.
+
+Output
+For each test case, print any string that satisfies the conditions from the problem statement. If there are multiple correct answers, you can print any one of them. It can be proven that the answer always exists under the given constraints.
+
+Example
+inputCopy
+2
+3 2
+4 1
+outputCopy
+aab
+acba
+Note
+In the first test case of the example, the palindrome substring with the maximum length is "aa". Its length does not exceed 2, so it fits.
+
+In the second test case all palindrome substrings have the length one.
+
+*/
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int t;
+    cin>>t;
+    while(t--){
+         int n, k;
+         cin>>n>>k;
+
+         string tmp="abc";
+         string res="";
+         int start=0;
+
+         for(int i=0;i<n;i++){
+            int j=k;
+            while(j-- && res.length()<n){
+                res+=tmp[start%3];
+            }
+            start++;
+         }
+
+         cout<<res<<endl;
+    }
+
+    return 0;
+}
+
+
+
+

competitive programming/hackerearth/math_number_theory_Prime Interval.cpp

@@ -0,0 +1,61 @@
+/*
+Find and Print All The Prime Numbers Between L and R (Both L and R Inclusive)
+
+Input Format
+
+Take Input Value of L and R
+
+Output Format
+
+Print All The Prime Number Between L and R (Both L and R inclusive)
+
+Constraints
+
+0 < L < 10001
+0 < R < 10001
+L <= R
+SAMPLE INPUT
+2 10
+SAMPLE OUTPUT
+2 3 5 7
+
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+void seiveErato(int start, int range, vector <int> &prime){
+    vector <bool> seive(range + 1, true);
+    seive[0] = false;
+    seive[1] = false;
+    for(int i = 2; i * i <= range; i++){
+        if(seive[i]){
+            for(int j = i * i; j <= range; j += i)
+                seive[j] = false;
+        }
+    }
+
+    for(int i = start; i <= range; i++)
+        if(seive[i])
+            prime.push_back(i);
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    int l, r;
+    cin >> l >> r;
+
+    vector <int> prime;
+    seiveErato(l, r, prime);
+
+    for(auto &x: prime) cout << x << " ";
+
+    return 0;
+}

competitive programming/leetcode/2020-December-Challenge/Day-11-Remove Duplicates from Sorted Array II.cpp

@@ -0,0 +1,71 @@
+Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.
+
+Do not allocate extra space for another array; you must do this by modifying the input array in-place with O(1) extra memory.
+
+Clarification:
+
+Confused why the returned value is an integer, but your answer is an array?
+
+Note that the input array is passed in by reference, which means a modification to the input array will be known to the caller.
+
+Internally you can think of this:
+
+// nums is passed in by reference. (i.e., without making a copy)
+int len = removeDuplicates(nums);
+
+// any modification to nums in your function would be known by the caller.
+// using the length returned by your function, it prints the first len elements.
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
+
+
+Example 1:
+
+Input: nums = [1,1,1,2,2,3]
+Output: 5, nums = [1,1,2,2,3]
+Explanation: Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively. It doesn't matter what you leave beyond the returned length.
+Example 2:
+
+Input: nums = [0,0,1,1,1,1,2,3,3]
+Output: 7, nums = [0,0,1,1,2,3,3]
+Explanation: Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively. It doesn't matter what values are set beyond the returned length.
+
+
+Constraints:
+
+0 <= nums.length <= 3 * 104
+-104 <= nums[i] <= 104
+nums is sorted in ascending order.
+
+
+
+
+
+
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int n=nums.size();
+        if(n<=2) return nums.size();
+
+        int cnt=1, start=0;
+        for(int i=0;i<n-1;i++){
+            if(nums[i]==nums[i+1]){
+                cnt++;
+            } else {
+                for(int j=0;j<cnt && j<2;j++)
+                    nums[start++]=nums[i];
+                cnt=1;
+            }
+        }
+
+        for(int j=0;j<cnt && j<2;j++)
+            nums[start++]=nums[n-1];
+
+
+        nums.resize(start);
+
+        return nums.size();
+    }
+};

competitive programming/leetcode/2020-December-Challenge/Day-12-Smallest Subtree with all the Deepest Nodes.cpp

@@ -0,0 +1,85 @@
+Given the root of a binary tree, the depth of each node is the shortest distance to the root.
+
+Return the smallest subtree such that it contains all the deepest nodes in the original tree.
+
+A node is called the deepest if it has the largest depth possible among any node in the entire tree.
+
+The subtree of a node is tree consisting of that node, plus the set of all descendants of that node.
+
+Note: This question is the same as 1123: https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves/
+
+
+
+Example 1:
+
+
+Input: root = [3,5,1,6,2,0,8,null,null,7,4]
+Output: [2,7,4]
+Explanation: We return the node with value 2, colored in yellow in the diagram.
+The nodes coloured in blue are the deepest nodes of the tree.
+Notice that nodes 5, 3 and 2 contain the deepest nodes in the tree but node 2 is the smallest subtree among them, so we return it.
+Example 2:
+
+Input: root = [1]
+Output: [1]
+Explanation: The root is the deepest node in the tree.
+Example 3:
+
+Input: root = [0,1,3,null,2]
+Output: [2]
+Explanation: The deepest node in the tree is 2, the valid subtrees are the subtrees of nodes 2, 1 and 0 but the subtree of node 2 is the smallest.
+
+
+Constraints:
+
+The number of nodes in the tree will be in the range [1, 500].
+0 <= Node.val <= 500
+The values of the nodes in the tree are unique.
+
+
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    unordered_map<TreeNode*, int> mp;
+    int max_depth;
+
+    void dfs(TreeNode* root, TreeNode* parent){
+        if(root){
+            mp.insert({root, mp[parent]+1});
+            dfs(root->left, root);
+            dfs(root->right, root);
+        }
+    }
+
+    TreeNode* answer(TreeNode* root){
+        if(root==NULL || mp[root]==max_depth) return root;
+        TreeNode* L=answer(root->left);
+        TreeNode* R=answer(root->right);
+        if(L && R) return root;
+        if(L) return L;
+        if(R) return R;
+        return NULL;
+    }
+
+    TreeNode* subtreeWithAllDeepest(TreeNode* root) {
+        mp.insert({NULL, -1});
+        dfs(root, NULL);
+        max_depth=-1;
+        for(auto it=mp.begin();it!=mp.end();it++){
+            max_depth=max(max_depth, it->second);
+        }
+        return answer(root);
+    }
+};