Add new solutions

Author: kiranpalsingh1806

solutions/design.md

@@ -0,0 +1,162 @@
+# Design and Implementation
+
+## Implement Queue Using Stack
+
+```cpp
+class MyQueue {
+public:
+    stack<int> S1, S2;
+    
+    void push(int x) {
+        while(S1.size()) {
+            S2.push(S1.top());
+            S1.pop();
+        }
+        
+        S2.push(x);
+        
+        while(S2.size()) {
+            S1.push(S2.top());
+            S2.pop();
+        }
+    }
+    
+    int pop() {
+        int x = S1.top();
+        S1.pop();
+        return x;
+    }
+    
+    int peek() {
+        return S1.top();
+    }
+    
+    bool empty() {
+        return S1.empty();
+    }
+};
+
+```
+
+## Implement Stack Using Queue
+
+```cpp
+class MyStack {
+public:
+    queue<int> q1, q2;
+    
+    void push(int x) {
+        q2.push(x);
+        while(q1.size()) {
+            q2.push(q1.front());
+            q1.pop();
+        }
+        while(q2.size()) {
+            q1.push(q2.front());
+            q2.pop();
+        }
+    }
+    
+    int pop() {
+        int x = q1.front();
+        q1.pop();
+        return x;
+    }
+    
+    int top() {
+        return q1.front();
+    }
+    
+    bool empty() {
+        return q1.empty();
+    }
+};
+```
+
+## Stock Price Fluctuation
+
+```cpp
+class StockPrice {
+    map<int, int> m;
+    multiset<int> s;
+public:
+    StockPrice() {}
+    void update(int t, int p) {
+        if (m.count(t)) {
+            s.erase(s.find(m[t]));
+        }
+        m[t] = p;
+        s.insert(p);
+    }
+    int current() {
+        return m.rbegin()->second;
+    }
+    int maximum() {
+        return *s.rbegin();
+    }
+    int minimum() {
+        return *s.begin();
+    }
+};
+```
+
+## Time based Key-Value Store
+
+```cpp
+class TimeMap {
+public:
+    unordered_map<string, map<int, string, greater<>>> M;
+    
+    void set(string key, string value, int timestamp) {
+        M[key][timestamp] = value;
+    }
+    
+    string get(string key, int timestamp) {
+        if (M.count(key) == 0) return "";
+        auto it = M[key].lower_bound(timestamp);
+        if(it == M[key].end()) {
+            return "";
+        } else {
+            return it->second;
+        }
+    }
+};
+
+```
+
+## Design Circular Queue
+
+```cpp
+class MyCircularQueue {
+private:
+    vector<int> v;
+    int start = 0, len = 0;
+public:
+    MyCircularQueue(int k): v(k) {}
+    bool enQueue(int value) {
+        if (isFull()) return false;
+        v[(start + len++) % v.size()] = value;
+        return true;
+    }
+    bool deQueue() {
+        if (isEmpty()) return false;
+        start = (start + 1) % v.size();
+        --len;
+        return true;
+    }
+    int Front() {
+        if (isEmpty()) return -1;
+        return v[start];
+    }
+    int Rear() {
+        if (isEmpty()) return -1;
+        return v[(start + len - 1) % v.size()];
+    }
+    bool isEmpty() {
+        return !len;
+    }
+    bool isFull() {
+        return len == v.size();
+    }
+};
+```

solutions/sliding-window.md

@@ -0,0 +1,112 @@
+# Sliding Window
+
+## Longest Substring Without Repeating Characters
+
+```cpp
+int lengthOfLongestSubstring(string s) {
+    int N = s.length();
+    int ans = 0, i = 0;
+    
+    unordered_map<char, int> M;
+    
+    for(int j = 0; j < N; j++) {
+        
+        M[s[j]]++;
+        
+        // Window size increases from left side.
+        while(M[s[j]] > 1) {
+            M[s[i++]]--;
+        }
+        
+        ans = max(ans, j - i + 1);
+    }
+    
+    return ans;
+}
+```
+
+## Minimum Size Subarray Sum
+
+```cpp
+int minSubArrayLen(int target, vector<int>& nums) { 
+    int N = nums.size();
+    int sum = 0, ans = N + 1, i = 0;
+    
+    for(int j = 0; j < N; j++) {
+        
+        sum += nums[j];
+        
+        while(sum >= target) {
+            ans = min(ans, j - i + 1);
+            sum -= nums[i++];
+        }
+    }
+    
+    return ans == N + 1 ? 0 : ans;
+}
+```
+
+## Number of Smooth Descent Periods of a Stock
+
+```cpp
+long long getDescentPeriods(vector<int>& prices) {   
+    long long ans = 0;
+    int i = 0, N = prices.size();
+    
+    for(int j = 0; j < N; j++) {
+        
+        if(j && prices[j] + 1 != prices[j - 1]) {
+            i = j;
+        }
+        
+        ans += (j - i + 1);
+    }
+    
+    return ans;
+}
+```
+
+## Frequency of Most Frequent Element
+
+```cpp
+int maxFrequency(vector<int>& A, int k) {
+    sort(A.begin(), A.end());
+    int N = A.size();
+    
+    long long i = 0, sum = 0, ans = 0;
+    
+    for(int j = 0; j < N; j++) {
+        sum += A[j];
+        
+        // Increase the windows size when our total sum - sum of window > k
+        while((A[j] * (j - i + 1) - sum) > k ) {
+            sum -= A[i++];
+        }
+        
+        // If our window is valid, we can perform less than or equal to k operations.
+        ans = max(ans, j - i + 1);
+    }
+    
+    return ans;
+}
+```
+
+## Max Consecutive Ones III
+
+```cpp
+int longestOnes(vector<int>& nums, int k) {  
+    int N = nums.size();
+    int length = 0, i = 0, sum = 0;
+    
+    for(int j = 0; j < N; j++) {
+        sum += nums[j];
+        while(((j - i + 1) - sum) > k) {
+            sum -= nums[i++];
+        }
+        
+        length = max(length, j - i + 1);
+    }
+    
+    return length;
+}
+```