Practise 16-Jun-2020

Author: sureshmangs

array/k_closest_num_max_heap.cpp

@@ -0,0 +1,49 @@
+/*
+Given an unsorted array and two numbers x and k, find k closest values to x.
+Input : arr[] = {10, 2, 14, 4, 7, 6}, x = 5, k = 3
+*/
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+
+        int arr[n];
+        for(int i=0;i<n;i++) cin>>arr[i];
+
+        int k, x;
+        cin>>k>>x;
+
+        priority_queue<pair<int, int> > maxh;
+
+        for(int i=0;i<n;i++){
+            maxh.push({abs(x-arr[i]), arr[i]});
+            if(maxh.size()>k) maxh.pop();
+        }
+
+        vector<int> res;
+        while(!maxh.empty()){
+            res.push_back(maxh.top().second);
+            maxh.pop();
+        }
+
+        sort(res.begin(), res.end());
+
+        for(auto x: res) cout<<x<<" ";
+        cout<<endl;
+    }
+
+return 0;
+}

array/k_largest_num_min_heap.cpp

@@ -0,0 +1,70 @@
+/*
+Given an array of N positive integers, print k largest elements from the array.  The output elements should be printed in decreasing order.
+
+Input:
+The first line of input contains an integer T denoting the number of test cases. The first line of each test case is N and k, N is the size of array and K is the largest elements to be returned. The second line of each test case contains N input C[i].
+
+Output:
+Print the k largest element in descending order.
+
+Constraints:
+1 ≤ T ≤ 100
+1 ≤ N ≤ 100
+K ≤ N
+1 ≤ C[i] ≤ 1000
+
+Example:
+Input:
+2
+5 2
+12 5 787 1 23
+7 3
+1 23 12 9 30 2 50
+
+Output:
+787 23
+50 30 23
+
+Explanation:
+Testcase 1: 1st largest element in the array is 787 and second largest is 23.
+Testcase 2: 3 Largest element in the array are 50, 30 and 23.
+*/
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n,k;
+        cin>>n>>k;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+
+        // Implement min heap
+        priority_queue<int, vector<int>, greater<int> > minh;
+        for(int i=0;i<n;i++){
+            minh.push(a[i]);
+            if(minh.size()> k) minh.pop();
+        }
+        stack<int> s;
+        while(!minh.empty()){
+            s.push(minh.top());
+            minh.pop();
+        }
+        // printing in descending order
+        while(!s.empty()){
+            cout<<s.top()<<" ";
+            s.pop();
+        }
+        cout<<endl;
+    }
+
+return 0;
+}

array/kth_smallest_num_max_heap.cpp

@@ -0,0 +1,37 @@
+/8
+Given an array and a number k where k is smaller than size of array, we need to find the k’th smallest element in the given array. It is given that all array elements are distinct.
+
+Example:
+Input: arr[] = {7, 10, 4, 3, 20, 15}
+k = 3
+Output: 7
+*/
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n,k;
+        cin>>n;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        cin>>k;
+        // Implement max heap
+        priority_queue<int> maxh;
+        for(int i=0;i<n;i++){
+            maxh.push(a[i]);
+            if(maxh.size()>k) maxh.pop();
+        }
+        cout<<maxh.top()<<endl;
+    }
+
+return 0;
+}

array/sort_k_sorted_array.cpp

@@ -0,0 +1,62 @@
+/*
+Given an array of n elements, where each element is at most k away from its target position. The task is to print array in sorted form.
+
+Input:
+First line consists of T test cases. First line of every test case consists of two integers N and K, denoting number of elements in array and at most k positions away from its target position respectively. Second line of every test case consists of elements of array.
+
+Output:
+Single line output to print the sorted array.
+
+Constraints:
+1<=T<=100
+1<=N<=100
+1<=K<=N
+
+Example:
+Input:
+2
+3 3
+2 1 3
+6 3
+2 6 3 12 56 8
+Output:
+1 2 3
+2 3 6 8 12 56
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n,k;
+        cin>>n>>k;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+        priority_queue<int, vector<int>, greater<int> >minh;
+        for(int i=0;i<n;i++){
+            minh.push(a[i]);
+            if(minh.size()>k){
+                cout<<minh.top()<<" ";
+                minh.pop();
+            }
+        }
+        while(!minh.empty()){
+            cout<<minh.top()<<" ";
+            minh.pop();
+        }
+        cout<<endl;
+    }
+
+return 0;
+}

competitive programming/leetcode/2020-June-Challenge/Day-15-Search in a Binary Search Tree.cpp

@@ -0,0 +1,78 @@
+Given the root node of a binary search tree (BST) and a value. You need to find the node in the BST that the node's value equals the given value. Return the subtree rooted with that node. If such node doesn't exist, you should return NULL.
+
+For example,
+
+Given the tree:
+        4
+       / \
+      2   7
+     / \
+    1   3
+
+And the value to search: 2
+You should return this subtree:
+
+      2
+     / \
+    1   3
+In the example above, if we want to search the value 5, since there is no node with value 5, we should return NULL.
+
+Note that an empty tree is represented by NULL, therefore you would see the expected output (serialized tree format) as [], not null.
+
+
+
+
+
+
+
+
+/**
+ * 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:
+    TreeNode* searchBST(TreeNode* root, int val) {
+        if(!root) return root;
+
+        if(val==root->val) return root;
+        else if(val<root->val) return searchBST(root->left, val);
+        else return searchBST(root->right, val);
+    }
+};
+
+
+
+
+
+
+/**
+Iterative
+ * 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:
+    TreeNode* searchBST(TreeNode* root, int val) {
+        while(root && root->val!=val){
+            root=val<root->val ? root->left: root->right;
+        }
+        return root;
+    }
+};

competitive programming/leetcode/658. Find K Closest Elements.cpp

@@ -0,0 +1,43 @@
+Given a sorted array arr, two integers k and x, find the k closest elements to x in the array. The result should also be sorted in ascending order. If there is a tie, the smaller elements are always preferred.
+
+
+
+Example 1:
+
+Input: arr = [1,2,3,4,5], k = 4, x = 3
+Output: [1,2,3,4]
+Example 2:
+
+Input: arr = [1,2,3,4,5], k = 4, x = -1
+Output: [1,2,3,4]
+
+
+Constraints:
+
+1 <= k <= arr.length
+1 <= arr.length <= 10^4
+Absolute value of elements in the array and x will not exceed 104
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
+        int n=arr.size();
+        priority_queue<pair<int, int> > maxh;
+        for(int i=0;i<n;i++){
+            maxh.push({abs(x-arr[i]), arr[i]});
+            if(maxh.size()>k) maxh.pop();
+        }
+        vector<int> res;
+        while(!maxh.empty()){
+            res.push_back(maxh.top().second);
+            maxh.pop();
+        }
+        sort(res.begin(), res.end());
+        return res;
+    }
+};