🚀 04-Sep-2020

Author: sureshmangs

array/distinct_element_in_window_of_size_k.cpp

@@ -0,0 +1,48 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+void countDistinct(int arr[], int k, int n){
+	unordered_map<int, int> m;
+	int dist_count = 0;
+
+	// Traverse the first window and store count of every element in hash map
+	for(int i = 0; i < k; i++){
+		if(m[arr[i]] == 0)
+			dist_count++;
+		m[arr[i]]++;
+	}
+
+	// Print count of first window
+	cout<<dist_count<<" ";
+
+	// Traverse through the remaining array
+	for (int i = k; i < n; i++){
+		// Remove first element of previous window
+		// If there was only one occurrence, then reduce distinct count
+		if(m[arr[i - k]] == 1)
+			dist_count--;
+
+		// reduce count of the removed element
+		m[arr[i - k]]--;
+
+		// Add new element of current window
+		// If this element appears first time, increment distinct element count
+
+		if (m[arr[i]] == 0)
+			dist_count++;
+
+		m[arr[i]]++;
+
+		// Print count of current window
+		cout<<dist_count<<" ";
+	}
+}
+
+int main(){
+	int arr[] = { 1, 2, 1, 3, 4, 2, 3 };
+	int size = sizeof(arr) / sizeof(arr[0]);
+	int k = 4;
+	countDistinct(arr, k, size);
+
+	return 0;
+}

competitive programming/leetcode/2020-September-Challenge/Day-03-Repeated Substring Pattern.cpp

@@ -0,0 +1,46 @@
+/*
+The key here is to double the string, that is, append the string to itself.
+In this way, the pattern would be duplicated.
+On removing the first and the last characters,
+if there exists some pattern,
+we would still be able to find the original string somewhere in the middle,
+taking some characters from the first half and some from the second half.
+
+For example,
+
+Example 1.
+
+s = "abab"
+s+s = "abababab"
+
+On removing the first and the last characters, we get:
+(s+s).substr(1, 2*s.size()-2) = "bababa"
+
+This new string, "bababa" still contains the original string, "abab".
+Thus there exists some repeated pattern in the original string itself.
+Example 2.
+
+s = "aba"
+s+s = "abaaba"
+
+On removing the first and the last characters, we get:
+(s+s).substr(1, 2*s.size()-2) = "baab"
+
+This new string, "baab" does not contain the original string, "aba".
+This implies that there does not exist any pattern in the original string itself.
+
+
+Source: https://leetcode.com/problems/repeated-substring-pattern/discuss/826135/C%2B%2B-O(N)-time-or-One-liner-without-KMP-Explained-or-Beats-99
+*/
+
+
+
+
+
+
+class Solution {
+public:
+    bool repeatedSubstringPattern(string s) {
+        return (s+s).substr(1, 2*s.length()-2).find(s)!=-1;
+    }
+};

competitive programming/leetcode/215. Kth Largest Element in an Array.cpp

@@ -0,0 +1,34 @@
+Find the kth largest element in an unsorted array.
+Note that it is the kth largest element in the sorted order, not the kth distinct element.
+
+Example 1:
+
+Input: [3,2,1,5,6,4] and k = 2
+Output: 5
+Example 2:
+
+Input: [3,2,3,1,2,4,5,5,6] and k = 4
+Output: 4
+Note:
+You may assume k is always valid, 1 ≤ k ≤ array's length.
+
+
+
+
+
+
+
+class Solution {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        priority_queue<int, vector<int>, greater<int> > q;  // min heap
+
+        if(nums.size()<k) return -1;
+        for(auto &num: nums){
+            q.push(num);
+            if(q.size()>k) q.pop();
+        }
+
+        return q.top();
+    }
+};

competitive programming/leetcode/239. Sliding Window Maximum.cpp

@@ -0,0 +1,67 @@
+Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Return the max sliding window.
+
+Follow up:
+Could you solve it in linear time?
+
+Example:
+
+Input: nums = [1,3,-1,-3,5,3,6,7], and k = 3
+Output: [3,3,5,5,6,7]
+Explanation:
+
+Window position                Max
+---------------               -----
+[1  3  -1] -3  5  3  6  7       3
+ 1 [3  -1  -3] 5  3  6  7       3
+ 1  3 [-1  -3  5] 3  6  7       5
+ 1  3  -1 [-3  5  3] 6  7       5
+ 1  3  -1  -3 [5  3  6] 7       6
+ 1  3  -1  -3  5 [3  6  7]      7
+
+
+Constraints:
+
+1 <= nums.length <= 10^5
+-10^4 <= nums[i] <= 10^4
+1 <= k <= nums.length
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
+        int n=nums.size();
+        vector<int> res;
+        deque<int> q;
+
+        for(int i=0;i<k;i++){
+            while(!q.empty() && nums[i]>=nums[q.back()])
+                q.pop_back(); // Remove from rear
+
+            q.push_back(i); // Add new element at rear of queue
+        }
+
+        for(int i=k;i<n;i++){
+            res.push_back(nums[q.front()]);
+
+            // Remove the elements which are out of this window
+            while(!q.empty() && q.front()<=i-k)
+                q.pop_front();
+
+            while(!q.empty() && nums[i]>=nums[q.back()])
+                q.pop_back(); // Remove from rear
+
+            q.push_back(i);
+        }
+        // Adding maximum element of last window
+        res.push_back(nums[q.front()]);
+
+        return res;
+    }
+};

competitive programming/leetcode/295. Find Median from Data Stream.cpp

@@ -0,0 +1,96 @@
+Median is the middle value in an ordered integer list.
+If the size of the list is even, there is no middle value.
+So the median is the mean of the two middle value.
+
+For example,
+[2,3,4], the median is 3
+
+[2,3], the median is (2 + 3) / 2 = 2.5
+
+Design a data structure that supports the following two operations:
+
+void addNum(int num) - Add a integer number from the data stream to the data structure.
+double findMedian() - Return the median of all elements so far.
+
+
+Example:
+
+addNum(1)
+addNum(2)
+findMedian() -> 1.5
+addNum(3)
+findMedian() -> 2
+
+
+Follow up:
+
+If all integer numbers from the stream are between 0 and 100, how would you optimize it?
+If 99% of all integer numbers from the stream are between 0 and 100, how would you optimize it?
+
+
+
+
+
+
+
+
+class MedianFinder {
+public:
+
+    priority_queue<int> q1; // max heap
+    priority_queue<int, vector<int>, greater<int> > q2;  // min heap
+
+    /** initialize your data structure here. */
+    MedianFinder() {
+
+    }
+
+    void addNum(int num) {
+        if(q1.empty() || q1.top()>num)
+            q1.push(num);
+        else q2.push(num);
+
+        if(q1.size()>q2.size()+1){
+            q2.push(q1.top());
+            q1.pop();
+        } else if(q2.size()>q1.size()+1){
+            q1.push(q2.top());
+            q2.pop();
+        }
+
+    }
+
+    double findMedian() {
+        int q1size=q1.size();
+        int q2size=q2.size();
+        if(q1size>q2size) return q1.top();
+        else if(q2size>q1size)return q2.top();
+        else return (double)(q1.top()+q2.top())/2;
+    }
+};
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder* obj = new MedianFinder();
+ * obj->addNum(num);
+ * double param_2 = obj->findMedian();
+ */
+
+
+
+
+ // Approach 1: Simple Sorting
+ // Time complexity: O(nlog n) + O(1) = O(nlogn)
+ // Space complexity: O(n)
+
+ // Approach 2: Insertion Sort
+ // When a new number comes, we just have to put it in it's right place in the already sorted array
+ // We can use binary search for it
+ // Time complexity:  O(n) + O(logn) ≈ O(n)
+ // Space complexity: O(n)
+
+
+
+ // Approach 3: Two Heaps
+ // Time complexity: (O(logn)
+// Space complexity: O(n)

competitive programming/leetcode/459. Repeated Substring Pattern.cpp

@@ -0,0 +1,46 @@
+/*
+The key here is to double the string, that is, append the string to itself.
+In this way, the pattern would be duplicated.
+On removing the first and the last characters,
+if there exists some pattern,
+we would still be able to find the original string somewhere in the middle,
+taking some characters from the first half and some from the second half.
+
+For example,
+
+Example 1.
+
+s = "abab"
+s+s = "abababab"
+
+On removing the first and the last characters, we get:
+(s+s).substr(1, 2*s.size()-2) = "bababa"
+
+This new string, "bababa" still contains the original string, "abab".
+Thus there exists some repeated pattern in the original string itself.
+Example 2.
+
+s = "aba"
+s+s = "abaaba"
+
+On removing the first and the last characters, we get:
+(s+s).substr(1, 2*s.size()-2) = "baab"
+
+This new string, "baab" does not contain the original string, "aba".
+This implies that there does not exist any pattern in the original string itself.
+
+
+Source: https://leetcode.com/problems/repeated-substring-pattern/discuss/826135/C%2B%2B-O(N)-time-or-One-liner-without-KMP-Explained-or-Beats-99
+*/
+
+
+
+
+
+
+class Solution {
+public:
+    bool repeatedSubstringPattern(string s) {
+        return (s+s).substr(1, 2*s.length()-2).find(s)!=-1;
+    }
+};

competitive programming/leetcode/703. Kth Largest Element in a Stream.cpp

@@ -0,0 +1,54 @@
+Design a class to find the kth largest element in a stream.
+Note that it is the kth largest element in the sorted order, not the kth distinct element.
+
+Your KthLargest class will have a constructor which accepts an integer k and an integer array nums,
+which contains initial elements from the stream.
+For each call to the method KthLargest.add, return the element representing the kth largest element in the stream.
+
+Example:
+
+int k = 3;
+int[] arr = [4,5,8,2];
+KthLargest kthLargest = new KthLargest(3, arr);
+kthLargest.add(3);   // returns 4
+kthLargest.add(5);   // returns 5
+kthLargest.add(10);  // returns 5
+kthLargest.add(9);   // returns 8
+kthLargest.add(4);   // returns 8
+Note:
+You may assume that nums' length ≥ k-1 and k ≥ 1.
+
+
+
+
+
+
+
+
+
+class KthLargest {
+public:
+
+    priority_queue<int, vector<int>, greater<int> > q; // min heap
+    int qcap; // k
+
+    KthLargest(int k, vector<int>& nums) {
+        qcap=k;
+        for(auto &num: nums){
+            q.push(num);
+            if(q.size()>k) q.pop();
+        }
+    }
+
+    int add(int val) {
+        q.push(val);
+        if(q.size()>qcap) q.pop();
+        return q.top();
+    }
+};
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * KthLargest* obj = new KthLargest(k, nums);
+ * int param_1 = obj->add(val);
+ */