From be011e1b7c438db045dadeb03103ecb951abd050 Mon Sep 17 00:00:00 2001
From: Sri Hari <kataresrihari@gmail.com>
Date: Fri, 24 Jan 2025 11:25:27 +0530
Subject: [PATCH 1/4] Batch-5/Neetcode-ALL/Added-articles

---
 ...ments-not-equal-to-average-of-neighbors.md | 338 ++++++++++
 articles/bag-of-tokens.md                     | 109 ++++
 ...find-polygon-with-the-largest-perimeter.md | 295 +++++++++
 articles/k-th-symbol-in-grammar.md            | 413 +++++++++++++
 ...h-of-string-after-deleting-similar-ends.md |  86 +++
 .../minimum-time-to-make-rope-colorful.md     | 270 ++++++++
 ...es-that-satisfy-the-given-sum-condition.md | 514 ++++++++++++++++
 articles/rearrange-array-elements-by-sign.md  | 310 ++++++++++
 .../remove-duplicates-from-sorted-array-ii.md | 421 +++++++++++++
 articles/sequential-digits.md                 | 579 ++++++++++++++++++
 10 files changed, 3335 insertions(+)
 create mode 100644 articles/array-with-elements-not-equal-to-average-of-neighbors.md
 create mode 100644 articles/bag-of-tokens.md
 create mode 100644 articles/find-polygon-with-the-largest-perimeter.md
 create mode 100644 articles/k-th-symbol-in-grammar.md
 create mode 100644 articles/minimum-length-of-string-after-deleting-similar-ends.md
 create mode 100644 articles/minimum-time-to-make-rope-colorful.md
 create mode 100644 articles/number-of-subsequences-that-satisfy-the-given-sum-condition.md
 create mode 100644 articles/rearrange-array-elements-by-sign.md
 create mode 100644 articles/remove-duplicates-from-sorted-array-ii.md
 create mode 100644 articles/sequential-digits.md

diff --git a/articles/array-with-elements-not-equal-to-average-of-neighbors.md b/articles/array-with-elements-not-equal-to-average-of-neighbors.md
new file mode 100644
index 000000000..4e4a1daa1
--- /dev/null
+++ b/articles/array-with-elements-not-equal-to-average-of-neighbors.md
@@ -0,0 +1,338 @@
+## 1. Greedy
+
+::tabs-start
+
+```python
+class Solution:
+    def rearrangeArray(self, nums: List[int]) -> List[int]:
+        nums.sort()
+        res = []
+        l, r = 0, len(nums) - 1
+        while len(res) != len(nums):
+            res.append(nums[l])
+            l += 1
+            if l <= r:
+                res.append(nums[r])
+                r -= 1
+        return res
+```
+
+```java
+public class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        Arrays.sort(nums);
+        int[] res = new int[nums.length];
+        int l = 0, r = nums.length - 1;
+        int idx = 0;
+
+        while (idx != nums.length) {
+            res[idx++] = nums[l++];
+            if (l <= r) {
+                res[idx++] = nums[r--];
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        vector<int> res;
+        int l = 0, r = nums.size() - 1;
+
+        while (res.size() != nums.size()) {
+            res.push_back(nums[l++]);
+            if (l <= r) {
+                res.push_back(nums[r--]);
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    rearrangeArray(nums) {
+        nums.sort((a, b) => a - b);
+        const res = [];
+        let l = 0, r = nums.length - 1;
+
+        while (res.length !== nums.length) {
+            res.push(nums[l++]);
+            if (l <= r) {
+                res.push(nums[r--]);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n\log n)$
+* Space complexity: $O(n)$
+
+---
+
+## 2. Greedy (Space Optimized)
+
+::tabs-start
+
+```python
+class Solution:
+    def rearrangeArray(self, nums: List[int]) -> List[int]:
+        nums.sort()
+        for i in range(1, len(nums), 2):
+            nums[i], nums[i - 1] = nums[i - 1], nums[i]
+        return nums
+```
+
+```java
+public class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        Arrays.sort(nums);
+        for (int i = 1; i < nums.length; i += 2) {
+            int temp = nums[i];
+            nums[i] = nums[i - 1];
+            nums[i - 1] = temp;
+        }
+        return nums;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        for (int i = 1; i < nums.size(); i += 2) {
+            swap(nums[i], nums[i - 1]);
+        }
+        return nums;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    rearrangeArray(nums) {
+        nums.sort((a, b) => a - b);
+        for (let i = 1; i < nums.length; i += 2) {
+            [nums[i], nums[i - 1]] = [nums[i - 1], nums[i]];
+        }
+        return nums;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
+
+---
+
+## 3. Greedy (Optimal) - I
+
+::tabs-start
+
+```python
+class Solution:
+    def rearrangeArray(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+
+        for i in range(1, n - 1):
+            if 2 * nums[i] == (nums[i - 1] + nums[i + 1]):
+                nums[i], nums[i + 1] = nums[i + 1], nums[i]
+        
+        for i in range(n - 2, 0, -1):
+            if 2 * nums[i] == (nums[i - 1] + nums[i + 1]):
+                nums[i], nums[i - 1] = nums[i - 1], nums[i]
+        
+        return nums
+```
+
+```java
+public class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        int n = nums.length;
+
+        for (int i = 1; i < n - 1; i++) {
+            if (2 * nums[i] == (nums[i - 1] + nums[i + 1])) {
+                int temp = nums[i];
+                nums[i] = nums[i + 1];
+                nums[i + 1] = temp;
+            }
+        }
+
+        for (int i = n - 2; i > 0; i--) {
+            if (2 * nums[i] == (nums[i - 1] + nums[i + 1])) {
+                int temp = nums[i];
+                nums[i] = nums[i - 1];
+                nums[i - 1] = temp;
+            }
+        }
+
+        return nums;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        int n = nums.size();
+
+        for (int i = 1; i < n - 1; i++) {
+            if (2 * nums[i] == (nums[i - 1] + nums[i + 1])) {
+                swap(nums[i], nums[i + 1]);
+            }
+        }
+
+        for (int i = n - 2; i > 0; i--) {
+            if (2 * nums[i] == (nums[i - 1] + nums[i + 1])) {
+                swap(nums[i], nums[i - 1]);
+            }
+        }
+
+        return nums;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    rearrangeArray(nums) {
+        const n = nums.length;
+
+        for (let i = 1; i < n - 1; i++) {
+            if (2 * nums[i] === nums[i - 1] + nums[i + 1]) {
+                [nums[i], nums[i + 1]] = [nums[i + 1], nums[i]];
+            }
+        }
+
+        for (let i = n - 2; i > 0; i--) {
+            if (2 * nums[i] === nums[i - 1] + nums[i + 1]) {
+                [nums[i], nums[i - 1]] = [nums[i - 1], nums[i]];
+            }
+        }
+
+        return nums;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 4. Greedy Optimal - II
+
+::tabs-start
+
+```python
+class Solution:
+    def rearrangeArray(self, nums: List[int]) -> List[int]:
+        increase = nums[0] < nums[1]
+        for i in range(1, len(nums) - 1):
+            if ((increase and nums[i] < nums[i + 1]) or
+                (not increase and nums[i] > nums[i + 1])
+            ):
+                nums[i], nums[i + 1] = nums[i + 1], nums[i]
+            increase = not increase
+        return nums
+```
+
+```java
+public class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        boolean increase = nums[0] < nums[1];
+        for (int i = 1; i < nums.length - 1; i++) {
+            if ((increase && nums[i] < nums[i + 1]) ||
+                (!increase && nums[i] > nums[i + 1])) {
+                int temp = nums[i];
+                nums[i] = nums[i + 1];
+                nums[i + 1] = temp;
+            }
+            increase = !increase;
+        }
+        return nums;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        bool increase = nums[0] < nums[1];
+        for (int i = 1; i < nums.size() - 1; i++) {
+            if ((increase && nums[i] < nums[i + 1]) ||
+                (!increase && nums[i] > nums[i + 1])) {
+                swap(nums[i], nums[i + 1]);
+            }
+            increase = !increase;
+        }
+        return nums;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    rearrangeArray(nums) {
+        let increase = nums[0] < nums[1];
+        for (let i = 1; i < nums.length - 1; i++) {
+            if ((increase && nums[i] < nums[i + 1]) ||
+                (!increase && nums[i] > nums[i + 1])) {
+                [nums[i], nums[i + 1]] = [nums[i + 1], nums[i]];
+            }
+            increase = !increase;
+        }
+        return nums;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
\ No newline at end of file
diff --git a/articles/bag-of-tokens.md b/articles/bag-of-tokens.md
new file mode 100644
index 000000000..e6db737b8
--- /dev/null
+++ b/articles/bag-of-tokens.md
@@ -0,0 +1,109 @@
+## 1. Greedy + Two Pointers
+
+::tabs-start
+
+```python
+class Solution:
+    def bagOfTokensScore(self, tokens: List[int], power: int) -> int:
+        res = score = 0
+        tokens.sort()
+        l, r = 0, len(tokens) - 1
+        while l <= r:
+            if power >= tokens[l]:
+                power -= tokens[l]
+                l += 1
+                score += 1
+                res = max(res, score)
+            elif score > 0:
+                power += tokens[r]
+                r -= 1
+                score -= 1
+            else:
+                break
+        return res
+```
+
+```java
+public class Solution {
+    public int bagOfTokensScore(int[] tokens, int power) {
+        Arrays.sort(tokens);
+        int res = 0, score = 0, l = 0, r = tokens.length - 1;
+
+        while (l <= r) {
+            if (power >= tokens[l]) {
+                power -= tokens[l++];
+                score++;
+                res = Math.max(res, score);
+            } else if (score > 0) {
+                power += tokens[r--];
+                score--;
+            } else {
+                break;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int bagOfTokensScore(vector<int>& tokens, int power) {
+        sort(tokens.begin(), tokens.end());
+        int res = 0, score = 0, l = 0, r = tokens.size() - 1;
+
+        while (l <= r) {
+            if (power >= tokens[l]) {
+                power -= tokens[l++];
+                score++;
+                res = max(res, score);
+            } else if (score > 0) {
+                power += tokens[r--];
+                score--;
+            } else {
+                break;
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} tokens
+     * @param {number} power
+     * @return {number}
+     */
+    bagOfTokensScore(tokens, power) {
+        tokens.sort((a, b) => a - b);
+        let res = 0, score = 0, l = 0, r = tokens.length - 1;
+
+        while (l <= r) {
+            if (power >= tokens[l]) {
+                power -= tokens[l++];
+                score++;
+                res = Math.max(res, score);
+            } else if (score > 0) {
+                power += tokens[r--];
+                score--;
+            } else {
+                break;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
\ No newline at end of file
diff --git a/articles/find-polygon-with-the-largest-perimeter.md b/articles/find-polygon-with-the-largest-perimeter.md
new file mode 100644
index 000000000..f736cb463
--- /dev/null
+++ b/articles/find-polygon-with-the-largest-perimeter.md
@@ -0,0 +1,295 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def largestPerimeter(self, nums: List[int]) -> int:
+        n = len(nums)
+        res = -1
+
+        for i, large in enumerate(nums):
+            cur = 0
+            for j, side in enumerate(nums):
+                if i != j and side <= large:
+                    cur += side
+            if cur > large:
+                res = max(res, cur + large)
+
+        return res
+```
+
+```java
+public class Solution {
+    public long largestPerimeter(int[] nums) {
+        int n = nums.length;
+        long res = -1;
+
+        for (int i = 0; i < n; i++) {
+            int large = nums[i];
+            long cur = 0;
+
+            for (int j = 0; j < n; j++) {
+                if (i != j && nums[j] <= large) {
+                    cur += nums[j];
+                }
+            }
+
+            if (cur > large) {
+                res = Math.max(res, cur + large);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long largestPerimeter(vector<int>& nums) {
+        int n = nums.size();
+        long long res = -1;
+
+        for (int i = 0; i < n; i++) {
+            long long large = nums[i];
+            long long cur = 0;
+
+            for (int j = 0; j < n; j++) {
+                if (i != j && nums[j] <= large) {
+                    cur += nums[j];
+                }
+            }
+
+            if (cur > large) {
+                res = max(res, cur + large);
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    largestPerimeter(nums) {
+        const n = nums.length;
+        let res = -1;
+
+        for (let i = 0; i < n; i++) {
+            const large = nums[i];
+            let cur = 0;
+
+            for (let j = 0; j < n; j++) {
+                if (i !== j && nums[j] <= large) {
+                    cur += nums[j];
+                }
+            }
+
+            if (cur > large) {
+                res = Math.max(res, cur + large);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 2. Sorting
+
+::tabs-start
+
+```python
+class Solution:
+    def largestPerimeter(self, nums: List[int]) -> int:
+        nums.sort()
+        res = -1
+        total = 0
+        for num in nums:
+            if total > num:
+                res = total + num
+            total += num
+        return res
+```
+
+```java
+public class Solution {
+    public long largestPerimeter(int[] nums) {
+        Arrays.sort(nums);
+        long res = -1;
+        long total = 0;
+
+        for (int num : nums) {
+            if (total > num) {
+                res = total + num;
+            }
+            total += num;
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long largestPerimeter(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        long long res = -1;
+        long long total = 0;
+
+        for (int& num : nums) {
+            if (total > num) {
+                res = total + num;
+            }
+            total += num;
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    largestPerimeter(nums) {
+        nums.sort((a, b) => a - b);
+        let res = -1;
+        let total = 0;
+
+        for (let num of nums) {
+            if (total > num) {
+                res = total + num;
+            }
+            total += num;
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
+
+---
+
+## 3. Max Heap
+
+::tabs-start
+
+```python
+class Solution:
+    def largestPerimeter(self, nums: List[int]) -> int:
+        nums = [-num for num in nums]
+        heapq.heapify(nums)
+        total = -sum(nums)
+
+        while len(nums) > 2:
+            largest = -heapq.heappop(nums)
+            total -= largest
+            if largest < total:
+                return total + largest
+        return -1
+```
+
+```java
+public class Solution {
+    public long largestPerimeter(int[] nums) {
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
+        long total = 0;
+        for (int num : nums) {
+            maxHeap.add(num);
+            total += num;
+        }
+
+        while (maxHeap.size() > 2) {
+            int largest = maxHeap.poll();
+            total -= largest;
+            if (largest < total) {
+                return total + largest;
+            }
+        }
+        return -1;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long largestPerimeter(vector<int>& nums) {
+        priority_queue<int> maxHeap(nums.begin(), nums.end());
+        long long total = accumulate(nums.begin(), nums.end(), 0LL);
+
+        while (maxHeap.size() > 2) {
+            int largest = maxHeap.top();
+            maxHeap.pop();
+            total -= largest;
+            if (largest < total) {
+                return total + largest;
+            }
+        }
+        return -1;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    largestPerimeter(nums) {
+        const maxHeap = new MaxPriorityQueue();
+        let total = 0;
+
+        nums.forEach(num => {
+            total += num;
+            maxHeap.enqueue(num);
+        });
+
+        while (maxHeap.size() > 2) {
+            const largest = maxHeap.dequeue().element;
+            total -= largest;
+            if (largest < total) return total + largest;
+        }
+        return -1;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity:
+    * $O(n + (30\log n))$ in Python, C++, JS.
+    * $O(n \log n)$ in Java.
+* Space complexity: $O(n)$
\ No newline at end of file
diff --git a/articles/k-th-symbol-in-grammar.md b/articles/k-th-symbol-in-grammar.md
new file mode 100644
index 000000000..d3f782b4c
--- /dev/null
+++ b/articles/k-th-symbol-in-grammar.md
@@ -0,0 +1,413 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        prev = ['0']
+        for i in range(2, n + 1):
+            cur = []
+            for c in prev:
+                if c == '0':
+                    cur.append('0')
+                    cur.append('1')
+                else:
+                    cur.append('1')
+                    cur.append('0')
+            prev = cur
+        return int(prev[k - 1])
+```
+
+```java
+public class Solution {
+    public int kthGrammar(int n, int k) {
+        List<Character> prev = new ArrayList<>();
+        prev.add('0');
+        for (int i = 2; i <= n; i++) {
+            List<Character> cur = new ArrayList<>();
+            for (char c : prev) {
+                if (c == '0') {
+                    cur.add('0');
+                    cur.add('1');
+                } else {
+                    cur.add('1');
+                    cur.add('0');
+                }
+            }
+            prev = cur;
+        }
+        return prev.get(k - 1) - '0';
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int kthGrammar(int n, int k) {
+        vector<char> prev = {'0'};
+        for (int i = 2; i <= n; i++) {
+            vector<char> cur;
+            for (char c : prev) {
+                if (c == '0') {
+                    cur.push_back('0');
+                    cur.push_back('1');
+                } else {
+                    cur.push_back('1');
+                    cur.push_back('0');
+                }
+            }
+            prev = cur;
+        }
+        return prev[k - 1] - '0';
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} n
+     * @param {number} k
+     * @return {number}
+     */
+    kthGrammar(n, k) {
+        let prev = ['0'];
+        for (let i = 2; i <= n; i++) {
+            let cur = [];
+            for (let c of prev) {
+                if (c === '0') {
+                    cur.push('0');
+                    cur.push('1');
+                } else {
+                    cur.push('1');
+                    cur.push('0');
+                }
+            }
+            prev = cur;
+        }
+        return parseInt(prev[k - 1]);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(2 ^ n)$
+* Space complexity: $O(2 ^ n)$
+
+---
+
+## 2. Binary Tree Traversal (Recursion)
+
+::tabs-start
+
+```python
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        def dfs(n, k, root):
+            if n == 1:
+                return root
+            
+            total = 1 << (n - 1)
+            if k > (total // 2):
+                return dfs(n - 1, k - (total // 2), root ^ 1)
+            else:
+                return dfs(n - 1, k, root)
+        
+        return dfs(n, k, 0)
+```
+
+```java
+public class Solution {
+    public int kthGrammar(int n, int k) {
+        return dfs(n, k, 0);
+    }
+    
+    private int dfs(int n, int k, int root) {
+        if (n == 1) {
+            return root;
+        }
+        
+        int total = 1 << (n - 1);
+        if (k > total / 2) {
+            return dfs(n - 1, k - total / 2, root ^ 1);
+        } else {
+            return dfs(n - 1, k, root);
+        }
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int kthGrammar(int n, int k) {
+        return dfs(n, k, 0);
+    }
+
+    int dfs(int n, int k, int root){
+        if (n == 1) return root;
+
+        int total = 1 << (n - 1);
+        if (k > total / 2) {
+            return dfs(n - 1, k - total / 2, root ^ 1);
+        } else {
+            return dfs(n - 1, k, root);
+        }
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} n
+     * @param {number} k
+     * @return {number}
+     */
+    kthGrammar(n, k) {
+        const dfs = (n, k, root) => {
+            if (n === 1) return root;
+
+            const total = 1 << (n - 1);
+            if (k > total / 2) {
+                return dfs(n - 1, k - total / 2, root ^ 1);
+            } else {
+                return dfs(n - 1, k, root);
+            }
+        };
+
+        return dfs(n, k, 0);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$ for recursion stack.
+
+---
+
+## 3. Binary Tree Traversal (Iteration)
+
+::tabs-start
+
+```python
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        cur = 0
+        left, right = 1, 2 ** (n - 1)
+        
+        for _ in range(n - 1):
+            mid = (left + right) // 2
+            if k <= mid:
+                right = mid
+            else:
+                left = mid + 1
+                cur = 0 if cur else 1
+        
+        return cur
+```
+
+```java
+public class Solution {
+    public int kthGrammar(int n, int k) {
+        int cur = 0;
+        int left = 1, right = 1 << (n - 1);
+        
+        for (int i = 0; i < n - 1; i++) {
+            int mid = (left + right) / 2;
+            if (k <= mid) {
+                right = mid;
+            } else {
+                left = mid + 1;
+                cur = (cur == 0) ? 1 : 0;
+            }
+        }
+        
+        return cur;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int kthGrammar(int n, int k) {
+        int cur = 0;
+        int left = 1, right = 1 << (n - 1);
+        
+        for (int i = 0; i < n - 1; i++) {
+            int mid = (left + right) / 2;
+            if (k <= mid) {
+                right = mid;
+            } else {
+                left = mid + 1;
+                cur = (cur == 0) ? 1 : 0;
+            }
+        }
+        
+        return cur;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} n
+     * @param {number} k
+     * @return {number}
+     */
+    kthGrammar(n, k) {
+        let cur = 0;
+        let left = 1, right = 1 << (n - 1);
+        
+        for (let i = 0; i < n - 1; i++) {
+            let mid = Math.floor((left + right) / 2);
+            if (k <= mid) {
+                right = mid;
+            } else {
+                left = mid + 1;
+                cur = cur === 0 ? 1 : 0;
+            }
+        }
+        
+        return cur;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
+
+---
+
+## 4. Recursion (Traverse Towards Root)
+
+::tabs-start
+
+```python
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        if n == 1:
+            return 0
+        if k & 1:
+            return self.kthGrammar(n - 1, (k + 1) // 2)
+        return self.kthGrammar(n - 1, k // 2) ^ 1
+```
+
+```java
+public class Solution {
+    public int kthGrammar(int n, int k) {
+        if (n == 1) {
+            return 0;
+        }
+        if ((k & 1) == 1) {
+            return kthGrammar(n - 1, (k + 1) / 2);
+        }
+        return kthGrammar(n - 1, k / 2) ^ 1;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int kthGrammar(int n, int k) {
+        if (n == 1) {
+            return 0;
+        }
+        if (k & 1) {
+            return kthGrammar(n - 1, (k + 1) / 2);
+        }
+        return kthGrammar(n - 1, k / 2) ^ 1;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} n
+     * @param {number} k
+     * @return {number}
+     */
+    kthGrammar(n, k) {
+        if (n === 1) {
+            return 0;
+        }
+        if (k % 2 === 1) {
+            return this.kthGrammar(n - 1, Math.floor((k + 1) / 2));
+        }
+        return this.kthGrammar(n - 1, Math.floor(k / 2)) ^ 1;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$ for recursion stack.
+
+---
+
+## 5. Math
+
+::tabs-start
+
+```python
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        return bin(k - 1).count('1') & 1
+```
+
+```java
+public class Solution {
+    public int kthGrammar(int n, int k) {
+        return Integer.bitCount(k - 1) & 1;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int kthGrammar(int n, int k) {
+        return __builtin_popcount(k - 1) & 1;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} n
+     * @param {number} k
+     * @return {number}
+     */
+    kthGrammar(n, k) {
+        return (k - 1).toString(2).split('1').length - 1 & 1;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(\log n)$
+* Space complexity: $O(1)$ or $O(\log n)$ depending on the language.
\ No newline at end of file
diff --git a/articles/minimum-length-of-string-after-deleting-similar-ends.md b/articles/minimum-length-of-string-after-deleting-similar-ends.md
new file mode 100644
index 000000000..81155cffe
--- /dev/null
+++ b/articles/minimum-length-of-string-after-deleting-similar-ends.md
@@ -0,0 +1,86 @@
+## 1. Greedy + Two Pointers
+
+::tabs-start
+
+```python
+class Solution:
+    def minimumLength(self, s: str) -> int:
+        l, r = 0, len(s) - 1
+
+        while l < r and s[l] == s[r]:
+            tmp = s[l]
+            while l <= r and s[l] == tmp:
+                l += 1
+            while l <= r and s[r] == tmp:
+                r -= 1
+        return r - l + 1
+```
+
+```java
+public class Solution {
+    public int minimumLength(String s) {
+        int l = 0, r = s.length() - 1;
+
+        while (l < r && s.charAt(l) == s.charAt(r)) {
+            char tmp = s.charAt(l);
+            while (l <= r && s.charAt(l) == tmp) {
+                l++;
+            }
+            while (l <= r && s.charAt(r) == tmp) {
+                r--;
+            }
+        }
+        return r - l + 1;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minimumLength(string s) {
+        int l = 0, r = s.length() - 1;
+
+        while (l < r && s[l] == s[r]) {
+            char tmp = s[l];
+            while (l <= r && s[l] == tmp) {
+                l++;
+            }
+            while (l <= r && s[r] == tmp) {
+                r--;
+            }
+        }
+        return r - l + 1;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    minimumLength(s) {
+        let l = 0, r = s.length - 1;
+
+        while (l < r && s[l] === s[r]) {
+            const tmp = s[l];
+            while (l <= r && s[l] === tmp) {
+                l++;
+            }
+            while (l <= r && s[r] === tmp) {
+                r--;
+            }
+        }
+        return r - l + 1;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
\ No newline at end of file
diff --git a/articles/minimum-time-to-make-rope-colorful.md b/articles/minimum-time-to-make-rope-colorful.md
new file mode 100644
index 000000000..a9d436a9d
--- /dev/null
+++ b/articles/minimum-time-to-make-rope-colorful.md
@@ -0,0 +1,270 @@
+## 1. Two Pointers - I
+
+::tabs-start
+
+```python
+class Solution:
+    def minCost(self, colors: str, neededTime: List[int]) -> int:
+        n = len(neededTime)
+        res = i = 0
+        while i < n:
+            j = i
+            maxi = curr = 0
+            while j < n and colors[j] == colors[i]:
+                maxi = max(maxi, neededTime[j])
+                curr += neededTime[j]
+                j += 1
+            res += curr - maxi
+            i = j
+        return res
+```
+
+```java
+public class Solution {
+    public int minCost(String colors, int[] neededTime) {
+        int n = neededTime.length;
+        int res = 0, i = 0;
+        while (i < n) {
+            int j = i, maxi = 0, curr = 0;
+            while (j < n && colors.charAt(j) == colors.charAt(i)) {
+                maxi = Math.max(maxi, neededTime[j]);
+                curr += neededTime[j];
+                j++;
+            }
+            res += curr - maxi;
+            i = j;
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minCost(string colors, vector<int>& neededTime) {
+        int n = neededTime.size();
+        int res = 0, i = 0;
+        while (i < n) {
+            int j = i, maxi = 0, curr = 0;
+            while (j < n && colors[j] == colors[i]) {
+                maxi = max(maxi, neededTime[j]);
+                curr += neededTime[j];
+                j++;
+            }
+            res += curr - maxi;
+            i = j;
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} colors
+     * @param {number[]} neededTime
+     * @return {number}
+     */
+    minCost(colors, neededTime) {
+        const n = neededTime.length;
+        let res = 0, i = 0;
+        while (i < n) {
+            let j = i, maxi = 0, curr = 0;
+            while (j < n && colors[j] === colors[i]) {
+                maxi = Math.max(maxi, neededTime[j]);
+                curr += neededTime[j];
+                j++;
+            }
+            res += curr - maxi;
+            i = j;
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 2. Two Pointers - II
+
+::tabs-start
+
+```python
+class Solution:
+    def minCost(self, colors: str, neededTime: List[int]) -> int:
+        l, res = 0, 0
+        for r in range(1, len(colors)):
+            if colors[l] == colors[r]:
+                if neededTime[l] < neededTime[r]:
+                    res += neededTime[l]
+                    l = r
+                else:
+                    res += neededTime[r]
+            else:
+                l = r
+        return res
+```
+
+```java
+public class Solution {
+    public int minCost(String colors, int[] neededTime) {
+        int l = 0, res = 0;
+        for (int r = 1; r < colors.length(); r++) {
+            if (colors.charAt(l) == colors.charAt(r)) {
+                if (neededTime[l] < neededTime[r]) {
+                    res += neededTime[l];
+                    l = r;
+                } else {
+                    res += neededTime[r];
+                }
+            } else {
+                l = r;
+            }
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minCost(string colors, vector<int>& neededTime) {
+        int l = 0, res = 0;
+        for (int r = 1; r < colors.size(); r++) {
+            if (colors[l] == colors[r]) {
+                if (neededTime[l] < neededTime[r]) {
+                    res += neededTime[l];
+                    l = r;
+                } else {
+                    res += neededTime[r];
+                }
+            } else {
+                l = r;
+            }
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} colors
+     * @param {number[]} neededTime
+     * @return {number}
+     */
+    minCost(colors, neededTime) {
+        let l = 0, res = 0;
+        for (let r = 1; r < colors.length; r++) {
+            if (colors[l] === colors[r]) {
+                if (neededTime[l] < neededTime[r]) {
+                    res += neededTime[l];
+                    l = r;
+                } else {
+                    res += neededTime[r];
+                }
+            } else {
+                l = r;
+            }
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 3. Two Pointers - III
+
+::tabs-start
+
+```python
+class Solution:
+    def minCost(self, colors: str, neededTime: List[int]) -> int:
+        res = maxi = 0
+        for i in range(len(colors)):
+            if i and colors[i] != colors[i - 1]:
+                maxi = 0
+            res += min(maxi, neededTime[i])
+            maxi = max(maxi, neededTime[i])
+        return res
+```
+
+```java
+public class Solution {
+    public int minCost(String colors, int[] neededTime) {
+        int res = 0, maxi = 0;
+        for (int i = 0; i < colors.length(); i++) {
+            if (i > 0 && colors.charAt(i) != colors.charAt(i - 1)) {
+                maxi = 0;
+            }
+            res += Math.min(maxi, neededTime[i]);
+            maxi = Math.max(maxi, neededTime[i]);
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minCost(string colors, vector<int>& neededTime) {
+        int res = 0, maxi = 0;
+        for (int i = 0; i < colors.size(); i++) {
+            if (i > 0 && colors[i] != colors[i - 1]) {
+                maxi = 0;
+            }
+            res += min(maxi, neededTime[i]);
+            maxi = max(maxi, neededTime[i]);
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} colors
+     * @param {number[]} neededTime
+     * @return {number}
+     */
+    minCost(colors, neededTime) {
+        let res = 0, maxi = 0;
+        for (let i = 0; i < colors.length; i++) {
+            if (i > 0 && colors[i] !== colors[i - 1]) {
+                maxi = 0;
+            }
+            res += Math.min(maxi, neededTime[i]);
+            maxi = Math.max(maxi, neededTime[i]);
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
\ No newline at end of file
diff --git a/articles/number-of-subsequences-that-satisfy-the-given-sum-condition.md b/articles/number-of-subsequences-that-satisfy-the-given-sum-condition.md
new file mode 100644
index 000000000..cc81b5ad0
--- /dev/null
+++ b/articles/number-of-subsequences-that-satisfy-the-given-sum-condition.md
@@ -0,0 +1,514 @@
+## 1. Brute Force (Recursion)
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubseq(self, nums: List[int], target: int) -> int:
+        MOD = 1000000007
+
+        def dfs(maxi, mini, i):
+            if i == len(nums):
+                if mini != float("inf") and (maxi + mini) <= target:
+                    return 1
+                return 0
+
+            skip = dfs(maxi, mini, i + 1)
+            include = dfs(max(maxi, nums[i]), min(mini, nums[i]), i + 1)
+            return (skip + include) % MOD
+
+        return dfs(float("-inf"), float("inf"), 0)
+```
+
+```java
+public class Solution {
+    private static final int MOD = 1000000007;
+
+    public int numSubseq(int[] nums, int target) {
+        return dfs(nums, Integer.MIN_VALUE, Integer.MAX_VALUE, 0, target);
+    }
+
+    private int dfs(int[] nums, int maxi, int mini, int i, int target) {
+        if (i == nums.length) {
+            if (mini != Integer.MAX_VALUE && (maxi + mini) <= target) {
+                return 1;
+            }
+            return 0;
+        }
+
+        int skip = dfs(nums, maxi, mini, i + 1, target);
+        int include = dfs(nums, Math.max(maxi, nums[i]), Math.min(mini, nums[i]), i + 1, target);
+        return (skip + include) % MOD;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    const int MOD = 1e9 + 7;
+
+    int numSubseq(vector<int>& nums, int target) {
+        return dfs(nums, INT_MIN, INT_MAX, 0, target);
+    }
+
+private:
+    int dfs(vector<int>& nums, int maxi, int mini, int i, int target) {
+        if (i == nums.size()) {
+            if (mini != INT_MAX && (maxi + mini) <= target) {
+                return 1;
+            }
+            return 0;
+        }
+
+        int skip = dfs(nums, maxi, mini, i + 1, target);
+        int include = dfs(nums, max(maxi, nums[i]), min(mini, nums[i]), i + 1, target);
+        return (skip + include) % MOD;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} target
+     * @return {number}
+     */
+    numSubseq(nums, target) {
+        const MOD = 1000000007;
+
+        const dfs = (maxi, mini, i) => {
+            if (i === nums.length) {
+                if (mini !== Infinity && (maxi + mini) <= target) {
+                    return 1;
+                }
+                return 0;
+            }
+
+            const skip = dfs(maxi, mini, i + 1);
+            const include = dfs(Math.max(maxi, nums[i]), Math.min(mini, nums[i]), i + 1);
+            return (skip + include) % MOD;
+        };
+
+        return dfs(-Infinity, Infinity, 0);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(2 ^ n)$
+* Space complexity: $O(n)$ for recursion stack.
+
+---
+
+## 2. Binary Search
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubseq(self, nums: List[int], target: int) -> int:
+        nums.sort()
+        MOD = 1000000007
+        res = 0
+        
+        for i in range(len(nums)):
+            if nums[i] * 2 > target:
+                break
+            
+            l, r = i, len(nums) - 1
+            while l <= r:
+                mid = (l + r) // 2
+                if nums[i] + nums[mid] <= target:
+                    l = mid + 1
+                else:
+                    r = mid - 1
+            
+            count = pow(2, r - i, MOD)
+            res = (res + count) % MOD
+        
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubseq(int[] nums, int target) {
+        Arrays.sort(nums);
+        int MOD = 1000000007;
+        int res = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] * 2 > target) break;
+
+            int l = i, r = nums.length - 1;
+            while (l <= r) {
+                int mid = l + (r - l) / 2;
+                if (nums[i] + nums[mid] <= target) {
+                    l = mid + 1;
+                } else {
+                    r = mid - 1;
+                }
+            }
+
+            long count = pow(2, r - i, MOD);
+            res = (int) ((res + count) % MOD);
+        }
+        return res;
+    }
+
+    private long pow(int base, int exp, int mod) {
+        long result = 1;
+        long b = base;
+        while (exp > 0) {
+            if ((exp & 1) == 1) result = (result * b) % mod;
+            b = (b * b) % mod;
+            exp >>= 1;
+        }
+        return result;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubseq(vector<int>& nums, int target) {
+        sort(nums.begin(), nums.end());
+        int MOD = 1000000007;
+        int res = 0;
+
+        for (int i = 0; i < nums.size(); i++) {
+            if (nums[i] * 2 > target) break;
+
+            int l = i, r = nums.size() - 1;
+            while (l <= r) {
+                int mid = l + (r - l) / 2;
+                if (nums[i] + nums[mid] <= target) {
+                    l = mid + 1;
+                } else {
+                    r = mid - 1;
+                }
+            }
+
+            long long count = powMod(2, r - i, MOD);
+            res = (res + count) % MOD;
+        }
+        return res;
+    }
+
+private:
+    long long powMod(int base, int exp, int mod) {
+        long long result = 1, b = base;
+        while (exp > 0) {
+            if (exp & 1) result = (result * b) % mod;
+            b = (b * b) % mod;
+            exp >>= 1;
+        }
+        return result;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} target
+     * @return {number}
+     */
+    numSubseq(nums, target) {
+        nums.sort((a, b) => a - b);
+        const MOD = BigInt(1000000007);
+        let res = 0n;
+
+        const powerMod = (base, exp, mod) => {
+            let result = 1n, b = BigInt(base);
+            while (exp > 0) {
+                if (exp & 1) result = (result * b) % mod;
+                b = (b * b) % mod;
+                exp >>= 1;
+            }
+            return result;
+        };
+
+        for (let i = 0; i < nums.length; i++) {
+            if (nums[i] * 2 > target) break;
+
+            let l = i, r = nums.length - 1;
+            while (l <= r) {
+                const mid = Math.floor((l + r) / 2);
+                if (nums[i] + nums[mid] <= target) {
+                    l = mid + 1;
+                } else {
+                    r = mid - 1;
+                }
+            }
+
+            const count = powerMod(2, r - i, MOD);
+            res = (res + count) % MOD;
+        }
+
+        return Number(res);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
+
+---
+
+## 3. Two Pointers
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubseq(self, nums: List[int], target: int) -> int:
+        nums.sort()
+        res = 0
+        mod = 10**9 + 7
+        
+        r = len(nums) - 1
+        for i, left in enumerate(nums):
+            while i <= r and left + nums[r] > target:
+                r -= 1
+            if i <= r:
+                res += pow(2, r - i, mod)
+                res %= mod
+        
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubseq(int[] nums, int target) {
+        Arrays.sort(nums);
+        int res = 0, mod = 1000000007;
+        int r = nums.length - 1;
+        
+        for (int i = 0; i < nums.length; i++) {
+            while (i <= r && nums[i] + nums[r] > target) {
+                r--;
+            }
+            if (i <= r) {
+                res = (res + power(2, r - i, mod)) % mod;
+            }
+        }
+        return res;
+    }
+    
+    private int power(int base, int exp, int mod) {
+        long result = 1, b = base;
+        while (exp > 0) {
+            if ((exp & 1) == 1) result = (result * b) % mod;
+            b = (b * b) % mod;
+            exp >>= 1;
+        }
+        return (int) result;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubseq(vector<int>& nums, int target) {
+        sort(nums.begin(), nums.end());
+        int res = 0, mod = 1000000007;
+        int r = nums.size() - 1;
+        
+        for (int i = 0; i < nums.size(); i++) {
+            while (i <= r && nums[i] + nums[r] > target) {
+                r--;
+            }
+            if (i <= r) {
+                res = (res + power(2, r - i, mod)) % mod;
+            }
+        }
+        return res;
+    }
+    
+private:
+    long long power(int base, int exp, int mod) {
+        long long result = 1, b = base;
+        while (exp > 0) {
+            if (exp & 1) result = (result * b) % mod;
+            b = (b * b) % mod;
+            exp >>= 1;
+        }
+        return result;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} target
+     * @return {number}
+     */
+    numSubseq(nums, target) {
+        nums.sort((a, b) => a - b);
+        const mod = BigInt(1000000007);
+        let res = 0n;
+
+        const power = (base, exp, mod) => {
+            let result = 1n, b = BigInt(base);
+            while (exp > 0) {
+                if (exp & 1) result = (result * b) % mod;
+                b = (b * b) % mod;
+                exp >>= 1;
+            }
+            return result;
+        };
+
+        for (let i = 0, r = nums.length - 1; i < nums.length; i++) {
+            while (nums[i] + nums[r] > target && i <= r) {
+                r--;
+            }
+            if (i <= r) {
+                res = (res + power(2, r - i, mod)) % mod;
+            }
+        }
+
+        return Number(res);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
+
+---
+
+## 4. Two Pointers (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubseq(self, nums: List[int], target: int) -> int:
+        nums.sort()
+        MOD = 1000000007
+        res = 0
+        l, r = 0, len(nums) - 1
+        power = [1] * len(nums)
+        
+        for i in range(1, len(nums)):
+            power[i] = (power[i - 1] * 2) % MOD
+        
+        while l <= r:
+            if nums[l] + nums[r] <= target:
+                res = (res + power[r - l]) % MOD
+                l += 1
+            else:
+                r -= 1
+        
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubseq(int[] nums, int target) {
+        Arrays.sort(nums);
+        int MOD = 1000000007;
+        int res = 0, l = 0, r = nums.length - 1;
+        int[] power = new int[nums.length];
+        power[0] = 1;
+
+        for (int i = 1; i < nums.length; i++) {
+            power[i] = (power[i - 1] * 2) % MOD;
+        }
+
+        while (l <= r) {
+            if (nums[l] + nums[r] <= target) {
+                res = (res + power[r - l]) % MOD;
+                l++;
+            } else {
+                r--;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubseq(vector<int>& nums, int target) {
+        sort(nums.begin(), nums.end());
+        int MOD = 1000000007;
+        int res = 0, l = 0, r = nums.size() - 1;
+        vector<int> power(nums.size(), 1);
+
+        for (int i = 1; i < nums.size(); i++) {
+            power[i] = (power[i - 1] * 2) % MOD;
+        }
+
+        while (l <= r) {
+            if (nums[l] + nums[r] <= target) {
+                res = (res + power[r - l]) % MOD;
+                l++;
+            } else {
+                r--;
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} target
+     * @return {number}
+     */
+    numSubseq(nums, target) {
+        nums.sort((a, b) => a - b);
+        const MOD = 1000000007;
+        let res = 0, l = 0, r = nums.length - 1;
+        const power = Array(nums.length).fill(1);
+
+        for (let i = 1; i < nums.length; i++) {
+            power[i] = (power[i - 1] * 2) % MOD;
+        }
+
+        while (l <= r) {
+            if (nums[l] + nums[r] <= target) {
+                res = (res + power[r - l]) % MOD;
+                l++;
+            } else {
+                r--;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(n)$
\ No newline at end of file
diff --git a/articles/rearrange-array-elements-by-sign.md b/articles/rearrange-array-elements-by-sign.md
new file mode 100644
index 000000000..a634ed75b
--- /dev/null
+++ b/articles/rearrange-array-elements-by-sign.md
@@ -0,0 +1,310 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def rearrangeArray(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        for i in range(n):
+            if ((i % 2 == 0 and nums[i] > 0) or
+                (i % 2 == 1 and nums[i] < 0)):
+                continue
+            
+            j = i + 1
+            while j < n and ((nums[j] > 0) == (nums[i] > 0)):
+                j += 1
+            
+            tmp = nums[j]
+            while j > i:
+                nums[j] = nums[j - 1]
+                j -= 1
+            nums[i] = tmp
+        return nums
+```
+
+```java
+public class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        int n = nums.length;
+        for (int i = 0; i < n; i++) {
+            if ((i % 2 == 0 && nums[i] > 0) || (i % 2 == 1 && nums[i] < 0)) {
+                continue;
+            }
+            
+            int j = i + 1;
+            while (j < n && ((nums[j] > 0) == (nums[i] > 0))) {
+                j++;
+            }
+            
+            int temp = nums[j];
+            while (j > i) {
+                nums[j] = nums[j - 1];
+                j--;
+            }
+            nums[i] = temp;
+        }
+        return nums;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        int n = nums.size();
+        for (int i = 0; i < n; i++) {
+            if ((i % 2 == 0 && nums[i] > 0) || (i % 2 == 1 && nums[i] < 0)) {
+                continue;
+            }
+            
+            int j = i + 1;
+            while (j < n && ((nums[j] > 0) == (nums[i] > 0))) {
+                j++;
+            }
+            
+            int temp = nums[j];
+            while (j > i) {
+                nums[j] = nums[j - 1];
+                j--;
+            }
+            nums[i] = temp;
+        }
+        return nums;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    rearrangeArray(nums) {
+        let n = nums.length;
+        for (let i = 0; i < n; i++) {
+            if ((i % 2 === 0 && nums[i] > 0) || (i % 2 === 1 && nums[i] < 0)) {
+                continue;
+            }
+            
+            let j = i + 1;
+            while (j < n && ((nums[j] > 0) === (nums[i] > 0))) {
+                j++;
+            }
+            
+            let temp = nums[j];
+            while (j > i) {
+                nums[j] = nums[j - 1];
+                j--;
+            }
+            nums[i] = temp;
+        }
+        return nums;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 2. Group Numbers Into Two Arrays
+
+::tabs-start
+
+```python
+class Solution:
+    def rearrangeArray(self, nums: List[int]) -> List[int]:
+        pos, neg = [], []
+        for num in nums:
+            if num > 0:
+                pos.append(num)
+            else:
+                neg.append(num)
+
+        i = 0
+        while 2 * i < len(nums):
+            nums[2 * i] = pos[i]
+            nums[2 * i + 1] = neg[i]
+            i += 1
+        return nums
+```
+
+```java
+public class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        List<Integer> pos = new ArrayList<>();
+        List<Integer> neg = new ArrayList<>();
+        for (int num : nums) {
+            if (num > 0) {
+                pos.add(num);
+            } else {
+                neg.add(num);
+            }
+        }
+
+        int i = 0;
+        while (2 * i < nums.length) {
+            nums[2 * i] = pos.get(i);
+            nums[2 * i + 1] = neg.get(i);
+            i++;
+        }
+        return nums;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        vector<int> pos, neg;
+        for (int num : nums) {
+            if (num > 0) {
+                pos.push_back(num);
+            } else {
+                neg.push_back(num);
+            }
+        }
+
+        int i = 0;
+        while (2 * i < nums.size()) {
+            nums[2 * i] = pos[i];
+            nums[2 * i + 1] = neg[i];
+            i++;
+        }
+        return nums;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    rearrangeArray(nums) {
+        const pos = [], neg = [];
+        for (const num of nums) {
+            if (num > 0) {
+                pos.push(num);
+            } else {
+                neg.push(num);
+            }
+        }
+
+        let i = 0;
+        while (2 * i < nums.length) {
+            nums[2 * i] = pos[i];
+            nums[2 * i + 1] = neg[i];
+            i++;
+        }
+        return nums;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Two Pointers
+
+::tabs-start
+
+```python
+class Solution:
+    def rearrangeArray(self, nums: List[int]) -> List[int]:
+        i, j = 0, 1
+        res = [0] * len(nums)
+        for k in range(len(nums)):
+            if nums[k] > 0:
+                res[i] = nums[k]
+                i += 2
+            else:
+                res[j] = nums[k]
+                j += 2
+        return res
+```
+
+```java
+public class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        int i = 0, j = 1;
+        int[] res = new int[nums.length];
+        for (int k = 0; k < nums.length; k++) {
+            if (nums[k] > 0) {
+                res[i] = nums[k];
+                i += 2;
+            } else {
+                res[j] = nums[k];
+                j += 2;
+            }
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        int i = 0, j = 1;
+        vector<int> res(nums.size());
+        for (int k = 0; k < nums.size(); k++) {
+            if (nums[k] > 0) {
+                res[i] = nums[k];
+                i += 2;
+            } else {
+                res[j] = nums[k];
+                j += 2;
+            }
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    rearrangeArray(nums) {
+        let i = 0, j = 1;
+        const res = new Array(nums.length);
+        for (let k = 0; k < nums.length; k++) {
+            if (nums[k] > 0) {
+                res[i] = nums[k];
+                i += 2;
+            } else {
+                res[j] = nums[k];
+                j += 2;
+            }
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$ for the output array.
\ No newline at end of file
diff --git a/articles/remove-duplicates-from-sorted-array-ii.md b/articles/remove-duplicates-from-sorted-array-ii.md
new file mode 100644
index 000000000..8fff8a2d4
--- /dev/null
+++ b/articles/remove-duplicates-from-sorted-array-ii.md
@@ -0,0 +1,421 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n <= 2:
+            return n
+        i = 0
+        while i < n - 1:
+            if nums[i] == nums[i + 1]:
+                j = i + 2
+                cnt = 0
+                while j < n and nums[i] == nums[j]:
+                    j += 1
+                    cnt += 1
+                for k in range(i + 2, n):
+                    if j >= n:
+                        break
+                    nums[k] = nums[j]
+                    j += 1
+                n -= cnt
+                i += 2
+            else:
+                i += 1
+        return n
+```
+
+```java
+public class Solution {
+    public int removeDuplicates(int[] nums) {
+        int n = nums.length;
+        if (n <= 2) return n;
+        int i = 0;
+        while (i < n - 1) {
+            if (nums[i] == nums[i + 1]) {
+                int j = i + 2, cnt = 0;
+                while (j < n && nums[i] == nums[j]) {
+                    j++;
+                    cnt++;
+                }
+                for (int k = i + 2; k < n; k++) {
+                    if (j >= n) break;
+                    nums[k] = nums[j++];
+                }
+                n -= cnt;
+                i += 2;
+            } else {
+                i++;
+            }
+        }
+        return n;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int n = nums.size();
+        if (n <= 2) return n;
+        int i = 0;
+        while (i < n - 1) {
+            if (nums[i] == nums[i + 1]) {
+                int j = i + 2, cnt = 0;
+                while (j < n && nums[i] == nums[j]) {
+                    j++;
+                    cnt++;
+                }
+                for (int k = i + 2; k < n; k++) {
+                    if (j >= n) break;
+                    nums[k] = nums[j++];
+                }
+                n -= cnt;
+                i += 2;
+            } else {
+                i++;
+            }
+        }
+        return n;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    removeDuplicates(nums) {
+        let n = nums.length;
+        if (n <= 2) return n;
+        let i = 0;
+        while (i < n - 1) {
+            if (nums[i] === nums[i + 1]) {
+                let j = i + 2, cnt = 0;
+                while (j < n && nums[i] === nums[j]) {
+                    j++;
+                    cnt++;
+                }
+                for (let k = i + 2; k < n; k++) {
+                    if (j >= n) break;
+                    nums[k] = nums[j++];
+                }
+                n -= cnt;
+                i += 2;
+            } else {
+                i++;
+            }
+        }
+        return n;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 2. Hash Map
+
+::tabs-start
+
+```python
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n <= 2:
+            return n
+        
+        count = Counter(nums)
+        i = 0
+        for num in count:
+            nums[i] = num
+            count[num] -= 1
+            i += 1
+            if count[num] >= 1:
+                nums[i] = num
+                count[num] -= 1
+                i += 1
+        return i
+```
+
+```java
+public class Solution {
+    public int removeDuplicates(int[] nums) {
+        Map<Integer, Integer> count = new HashMap<>();
+        List<Integer> arr = new ArrayList<>();
+        for (int num : nums) {
+            count.put(num, count.getOrDefault(num, 0) + 1);
+            if (count.get(num) == 1) {
+                arr.add(num);
+            }
+        }
+
+        int i = 0;
+        for (int num : arr) {
+            nums[i++] = num;
+            count.put(num, count.get(num) - 1);
+            if (count.get(num) >= 1) {
+                nums[i++] = num;
+                count.put(num, count.get(num) - 1);
+            }
+        }
+        return i;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        unordered_map<int, int> count;
+        vector<int> arr;
+        for (int& num : nums) {
+            count[num]++;
+            if (count[num] == 1) {
+                arr.push_back(num);
+            }
+        }
+
+        int i = 0;
+        for (auto& num : arr) {
+            int& cnt = count[num];
+            nums[i++] = num;
+            cnt--;
+            if (cnt >= 1) {
+                nums[i++] = num;
+                cnt--;
+            }
+        }
+        return i;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    removeDuplicates(nums) {
+        const count = new Map();
+        for (const num of nums) {
+            count.set(num, (count.get(num) || 0) + 1);
+        }
+
+        let i = 0;
+        for (const [num, cnt] of count) {
+            nums[i++] = num;
+            count.set(num, cnt - 1);
+            if (count.get(num) >= 1) {
+                nums[i++] = num;
+                count.set(num, cnt - 1);
+            }
+        }
+        return i;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Two Pointers
+
+::tabs-start
+
+```python
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        l, r = 0, 0
+
+        while r < len(nums):
+            count = 1
+            while r + 1 < len(nums) and nums[r] == nums[r + 1]:
+                r += 1
+                count += 1
+
+            for i in range(min(2, count)):
+                nums[l] = nums[r]
+                l += 1
+            r += 1
+        
+        return l
+```
+
+```java
+public class Solution {
+    public int removeDuplicates(int[] nums) {
+        int l = 0, r = 0;
+
+        while (r < nums.length) {
+            int count = 1;
+            while (r + 1 < nums.length && nums[r] == nums[r + 1]) {
+                r++;
+                count++;
+            }
+
+            for (int i = 0; i < Math.min(2, count); i++) {
+                nums[l] = nums[r];
+                l++;
+            }
+            r++;
+        }
+        
+        return l;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int l = 0, r = 0;
+
+        while (r < nums.size()) {
+            int count = 1;
+            while (r + 1 < nums.size() && nums[r] == nums[r + 1]) {
+                r++;
+                count++;
+            }
+
+            for (int i = 0; i < min(2, count); i++) {
+                nums[l] = nums[r];
+                l++;
+            }
+            r++;
+        }
+        
+        return l;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    removeDuplicates(nums) {
+        let l = 0, r = 0;
+
+        while (r < nums.length) {
+            let count = 1;
+            while (r + 1 < nums.length && nums[r] === nums[r + 1]) {
+                r++;
+                count++;
+            }
+
+            for (let i = 0; i < Math.min(2, count); i++) {
+                nums[l] = nums[r];
+                l++;
+            }
+            r++;
+        }
+        
+        return l;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 4. Two Pointers (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        l = 0
+        for num in nums:
+            if l < 2 or num != nums[l - 2]:
+                nums[l] = num
+                l += 1
+        return l
+```
+
+```java
+public class Solution {
+    public int removeDuplicates(int[] nums) {
+        int l = 0;
+        for (int num : nums) {
+            if (l < 2 || num != nums[l - 2]) {
+                nums[l] = num;
+                l++;
+            }
+        }
+        return l;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        int l = 0;
+        for (int num : nums) {
+            if (l < 2 || num != nums[l - 2]) {
+                nums[l] = num;
+                l++;
+            }
+        }
+        return l;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    removeDuplicates(nums) {
+        let l = 0;
+        for (let num of nums) {
+            if (l < 2 || num !== nums[l - 2]) {
+                nums[l] = num;
+                l++;
+            }
+        }
+        return l;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
\ No newline at end of file
diff --git a/articles/sequential-digits.md b/articles/sequential-digits.md
new file mode 100644
index 000000000..b1f6bb8b8
--- /dev/null
+++ b/articles/sequential-digits.md
@@ -0,0 +1,579 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def sequentialDigits(self, low: int, high: int) -> List[int]:
+        res = []
+
+        for num in range(low, high + 1):
+            s = str(num)
+            flag = True
+            for i in range(1, len(s)):
+                if ord(s[i]) - ord(s[i - 1]) != 1:
+                    flag = False
+                    break
+            if flag:
+                res.append(num)
+
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> sequentialDigits(int low, int high) {
+        List<Integer> res = new ArrayList<>();
+        for (int num = low; num <= high; num++) {
+            String s = String.valueOf(num);
+            boolean flag = true;
+            for (int i = 1; i < s.length(); i++) {
+                if (s.charAt(i) - s.charAt(i - 1) != 1) {
+                    flag = false;
+                    break;
+                }
+            }
+            if (flag) {
+                res.add(num);
+            }
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> sequentialDigits(int low, int high) {
+        vector<int> res;
+        for (int num = low; num <= high; num++) {
+            string s = to_string(num);
+            bool flag = true;
+            for (int i = 1; i < s.size(); i++) {
+                if (s[i] - s[i - 1] != 1) {
+                    flag = false;
+                    break;
+                }
+            }
+            if (flag) {
+                res.push_back(num);
+            }
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} low
+     * @param {number} high
+     * @return {number[]}
+     */
+    sequentialDigits(low, high) {
+        const res = [];
+        for (let num = low; num <= high; num++) {
+            const s = num.toString();
+            let flag = true;
+            for (let i = 1; i < s.length; i++) {
+                if (s.charCodeAt(i) - s.charCodeAt(i - 1) !== 1) {
+                    flag = false;
+                    break;
+                }
+            }
+            if (flag) {
+                res.push(num);
+            }
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
+
+---
+
+## 2. Simulation
+
+::tabs-start
+
+```python
+class Solution:
+    def sequentialDigits(self, low: int, high: int) -> List[int]:
+        res = []
+        low_digit, high_digit = len(str(low)), len(str(high))
+        
+        for digits in range(low_digit, high_digit + 1):
+            for start in range(1, 10):
+                if start + digits > 10:
+                    break
+                num = start
+                prev = start
+                for i in range(digits - 1):
+                    num = num * 10
+                    prev += 1
+                    num += prev
+                if low <= num <= high:
+                    res.append(num)
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> sequentialDigits(int low, int high) {
+        List<Integer> res = new ArrayList<>();
+        int lowDigit = String.valueOf(low).length();
+        int highDigit = String.valueOf(high).length();
+        
+        for (int digits = lowDigit; digits <= highDigit; digits++) {
+            for (int start = 1; start < 10; start++) {
+                if (start + digits > 10) {
+                    break;
+                }
+                int num = start;
+                int prev = start;
+                for (int i = 1; i < digits; i++) {
+                    num = num * 10 + (++prev);
+                }
+                if (num >= low && num <= high) {
+                    res.add(num);
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> sequentialDigits(int low, int high) {
+        vector<int> res;
+        int lowDigit = to_string(low).length();
+        int highDigit = to_string(high).length();
+        
+        for (int digits = lowDigit; digits <= highDigit; digits++) {
+            for (int start = 1; start < 10; start++) {
+                if (start + digits > 10) {
+                    break;
+                }
+                int num = start;
+                int prev = start;
+                for (int i = 1; i < digits; i++) {
+                    num = num * 10 + (++prev);
+                }
+                if (num >= low && num <= high) {
+                    res.push_back(num);
+                }
+            }
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} low
+     * @param {number} high
+     * @return {number[]}
+     */
+    sequentialDigits(low, high) {
+        const res = [];
+        const lowDigit = low.toString().length;
+        const highDigit = high.toString().length;
+        
+        for (let digits = lowDigit; digits <= highDigit; digits++) {
+            for (let start = 1; start < 10; start++) {
+                if (start + digits > 10) {
+                    break;
+                }
+                let num = start;
+                let prev = start;
+                for (let i = 1; i < digits; i++) {
+                    num = num * 10 + (++prev);
+                }
+                if (num >= low && num <= high) {
+                    res.push(num);
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(1)$
+* Space complexity: $O(1)$
+
+> Since, we have at most $36$ valid numbers as per the given constraints.
+
+---
+
+## 3. Breadth First Search
+
+::tabs-start
+
+```python
+class Solution:
+    def sequentialDigits(self, low: int, high: int) -> List[int]:
+        res = []
+        queue = deque(range(1, 10))
+        
+        while queue:
+            n = queue.popleft()
+            if n > high:
+                continue
+            if low <= n <= high:
+                res.append(n)
+            ones = n % 10
+            if ones < 9:
+                queue.append(n * 10 + (ones + 1))
+        
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> sequentialDigits(int low, int high) {
+        List<Integer> res = new ArrayList<>();
+        Queue<Integer> queue = new LinkedList<>();
+        
+        for (int i = 1; i < 10; i++) {
+            queue.add(i);
+        }
+        
+        while (!queue.isEmpty()) {
+            int n = queue.poll();
+            if (n > high) {
+                continue;
+            }
+            if (n >= low && n <= high) {
+                res.add(n);
+            }
+            int ones = n % 10;
+            if (ones < 9) {
+                queue.add(n * 10 + (ones + 1));
+            }
+        }
+        
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> sequentialDigits(int low, int high) {
+        vector<int> res;
+        queue<int> queue;
+        
+        for (int i = 1; i < 10; i++) {
+            queue.push(i);
+        }
+        
+        while (!queue.empty()) {
+            int n = queue.front();
+            queue.pop();
+            
+            if (n > high) {
+                continue;
+            }
+            if (n >= low && n <= high) {
+                res.push_back(n);
+            }
+            int ones = n % 10;
+            if (ones < 9) {
+                queue.push(n * 10 + (ones + 1));
+            }
+        }
+        
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} low
+     * @param {number} high
+     * @return {number[]}
+     */
+    sequentialDigits(low, high) {
+        const res = [];
+        const queue = new Queue();
+        for (let i = 1; i < 9; i++) {
+            queue.push(i);
+        }
+        
+        while (!queue.isEmpty()) {
+            const n = queue.pop();
+            if (n > high) {
+                continue;
+            }
+            if (n >= low && n <= high) {
+                res.push(n);
+            }
+            const ones = n % 10;
+            if (ones < 9) {
+                queue.push(n * 10 + (ones + 1));
+            }
+        }
+        
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(1)$
+* Space complexity: $O(1)$
+
+> Since, we have at most $36$ valid numbers as per the given constraints.
+
+---
+
+## 4. Depth First Search
+
+::tabs-start
+
+```python
+class Solution:
+    def sequentialDigits(self, low: int, high: int) -> List[int]:
+        res = []
+
+        def dfs(num):
+            if num > high:
+                return
+            if low <= num <= high:
+                res.append(num)
+            last_digit = num % 10
+            if last_digit < 9:
+                dfs(num * 10 + (last_digit + 1))
+
+        for i in range(1, 10):
+            dfs(i)
+
+        return sorted(res)
+```
+
+```java
+public class Solution {
+    public List<Integer> sequentialDigits(int low, int high) {
+        List<Integer> res = new ArrayList<>();
+
+        for (int i = 1; i < 10; i++) {
+            dfs(i, low, high, res);
+        }
+
+        Collections.sort(res);
+        return res;
+    }
+
+    private void dfs(int num, int low, int high, List<Integer> res) {
+        if (num > high) {
+            return;
+        }
+        if (num >= low) {
+            res.add(num);
+        }
+        int lastDigit = num % 10;
+        if (lastDigit < 9) {
+            dfs(num * 10 + (lastDigit + 1), low, high, res);
+        }
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> sequentialDigits(int low, int high) {
+        vector<int> res;
+        for (int i = 1; i < 10; i++) {
+            dfs(i, low, high, res);
+        }
+        sort(res.begin(), res.end());
+        return res;
+    }
+
+private:
+    void dfs(int num, int low, int high, vector<int>& res) {
+        if (num > high) {
+            return;
+        }
+        if (num >= low) {
+            res.push_back(num);
+        }
+        int lastDigit = num % 10;
+        if (lastDigit < 9) {
+            dfs(num * 10 + (lastDigit + 1), low, high, res);
+        }
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} low
+     * @param {number} high
+     * @return {number[]}
+     */
+    sequentialDigits(low, high) {
+        const res = [];
+
+        const dfs = (num) => {
+            if (num > high) {
+                return;
+            }
+            if (num >= low) {
+                res.push(num);
+            }
+            const lastDigit = num % 10;
+            if (lastDigit < 9) {
+                dfs(num * 10 + (lastDigit + 1));
+            }
+        };
+
+        for (let i = 1; i < 10; i++) {
+            dfs(i);
+        }
+
+        return res.sort((a, b) => a - b);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(1)$
+* Space complexity: $O(1)$
+
+> Since, we have at most $36$ valid numbers as per the given constraints.
+
+---
+
+## 5. Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def sequentialDigits(self, low: int, high: int) -> List[int]:
+        nums = "123456789"
+        res = []
+        for d in range(2, 10):
+            for i in range(9 - d + 1):
+                num = int(nums[i: i + d])
+                if num > high:
+                    break
+                if low <= num <= high:
+                    res.append(num)
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> sequentialDigits(int low, int high) {
+        String nums = "123456789";
+        List<Integer> res = new ArrayList<>();
+        
+        for (int d = 2; d <= 9; d++) {
+            for (int i = 0; i <= 9 - d; i++) {
+                int num = Integer.parseInt(nums.substring(i, i + d));
+                if (num > high) {
+                    break;
+                }
+                if (num >= low && num <= high) {
+                    res.add(num);
+                }
+            }
+        }
+        
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> sequentialDigits(int low, int high) {
+        string nums = "123456789";
+        vector<int> res;
+
+        for (int d = 2; d <= 9; d++) {
+            for (int i = 0; i <= 9 - d; i++) {
+                int num = stoi(nums.substr(i, d));
+                if (num > high) {
+                    break;
+                }
+                if (num >= low && num <= high) {
+                    res.push_back(num);
+                }
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number} low
+     * @param {number} high
+     * @return {number[]}
+     */
+    sequentialDigits(low, high) {
+        const nums = "123456789";
+        const res = [];
+
+        for (let d = 2; d <= 9; d++) {
+            for (let i = 0; i <= 9 - d; i++) {
+                const num = parseInt(nums.substring(i, i + d));
+                if (num > high) {
+                    break;
+                }
+                if (num >= low && num <= high) {
+                    res.push(num);
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(1)$
+* Space complexity: $O(1)$
+
+> Since, we have at most $36$ valid numbers as per the given constraints.
\ No newline at end of file

From e53c827226a754c02ddb96d2f053ea2bf06d3289 Mon Sep 17 00:00:00 2001
From: Sri Hari <kataresrihari@gmail.com>
Date: Fri, 24 Jan 2025 22:53:02 +0530
Subject: [PATCH 2/4] Batch-5/Neetcode-ALL/Added-articles

---
 articles/binary-subarrays-with-sum.md         | 381 ++++++++++++
 articles/find-all-duplicates-in-an-array.md   | 440 +++++++++++++
 .../get-equal-substrings-within-budget.md     | 274 +++++++++
 .../minimum-operations-to-reduce-x-to-zero.md | 577 ++++++++++++++++++
 ...inimum-remove-to-make-valid-parentheses.md | 522 ++++++++++++++++
 5 files changed, 2194 insertions(+)
 create mode 100644 articles/binary-subarrays-with-sum.md
 create mode 100644 articles/find-all-duplicates-in-an-array.md
 create mode 100644 articles/get-equal-substrings-within-budget.md
 create mode 100644 articles/minimum-operations-to-reduce-x-to-zero.md
 create mode 100644 articles/minimum-remove-to-make-valid-parentheses.md

diff --git a/articles/binary-subarrays-with-sum.md b/articles/binary-subarrays-with-sum.md
new file mode 100644
index 000000000..65a07ca78
--- /dev/null
+++ b/articles/binary-subarrays-with-sum.md
@@ -0,0 +1,381 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:
+        n, res = len(nums), 0
+
+        for i in range(n):
+            curSum = 0
+            for j in range(i, n):
+                curSum += nums[j]
+                if curSum == goal:
+                    res += 1
+
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubarraysWithSum(int[] nums, int goal) {
+        int n = nums.length, res = 0;
+
+        for (int i = 0; i < n; i++) {
+            int curSum = 0;
+            for (int j = i; j < n; j++) {
+                curSum += nums[j];
+                if (curSum == goal) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        int n = nums.size(), res = 0;
+
+        for (int i = 0; i < n; i++) {
+            int curSum = 0;
+            for (int j = i; j < n; j++) {
+                curSum += nums[j];
+                if (curSum == goal) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} goal
+     * @return {number}
+     */
+    numSubarraysWithSum(nums, goal) {
+        const n = nums.length;
+        let res = 0;
+
+        for (let i = 0; i < n; i++) {
+            let curSum = 0;
+            for (let j = i; j < n; j++) {
+                curSum += nums[j];
+                if (curSum === goal) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$
+
+---
+
+## 2. Prefix Sum + Hash Map
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:
+        prefixSum = 0
+        count = { 0 : 1 } # prefixSum -> count
+        res = 0
+
+        for num in nums:
+            prefixSum += num
+            res += count.get(prefixSum - goal, 0)
+            count[prefixSum] = count.get(prefixSum, 0) + 1
+
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubarraysWithSum(int[] nums, int goal) {
+        int prefixSum = 0, res = 0;
+        HashMap<Integer, Integer> count = new HashMap<>();
+        count.put(0, 1);
+
+        for (int num : nums) {
+            prefixSum += num;
+            res += count.getOrDefault(prefixSum - goal, 0);
+            count.put(prefixSum, count.getOrDefault(prefixSum, 0) + 1);
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        int prefixSum = 0, res = 0;
+        unordered_map<int, int> count;
+        count[0] = 1;
+
+        for (int& num : nums) {
+            prefixSum += num;
+            res += count[prefixSum - goal];
+            count[prefixSum]++;
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} goal
+     * @return {number}
+     */
+    numSubarraysWithSum(nums, goal) {
+        let prefixSum = 0, res = 0;
+        const count = new Map();
+        count.set(0, 1);
+
+        for (const num of nums) {
+            prefixSum += num;
+            res += count.get(prefixSum - goal) || 0;
+            count.set(prefixSum, (count.get(prefixSum) || 0) + 1);
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Prefix Sum + Array
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:
+        n = len(nums)
+        count = [0] * (n + 1)
+        count[0] = 1
+        prefixSum, res = 0, 0
+
+        for num in nums:
+            prefixSum += num
+            if prefixSum >= goal:
+                res += count[prefixSum - goal]
+            count[prefixSum] += 1
+
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubarraysWithSum(int[] nums, int goal) {
+        int n = nums.length, prefixSum = 0, res = 0;
+        int[] count = new int[n + 1];
+        count[0] = 1;
+
+        for (int num : nums) {
+            prefixSum += num;
+            if (prefixSum >= goal) {
+                res += count[prefixSum - goal];
+            }
+            count[prefixSum]++;
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        int n = nums.size(), prefixSum = 0, res = 0;
+        vector<int> count(n + 1, 0);
+        count[0] = 1;
+
+        for (int num : nums) {
+            prefixSum += num;
+            if (prefixSum >= goal) {
+                res += count[prefixSum - goal];
+            }
+            count[prefixSum]++;
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} goal
+     * @return {number}
+     */
+    numSubarraysWithSum(nums, goal) {
+        const n = nums.length;
+        const count = Array(n + 1).fill(0);
+        count[0] = 1;
+        let prefixSum = 0, res = 0;
+
+        for (const num of nums) {
+            prefixSum += num;
+            if (prefixSum >= goal) {
+                res += count[prefixSum - goal];
+            }
+            count[prefixSum]++;
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:
+        def helper(x):
+            if x < 0:
+                return 0
+            res = l = cur = 0
+            for r in range(len(nums)):
+                cur += nums[r]
+                while cur > x:
+                    cur -= nums[l]
+                    l += 1
+                res += (r - l + 1)
+            return res
+
+        return helper(goal) - helper(goal - 1)
+```
+
+```java
+public class Solution {
+    public int numSubarraysWithSum(int[] nums, int goal) {
+        return helper(nums, goal) - helper(nums, goal - 1);
+    }
+    
+    private int helper(int[] nums, int x) {
+        if (x < 0) return 0;
+        int res = 0, l = 0, cur = 0;
+        for (int r = 0; r < nums.length; r++) {
+            cur += nums[r];
+            while (cur > x) {
+                cur -= nums[l];
+                l++;
+            }
+            res += (r - l + 1);
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubarraysWithSum(vector<int>& nums, int goal) {
+        return helper(nums, goal) - helper(nums, goal - 1);
+    }
+    
+private:
+    int helper(vector<int>& nums, int x) {
+        if (x < 0) return 0;
+        int res = 0, l = 0, cur = 0;
+        for (int r = 0; r < nums.size(); r++) {
+            cur += nums[r];
+            while (cur > x) {
+                cur -= nums[l];
+                l++;
+            }
+            res += (r - l + 1);
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} goal
+     * @return {number}
+     */
+    numSubarraysWithSum(nums, goal) {
+        const helper = (x) => {
+            if (x < 0) return 0;
+            let res = 0, l = 0, cur = 0;
+            for (let r = 0; r < nums.length; r++) {
+                cur += nums[r];
+                while (cur > x) {
+                    cur -= nums[l];
+                    l++;
+                }
+                res += (r - l + 1);
+            }
+            return res;
+        };
+
+        return helper(goal) - helper(goal - 1);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
\ No newline at end of file
diff --git a/articles/find-all-duplicates-in-an-array.md b/articles/find-all-duplicates-in-an-array.md
new file mode 100644
index 000000000..3d1f99fde
--- /dev/null
+++ b/articles/find-all-duplicates-in-an-array.md
@@ -0,0 +1,440 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def findDuplicates(self, nums: List[int]) -> List[int]:
+        n = len(nums)
+        res = []
+
+        for i in range(n):
+            for j in range(i + 1, n):
+                if nums[i] == nums[j]:
+                    res.append(nums[i])
+                    break
+
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> findDuplicates(int[] nums) {
+        int n = nums.length;
+        List<Integer> res = new ArrayList<>();
+
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums[i] == nums[j]) {
+                    res.add(nums[i]);
+                    break;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> findDuplicates(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> res;
+
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums[i] == nums[j]) {
+                    res.push_back(nums[i]);
+                    break;
+                }
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    findDuplicates(nums) {
+        const n = nums.length;
+        const res = [];
+
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                if (nums[i] === nums[j]) {
+                    res.push(nums[i]);
+                    break;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 2. Sorting
+
+::tabs-start
+
+```python
+class Solution:
+    def findDuplicates(self, nums: List[int]) -> List[int]:
+        nums.sort()
+        res = []
+
+        for i in range(len(nums) - 1):
+            if nums[i] == nums[i + 1]:
+                res.append(nums[i])
+
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> findDuplicates(int[] nums) {
+        Arrays.sort(nums);
+        List<Integer> res = new ArrayList<>();
+
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] == nums[i + 1]) {
+                res.add(nums[i]);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> findDuplicates(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        vector<int> res;
+
+        for (int i = 0; i < nums.size() - 1; i++) {
+            if (nums[i] == nums[i + 1]) {
+                res.push_back(nums[i]);
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    findDuplicates(nums) {
+        nums.sort((a, b) => a - b);
+        const res = [];
+
+        for (let i = 0; i < nums.length - 1; i++) {
+            if (nums[i] === nums[i + 1]) {
+                res.push(nums[i]);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
+
+---
+
+## 3. Hash Set
+
+::tabs-start
+
+```python
+class Solution:
+    def findDuplicates(self, nums: List[int]) -> List[int]:
+        seen = set()
+        res = []
+        for num in nums:
+            if num in seen:
+                res.append(num)
+            else:
+                seen.add(num)
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> findDuplicates(int[] nums) {
+        Set<Integer> seen = new HashSet<>();
+        List<Integer> res = new ArrayList<>();
+
+        for (int num : nums) {
+            if (seen.contains(num)) {
+                res.add(num);
+            } else {
+                seen.add(num);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> findDuplicates(vector<int>& nums) {
+        unordered_set<int> seen;
+        vector<int> res;
+
+        for (int num : nums) {
+            if (seen.count(num)) {
+                res.push_back(num);
+            } else {
+                seen.insert(num);
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    findDuplicates(nums) {
+        const seen = new Set();
+        const res = [];
+
+        for (const num of nums) {
+            if (seen.has(num)) {
+                res.push(num);
+            } else {
+                seen.add(num);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Hash Map
+
+::tabs-start
+
+```python
+class Solution:
+    def findDuplicates(self, nums: List[int]) -> List[int]:
+        count = Counter(nums)
+        res = []
+
+        for num in count:
+            if count[num] == 2:
+                res.append(num)
+        
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> findDuplicates(int[] nums) {
+        Map<Integer, Integer> count = new HashMap<>();
+        List<Integer> res = new ArrayList<>();
+
+        for (int num : nums) {
+            count.put(num, count.getOrDefault(num, 0) + 1);
+        }
+
+        for (int num : count.keySet()) {
+            if (count.get(num) == 2) {
+                res.add(num);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> findDuplicates(vector<int>& nums) {
+        unordered_map<int, int> count;
+        vector<int> res;
+
+        for (int num : nums) {
+            count[num]++;
+        }
+
+        for (auto& [num, freq] : count) {
+            if (freq == 2) {
+                res.push_back(num);
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    findDuplicates(nums) {
+        const count = new Map();
+        const res = [];
+
+        for (const num of nums) {
+            count.set(num, (count.get(num) || 0) + 1);
+        }
+
+        for (const [num, freq] of count.entries()) {
+            if (freq === 2) {
+                res.push(num);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 5. Negative Marking
+
+::tabs-start
+
+```python
+class Solution:
+    def findDuplicates(self, nums: List[int]) -> List[int]:
+        res = []
+
+        for num in nums:
+            idx = abs(num) - 1
+            if nums[idx] < 0:
+                res.append(abs(num))
+            nums[idx] = -nums[idx]
+        
+        return res
+```
+
+```java
+public class Solution {
+    public List<Integer> findDuplicates(int[] nums) {
+        List<Integer> res = new ArrayList<>();
+
+        for (int num : nums) {
+            int idx = Math.abs(num) - 1;
+            if (nums[idx] < 0) {
+                res.add(Math.abs(num));
+            }
+            nums[idx] = -nums[idx];
+        }
+        
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> findDuplicates(vector<int>& nums) {
+        vector<int> res;
+
+        for (int num : nums) {
+            int idx = abs(num) - 1;
+            if (nums[idx] < 0) {
+                res.push_back(abs(num));
+            }
+            nums[idx] = -nums[idx];
+        }
+        
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number[]}
+     */
+    findDuplicates(nums) {
+        const res = [];
+
+        for (let num of nums) {
+            const idx = Math.abs(num) - 1;
+            if (nums[idx] < 0) {
+                res.push(Math.abs(num));
+            }
+            nums[idx] = -nums[idx];
+        }
+        
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
\ No newline at end of file
diff --git a/articles/get-equal-substrings-within-budget.md b/articles/get-equal-substrings-within-budget.md
new file mode 100644
index 000000000..078230575
--- /dev/null
+++ b/articles/get-equal-substrings-within-budget.md
@@ -0,0 +1,274 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
+        n = len(s)
+        res = 0
+
+        for i in range(n):
+            cur_cost = 0
+            for j in range(i, n):
+                cur_cost += abs(ord(t[j]) - ord(s[j]))
+                if cur_cost > maxCost:
+                    break
+                res = max(res, j - i + 1)
+
+        return res
+```
+
+```java
+public class Solution {
+    public int equalSubstring(String s, String t, int maxCost) {
+        int n = s.length();
+        int res = 0;
+
+        for (int i = 0; i < n; i++) {
+            int curCost = 0;
+            for (int j = i; j < n; j++) {
+                curCost += Math.abs(t.charAt(j) - s.charAt(j));
+                if (curCost > maxCost) {
+                    break;
+                }
+                res = Math.max(res, j - i + 1);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int equalSubstring(string s, string t, int maxCost) {
+        int n = s.size();
+        int res = 0;
+
+        for (int i = 0; i < n; i++) {
+            int curCost = 0;
+            for (int j = i; j < n; j++) {
+                curCost += abs(t[j] - s[j]);
+                if (curCost > maxCost) {
+                    break;
+                }
+                res = max(res, j - i + 1);
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @param {string} t
+     * @param {number} maxCost
+     * @return {number}
+     */
+    equalSubstring(s, t, maxCost) {
+        const n = s.length;
+        let res = 0;
+
+        for (let i = 0; i < n; i++) {
+            let curCost = 0;
+            for (let j = i; j < n; j++) {
+                curCost += Math.abs(t.charCodeAt(j) - s.charCodeAt(j));
+                if (curCost > maxCost) {
+                    break;
+                }
+                res = Math.max(res, j - i + 1);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$
+
+---
+
+## 2. Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
+        curCost = 0
+        l = 0
+        res = 0
+
+        for r in range(len(s)):
+            curCost += abs(ord(s[r]) - ord(t[r]))
+            while curCost > maxCost:
+                curCost -= abs(ord(s[l]) - ord(t[l]))
+                l += 1
+            res = max(res, r - l + 1)
+
+        return res
+```
+
+```java
+public class Solution {
+    public int equalSubstring(String s, String t, int maxCost) {
+        int curCost = 0, l = 0, res = 0;
+
+        for (int r = 0; r < s.length(); r++) {
+            curCost += Math.abs(s.charAt(r) - t.charAt(r));
+            while (curCost > maxCost) {
+                curCost -= Math.abs(s.charAt(l) - t.charAt(l));
+                l++;
+            }
+            res = Math.max(res, r - l + 1);
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int equalSubstring(string s, string t, int maxCost) {
+        int curCost = 0, l = 0, res = 0;
+
+        for (int r = 0; r < s.length(); r++) {
+            curCost += abs(s[r] - t[r]);
+            while (curCost > maxCost) {
+                curCost -= abs(s[l] - t[l]);
+                l++;
+            }
+            res = max(res, r - l + 1);
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @param {string} t
+     * @param {number} maxCost
+     * @return {number}
+     */
+    equalSubstring(s, t, maxCost) {
+        let curCost = 0, l = 0, res = 0;
+
+        for (let r = 0; r < s.length; r++) {
+            curCost += Math.abs(s.charCodeAt(r) - t.charCodeAt(r));
+            while (curCost > maxCost) {
+                curCost -= Math.abs(s.charCodeAt(l) - t.charCodeAt(l));
+                l++;
+            }
+            res = Math.max(res, r - l + 1);
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
+
+---
+
+## 3. Sliding Window (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
+        l = 0
+        for r in range(len(s)):
+            maxCost -= abs(ord(s[r]) - ord(t[r]))
+            if maxCost < 0:
+                maxCost += abs(ord(s[l]) - ord(t[l]))
+                l += 1
+        return len(s) - l
+```
+
+```java
+public class Solution {
+    public int equalSubstring(String s, String t, int maxCost) {
+        int l = 0;
+        for (int r = 0; r < s.length(); r++) {
+            maxCost -= Math.abs(s.charAt(r) - t.charAt(r));
+            if (maxCost < 0) {
+                maxCost += Math.abs(s.charAt(l) - t.charAt(l));
+                l++;
+            }
+        }
+        return s.length() - l;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int equalSubstring(string s, string t, int maxCost) {
+        int l = 0;
+        for (int r = 0; r < s.length(); r++) {
+            maxCost -= abs(s[r] - t[r]);
+            if (maxCost < 0) {
+                maxCost += abs(s[l] - t[l]);
+                l++;
+            }
+        }
+        return s.length() - l;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @param {string} t
+     * @param {number} maxCost
+     * @return {number}
+     */
+    equalSubstring(s, t, maxCost) {
+        let l = 0;
+        for (let r = 0; r < s.length; r++) {
+            maxCost -= Math.abs(s.charCodeAt(r) - t.charCodeAt(r));
+            if (maxCost < 0) {
+                maxCost += Math.abs(s.charCodeAt(l) - t.charCodeAt(l));
+                l++;
+            }
+        }
+        return s.length - l;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
\ No newline at end of file
diff --git a/articles/minimum-operations-to-reduce-x-to-zero.md b/articles/minimum-operations-to-reduce-x-to-zero.md
new file mode 100644
index 000000000..e3b3ca2eb
--- /dev/null
+++ b/articles/minimum-operations-to-reduce-x-to-zero.md
@@ -0,0 +1,577 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def minOperations(self, nums: List[int], x: int) -> int:
+        n = len(nums)
+        res = n + 1
+        suffixSum = prefixSum = 0
+
+        for i in range(n - 1, -1, -1):
+            suffixSum += nums[i]
+            if suffixSum == x:
+                res = min(res, n - i)
+
+        for i in range(n):
+            prefixSum += nums[i]
+            suffixSum = 0
+            if prefixSum == x:
+                res = min(res, i + 1)
+
+            for j in range(n - 1, i, -1):
+                suffixSum += nums[j]
+                if prefixSum + suffixSum == x:
+                    res = min(res, i + 1 + n - j)
+        
+        return -1 if res == n + 1 else res
+```
+
+```java
+public class Solution {
+    public int minOperations(int[] nums, int x) {
+        int n = nums.length;
+        int res = n + 1;
+        int suffixSum = 0, prefixSum = 0;
+
+        for (int i = n - 1; i >= 0; i--) {
+            suffixSum += nums[i];
+            if (suffixSum == x) {
+                res = Math.min(res, n - i);
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            prefixSum += nums[i];
+            suffixSum = 0;
+            if (prefixSum == x) {
+                res = Math.min(res, i + 1);
+            }
+
+            for (int j = n - 1; j > i; j--) {
+                suffixSum += nums[j];
+                if (prefixSum + suffixSum == x) {
+                    res = Math.min(res, i + 1 + n - j);
+                }
+            }
+        }
+
+        return res == n + 1 ? -1 : res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minOperations(vector<int>& nums, int x) {
+        int n = nums.size();
+        int res = n + 1, suffixSum = 0, prefixSum = 0;
+
+        for (int i = n - 1; i >= 0; i--) {
+            suffixSum += nums[i];
+            if (suffixSum == x) {
+                res = min(res, n - i);
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            prefixSum += nums[i];
+            suffixSum = 0;
+            if (prefixSum == x) {
+                res = min(res, i + 1);
+            }
+
+            for (int j = n - 1; j > i; j--) {
+                suffixSum += nums[j];
+                if (prefixSum + suffixSum == x) {
+                    res = min(res, i + 1 + n - j);
+                }
+            }
+        }
+
+        return res == n + 1 ? -1 : res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} x
+     * @return {number}
+     */
+    minOperations(nums, x) {
+        const n = nums.length;
+        let res = n + 1, suffixSum = 0, prefixSum = 0;
+
+        for (let i = n - 1; i >= 0; i--) {
+            suffixSum += nums[i];
+            if (suffixSum === x) {
+                res = Math.min(res, n - i);
+            }
+        }
+
+        for (let i = 0; i < n; i++) {
+            prefixSum += nums[i];
+            suffixSum = 0;
+            if (prefixSum === x) {
+                res = Math.min(res, i + 1);
+            }
+
+            for (let j = n - 1; j > i; j--) {
+                suffixSum += nums[j];
+                if (prefixSum + suffixSum === x) {
+                    res = Math.min(res, i + 1 + n - j);
+                }
+            }
+        }
+
+        return res === n + 1 ? -1 : res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$ extra space.
+
+---
+
+## 2. Prefix Sum + Binary Search
+
+::tabs-start
+
+```python
+class Solution:
+    def minOperations(self, nums: List[int], x: int) -> int:
+        n = len(nums)
+        prefixSum = [0] * (n + 1)
+        for i in range(n):
+            prefixSum[i + 1] = prefixSum[i] + nums[i]
+        
+        if x > prefixSum[n]:
+            return -1
+
+        def binarySearch(target, m):
+            l, r = 1, m
+            index = n + 1
+
+            while l <= r:
+                mid = (l + r) >> 1
+                if prefixSum[mid] >= target:
+                    if prefixSum[mid] == target:
+                        index = mid
+                    r = mid - 1
+                else:
+                    l = mid + 1
+            
+            return index
+        
+        res = binarySearch(x, n)
+        suffixSum = 0
+        for i in range(n - 1, 0, -1):
+            suffixSum += nums[i]
+            if suffixSum == x:
+                res = min(res, n - i)
+                break
+            if suffixSum > x: break
+            res = min(res, binarySearch(x - suffixSum, i) + n - i)
+        
+        return -1 if res == n + 1 else res
+```
+
+```java
+public class Solution {
+    public int minOperations(int[] nums, int x) {
+        int n = nums.length;
+        int[] prefixSum = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i];
+        }
+        
+        if (x > prefixSum[n]) {
+            return -1;
+        }
+        
+        int res = binarySearch(prefixSum, x, n);
+        int suffixSum = 0;
+        for (int i = n - 1; i > 0; i--) {
+            suffixSum += nums[i];
+            if (suffixSum == x) {
+                res = Math.min(res, n - i);
+                break;
+            }
+            if (suffixSum > x) break;
+            res = Math.min(res, binarySearch(prefixSum, x - suffixSum, i) + n - i);
+        }
+        
+        return res == n + 1 ? -1 : res;
+    }
+
+    private int binarySearch(int[] prefixSum, int target, int m) {
+        int l = 1, r = m;
+        int index = prefixSum.length;
+
+        while (l <= r) {
+            int mid = (l + r) / 2;
+            if (prefixSum[mid] >= target) {
+                if (prefixSum[mid] == target) {
+                    index = mid;
+                }
+                r = mid - 1;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return index;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minOperations(vector<int>& nums, int x) {
+        int n = nums.size();
+        vector<int> prefixSum(n + 1, 0);
+        for (int i = 0; i < n; i++) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i];
+        }
+
+        if (x > prefixSum[n]) {
+            return -1;
+        }
+
+        auto binarySearch = [&](int target, int m) {
+            int l = 1, r = m, index = n + 1;
+            while (l <= r) {
+                int mid = (l + r) / 2;
+                if (prefixSum[mid] >= target) {
+                    if (prefixSum[mid] == target) {
+                        index = mid;
+                    }
+                    r = mid - 1;
+                } else {
+                    l = mid + 1;
+                }
+            }
+            return index;
+        };
+
+        int res = binarySearch(x, n);
+        int suffixSum = 0;
+        for (int i = n - 1; i > 0; i--) {
+            suffixSum += nums[i];
+            if (suffixSum == x) {
+                res = min(res, n - i);
+                break;
+            }
+            if (suffixSum > x) break;
+            res = min(res, binarySearch(x - suffixSum, i) + n - i);
+        }
+
+        return res == n + 1 ? -1 : res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} x
+     * @return {number}
+     */
+    minOperations(nums, x) {
+        const n = nums.length;
+        const prefixSum = new Array(n + 1).fill(0);
+        for (let i = 0; i < n; i++) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i];
+        }
+        
+        if (x > prefixSum[n]) return -1;
+
+        const binarySearch = (target, m) => {
+            let l = 1, r = m;
+            let index = n + 1;
+            while (l <= r) {
+                let mid = Math.floor((l + r) / 2);
+                if (prefixSum[mid] >= target) {
+                    if (prefixSum[mid] === target) {
+                        index = mid;
+                    }
+                    r = mid - 1;
+                } else {
+                    l = mid + 1;
+                }
+            }
+            return index;
+        };
+
+        let res = binarySearch(x, n);
+        let suffixSum = 0;
+        for (let i = n - 1; i > 0; i--) {
+            suffixSum += nums[i];
+            if (suffixSum === x) {
+                res = Math.min(res, n - i);
+                break;
+            }
+            if (suffixSum > x) break;
+            res = Math.min(res, binarySearch(x - suffixSum, i) + n - i);
+        }
+
+        return res === n + 1 ? -1 : res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Prefix Sum + Hash Map
+
+::tabs-start
+
+```python
+class Solution:
+    def minOperations(self, nums: List[int], x: int) -> int:
+        total = sum(nums)
+        if total == x:
+            return len(nums)
+
+        target = total - x
+        if target < 0:
+            return -1
+        
+        res = -1
+        prefixSum = 0
+        prefixMap = {0: -1}  # prefixSum -> index
+        
+        for i, num in enumerate(nums):
+            prefixSum += num
+            if prefixSum - target in prefixMap:
+                res = max(res, i - prefixMap[prefixSum - target])
+            prefixMap[prefixSum] = i
+        
+        return len(nums) - res if res != -1 else -1
+```
+
+```java
+public class Solution {
+    public int minOperations(int[] nums, int x) {
+        int total = 0;
+        for (int num : nums) total += num;
+        if (total == x) return nums.length;
+
+        int target = total - x;
+        if (target < 0) return -1;
+        
+        Map<Integer, Integer> prefixMap = new HashMap<>();
+        prefixMap.put(0, -1);
+        int prefixSum = 0, res = -1;
+
+        for (int i = 0; i < nums.length; i++) {
+            prefixSum += nums[i];
+            if (prefixMap.containsKey(prefixSum - target)) {
+                res = Math.max(res, i - prefixMap.get(prefixSum - target));
+            }
+            prefixMap.put(prefixSum, i);
+        }
+        
+        return res == -1 ? -1 : nums.length - res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minOperations(vector<int>& nums, int x) {
+        int total = 0;
+        for (int& num : nums) total += num;
+        if (total == x) return nums.size();
+
+        int target = total - x;
+        if (target < 0) return -1;
+        
+        unordered_map<int, int> prefixMap;
+        prefixMap[0] = -1;
+        int prefixSum = 0, res = -1;
+
+        for (int i = 0; i < nums.size(); i++) {
+            prefixSum += nums[i];
+            if (prefixMap.count(prefixSum - target)) {
+                res = max(res, i - prefixMap[prefixSum - target]);
+            }
+            prefixMap[prefixSum] = i;
+        }
+
+        return res == -1 ? -1 : nums.size() - res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} x
+     * @return {number}
+     */
+    minOperations(nums, x) {
+        const total = nums.reduce((acc, num) => acc + num, 0);
+        if (total === x) return nums.length;
+
+        const target = total - x;
+        if (target < 0) return -1;
+
+        const prefixMap = new Map();
+        prefixMap.set(0, -1);
+        let prefixSum = 0, res = -1;
+
+        for (let i = 0; i < nums.length; i++) {
+            prefixSum += nums[i];
+            if (prefixMap.has(prefixSum - target)) {
+                res = Math.max(res, i - prefixMap.get(prefixSum - target));
+            }
+            prefixMap.set(prefixSum, i);
+        }
+
+        return res === -1 ? -1 : nums.length - res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def minOperations(self, nums: List[int], x: int) -> int:
+        target = sum(nums) - x
+        cur_sum = 0
+        max_window = -1
+        l = 0
+
+        for r in range(len(nums)):
+            cur_sum += nums[r]
+
+            while l <= r and cur_sum > target:
+                cur_sum -= nums[l]
+                l += 1
+
+            if cur_sum == target:
+                max_window = max(max_window, r - l + 1)
+
+        return -1 if max_window == -1 else len(nums) - max_window
+```
+
+```java
+public class Solution {
+    public int minOperations(int[] nums, int x) {
+        int target = 0;
+        for (int num : nums) target += num;
+        target -= x;
+
+        int curSum = 0, maxWindow = -1, l = 0;
+
+        for (int r = 0; r < nums.length; r++) {
+            curSum += nums[r];
+
+            while (l <= r && curSum > target) {
+                curSum -= nums[l];
+                l++;
+            }
+
+            if (curSum == target) {
+                maxWindow = Math.max(maxWindow, r - l + 1);
+            }
+        }
+
+        return maxWindow == -1 ? -1 : nums.length - maxWindow;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minOperations(vector<int>& nums, int x) {
+        int target = accumulate(nums.begin(), nums.end(), 0) - x;
+        int curSum = 0, maxWindow = -1, l = 0;
+
+        for (int r = 0; r < nums.size(); r++) {
+            curSum += nums[r];
+
+            while (l <= r && curSum > target) {
+                curSum -= nums[l];
+                l++;
+            }
+
+            if (curSum == target) {
+                maxWindow = max(maxWindow, r - l + 1);
+            }
+        }
+
+        return maxWindow == -1 ? -1 : nums.size() - maxWindow;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} x
+     * @return {number}
+     */
+    minOperations(nums, x) {
+        const target = nums.reduce((acc, num) => acc + num, 0) - x;
+        let curSum = 0, maxWindow = -1, l = 0;
+
+        for (let r = 0; r < nums.length; r++) {
+            curSum += nums[r];
+
+            while (l <= r && curSum > target) {
+                curSum -= nums[l];
+                l++;
+            }
+
+            if (curSum === target) {
+                maxWindow = Math.max(maxWindow, r - l + 1);
+            }
+        }
+
+        return maxWindow === -1 ? -1 : nums.length - maxWindow;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ extra space.
\ No newline at end of file
diff --git a/articles/minimum-remove-to-make-valid-parentheses.md b/articles/minimum-remove-to-make-valid-parentheses.md
new file mode 100644
index 000000000..23627cf72
--- /dev/null
+++ b/articles/minimum-remove-to-make-valid-parentheses.md
@@ -0,0 +1,522 @@
+## 1. Stack
+
+::tabs-start
+
+```python
+class Solution:
+    def minRemoveToMakeValid(self, s: str) -> str:
+        res = []
+        cnt = 0  # extra ( parentheses
+        for c in s:
+            if c == "(":
+                res.append(c)
+                cnt += 1
+            elif c == ")" and cnt > 0:
+                res.append(c)
+                cnt -= 1
+            elif c != ")":
+                res.append(c)
+
+        filtered = []
+        for c in reversed(res):
+            if c == "(" and cnt > 0:
+                cnt -= 1
+            else:
+                filtered.append(c)
+        return "".join(reversed(filtered))
+```
+
+```java
+public class Solution {
+    public String minRemoveToMakeValid(String s) {
+        StringBuilder res = new StringBuilder();
+        int cnt = 0;
+
+        for (char c : s.toCharArray()) {
+            if (c == '(') {
+                res.append(c);
+                cnt++;
+            } else if (c == ')' && cnt > 0) {
+                res.append(c);
+                cnt--;
+            } else if (c != ')') {
+                res.append(c);
+            }
+        }
+
+        StringBuilder filtered = new StringBuilder();
+        for (int i = res.length() - 1; i >= 0; i--) {
+            char c = res.charAt(i);
+            if (c == '(' && cnt > 0) {
+                cnt--;
+            } else {
+                filtered.append(c);
+            }
+        }
+        return filtered.reverse().toString();
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string minRemoveToMakeValid(string s) {
+        string res;
+        int cnt = 0;
+
+        for (char c : s) {
+            if (c == '(') {
+                res.push_back(c);
+                cnt++;
+            } else if (c == ')' && cnt > 0) {
+                res.push_back(c);
+                cnt--;
+            } else if (c != ')') {
+                res.push_back(c);
+            }
+        }
+
+        string filtered;
+        for (int i = res.size() - 1; i >= 0; i--) {
+            char c = res[i];
+            if (c == '(' && cnt > 0) {
+                cnt--;
+            } else {
+                filtered.push_back(c);
+            }
+        }
+        reverse(filtered.begin(), filtered.end());
+        return filtered;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    minRemoveToMakeValid(s) {
+        let res = [];
+        let cnt = 0;
+
+        for (let c of s) {
+            if (c === '(') {
+                res.push(c);
+                cnt++;
+            } else if (c === ')' && cnt > 0) {
+                res.push(c);
+                cnt--;
+            } else if (c !== ')') {
+                res.push(c);
+            }
+        }
+
+        let filtered = [];
+        for (let i = res.length - 1; i >= 0; i--) {
+            let c = res[i];
+            if (c === '(' && cnt > 0) {
+                cnt--;
+            } else {
+                filtered.push(c);
+            }
+        }
+        return filtered.reverse().join('');
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 2. Without Stack
+
+::tabs-start
+
+```python
+class Solution:
+    def minRemoveToMakeValid(self, s: str) -> str:
+        arr = list(s)
+        cnt = 0  # extra ( parentheses
+        for i, c in enumerate(s):
+            if c == "(":
+                cnt += 1
+            elif c == ")" and cnt > 0:
+                cnt -= 1
+            elif c == ")":
+                arr[i] = ''
+        
+        res = []
+        for c in reversed(arr):
+            if c == '(' and cnt > 0:
+                cnt -= 1
+            else:
+                res.append(c)
+        
+        return ''.join(reversed(res))
+```
+
+```java
+public class Solution {
+    public String minRemoveToMakeValid(String s) {
+        char[] arr = s.toCharArray();
+        int cnt = 0;
+
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == '(') {
+                cnt++;
+            } else if (c == ')' && cnt > 0) {
+                cnt--;
+            } else if (c == ')') {
+                arr[i] = '\0';
+            }
+        }
+
+        StringBuilder res = new StringBuilder();
+        for (int i = arr.length - 1; i >= 0; i--) {
+            char c = arr[i];
+            if (c == '(' && cnt > 0) {
+                cnt--;
+            } else if (c != '\0') {
+                res.append(c);
+            }
+        }
+
+        return res.reverse().toString();
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string minRemoveToMakeValid(string s) {
+        vector<char> arr(s.begin(), s.end());
+        int cnt = 0;
+
+        for (int i = 0; i < s.size(); i++) {
+            if (s[i] == '(') {
+                cnt++;
+            } else if (s[i] == ')' && cnt > 0) {
+                cnt--;
+            } else if (s[i] == ')') {
+                arr[i] = '\0';
+            }
+        }
+
+        string res;
+        for (int i = arr.size() - 1; i >= 0; i--) {
+            if (arr[i] == '(' && cnt > 0) {
+                cnt--;
+            } else if (arr[i] != '\0') {
+                res.push_back(arr[i]);
+            }
+        }
+
+        reverse(res.begin(), res.end());
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    minRemoveToMakeValid(s) {
+        let arr = [...s];
+        let cnt = 0;
+
+        for (let i = 0; i < s.length; i++) {
+            let c = s[i];
+            if (c === '(') {
+                cnt++;
+            } else if (c === ')' && cnt > 0) {
+                cnt--;
+            } else if (c === ')') {
+                arr[i] = '';
+            }
+        }
+
+        let res = [];
+        for (let i = arr.length - 1; i >= 0; i--) {
+            let c = arr[i];
+            if (c === '(' && cnt > 0) {
+                cnt--;
+            } else if (c !== '') {
+                res.push(c);
+            }
+        }
+
+        return res.reverse().join('');
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Stack (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def minRemoveToMakeValid(self, s: str) -> str:
+        s = list(s)
+        stack = []
+        for i, c in enumerate(s):
+            if c == '(':
+                stack.append(i)
+            elif c == ')':
+                if stack:
+                    stack.pop()
+                else:
+                    s[i] = ''
+        
+        while stack:
+            s[stack.pop()] = ''
+        return ''.join(s)
+```
+
+```java
+public class Solution {
+    public String minRemoveToMakeValid(String s) {
+        StringBuilder sb = new StringBuilder(s);
+        Stack<Integer> stack = new Stack<>();
+
+        for (int i = 0; i < sb.length(); i++) {
+            if (sb.charAt(i) == '(') {
+                stack.push(i);
+            } else if (sb.charAt(i) == ')') {
+                if (!stack.isEmpty()) {
+                    stack.pop();
+                } else {
+                    sb.setCharAt(i, '\0');
+                }
+            }
+        }
+
+        while (!stack.isEmpty()) {
+            sb.setCharAt(stack.pop(), '\0');
+        }
+
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < sb.length(); i++) {
+            if (sb.charAt(i) != '\0') {
+                result.append(sb.charAt(i));
+            }
+        }
+        return result.toString();
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string minRemoveToMakeValid(string s) {
+        stack<int> stack;
+        for (int i = 0; i < s.size(); i++) {
+            if (s[i] == '(') {
+                stack.push(i);
+            } else if (s[i] == ')') {
+                if (!stack.empty()) {
+                    stack.pop();
+                } else {
+                    s[i] = '\0';
+                }
+            }
+        }
+
+        while (!stack.empty()) {
+            s[stack.top()] = '\0';
+            stack.pop();
+        }
+
+        string result;
+        for (char& c : s) {
+            if (c != '\0') {
+                result += c;
+            }
+        }
+        return result;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    minRemoveToMakeValid(s) {
+        const arr = [...s];
+        const stack = [];
+
+        for (let i = 0; i < arr.length; i++) {
+            if (arr[i] === '(') {
+                stack.push(i);
+            } else if (arr[i] === ')') {
+                if (stack.length > 0) {
+                    stack.pop();
+                } else {
+                    arr[i] = '';
+                }
+            }
+        }
+
+        while (stack.length > 0) {
+            arr[stack.pop()] = '';
+        }
+
+        return arr.join('');
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Without Stack (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def minRemoveToMakeValid(self, s: str) -> str:
+        openCnt = closeCnt = 0
+        for c in s:
+            closeCnt += c == ')'
+        
+        res = []
+        for c in s:
+            if c == '(':
+                if openCnt == closeCnt:
+                    continue
+                openCnt += 1
+            elif c == ')':
+                closeCnt -= 1
+                if openCnt == 0:
+                    continue
+                openCnt -= 1
+            res.append(c)
+        
+        return ''.join(res)
+```
+
+```java
+public class Solution {
+    public String minRemoveToMakeValid(String s) {
+        int openCnt = 0, closeCnt = 0;
+        for (char c : s.toCharArray()) {
+            if (c == ')') closeCnt++;
+        }
+        
+        StringBuilder res = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (c == '(') {
+                if (openCnt == closeCnt) continue;
+                openCnt++;
+            } else if (c == ')') {
+                closeCnt--;
+                if (openCnt == 0) continue;
+                openCnt--;
+            }
+            res.append(c);
+        }
+        
+        return res.toString();
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string minRemoveToMakeValid(string s) {
+        int openCnt = 0, closeCnt = 0;
+        for (char& c : s) {
+            if (c == ')') closeCnt++;
+        }
+        
+        string res;
+        for (char& c : s) {
+            if (c == '(') {
+                if (openCnt == closeCnt) continue;
+                openCnt++;
+            } else if (c == ')') {
+                closeCnt--;
+                if (openCnt == 0) continue;
+                openCnt--;
+            }
+            res.push_back(c);
+        }
+        
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    minRemoveToMakeValid(s) {
+        let openCnt = 0, closeCnt = 0;
+        for (const c of s) {
+            if (c === ')') closeCnt++;
+        }
+        
+        let res = [];
+        for (const c of s) {
+            if (c === '(') {
+                if (openCnt === closeCnt) continue;
+                openCnt++;
+            } else if (c === ')') {
+                closeCnt--;
+                if (openCnt === 0) continue;
+                openCnt--;
+            }
+            res.push(c);
+        }
+        
+        return res.join('');
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity:
+    * $O(1)$ extra space.
+    * $O(n)$ space for the output string.
\ No newline at end of file

From 3ee50e93b95108682f86d13c20870f4da88b0906 Mon Sep 17 00:00:00 2001
From: Sri Hari <kataresrihari@gmail.com>
Date: Sat, 25 Jan 2025 22:07:32 +0530
Subject: [PATCH 3/4] Batch-5/Neetcode-ALL/Added-articles

---
 ...re-max-element-appears-at-least-k-times.md | 589 ++++++++++++++++++
 ...ngest-subarray-with-at-most-k-frequency.md | 278 +++++++++
 ...-of-operations-to-make-array-continuous.md | 142 +++++
 articles/subarray-product-less-than-k.md      | 313 ++++++++++
 .../subarrays-with-k-different-integers.md    | 546 ++++++++++++++++
 5 files changed, 1868 insertions(+)
 create mode 100644 articles/count-subarrays-where-max-element-appears-at-least-k-times.md
 create mode 100644 articles/length-of-longest-subarray-with-at-most-k-frequency.md
 create mode 100644 articles/minimum-number-of-operations-to-make-array-continuous.md
 create mode 100644 articles/subarray-product-less-than-k.md
 create mode 100644 articles/subarrays-with-k-different-integers.md

diff --git a/articles/count-subarrays-where-max-element-appears-at-least-k-times.md b/articles/count-subarrays-where-max-element-appears-at-least-k-times.md
new file mode 100644
index 000000000..c4d2a5914
--- /dev/null
+++ b/articles/count-subarrays-where-max-element-appears-at-least-k-times.md
@@ -0,0 +1,589 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        n, res = len(nums), 0
+        maxi = max(nums)
+
+        for i in range(n):
+            cnt = 0
+            for j in range(i, n):
+                if nums[j] == maxi:
+                    cnt += 1
+                
+                if cnt >= k:
+                    res += 1
+        
+        return res
+```
+
+```java
+public class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int n = nums.length;
+        long res = 0;
+        int maxi = Integer.MIN_VALUE;
+
+        for (int num : nums) {
+            maxi = Math.max(maxi, num);
+        }
+
+        for (int i = 0; i < n; i++) {
+            int cnt = 0;
+            for (int j = i; j < n; j++) {
+                if (nums[j] == maxi) {
+                    cnt++;
+                }
+                
+                if (cnt >= k) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        int n = nums.size();
+        long long res = 0;
+        int maxi = *max_element(nums.begin(), nums.end());
+
+        for (int i = 0; i < n; i++) {
+            int cnt = 0;
+            for (int j = i; j < n; j++) {
+                if (nums[j] == maxi) {
+                    cnt++;
+                }
+                
+                if (cnt >= k) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    countSubarrays(nums, k) {
+        let n = nums.length, res = 0;
+        let maxi = Math.max(...nums);
+
+        for (let i = 0; i < n; i++) {
+            let cnt = 0;
+            for (let j = i; j < n; j++) {
+                if (nums[j] === maxi) {
+                    cnt++;
+                }
+                
+                if (cnt >= k) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$
+
+---
+
+## 2. Variable Size Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        max_n, max_cnt = max(nums), 0
+        l = 0
+        res = 0
+
+        for r in range(len(nums)):
+            if nums[r] == max_n:
+                max_cnt += 1
+            
+            while max_cnt > k or (l <= r and max_cnt == k and nums[l] != max_n):
+                if nums[l] == max_n:
+                    max_cnt -= 1
+                l += 1
+            
+            if max_cnt == k:
+                res += l + 1
+        
+        return res
+```
+
+```java
+public class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int maxN = Integer.MIN_VALUE, maxCnt = 0, l = 0;
+        long res = 0;
+        for (int num : nums) {
+            maxN = Math.max(maxN, num);
+        }
+
+        for (int r = 0; r < nums.length; r++) {
+            if (nums[r] == maxN) {
+                maxCnt++;
+            }
+
+            while (maxCnt > k || (l <= r && maxCnt == k && nums[l] != maxN)) {
+                if (nums[l] == maxN) {
+                    maxCnt--;
+                }
+                l++;
+            }
+
+            if (maxCnt == k) {
+                res += l + 1;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        int maxN = *max_element(nums.begin(), nums.end());
+        int maxCnt = 0, l = 0;
+        long long res = 0;
+
+        for (int r = 0; r < nums.size(); r++) {
+            if (nums[r] == maxN) {
+                maxCnt++;
+            }
+
+            while (maxCnt > k || (l <= r && maxCnt == k && nums[l] != maxN)) {
+                if (nums[l] == maxN) {
+                    maxCnt--;
+                }
+                l++;
+            }
+
+            if (maxCnt == k) {
+                res += l + 1;
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    countSubarrays(nums, k) {
+        let maxN = Math.max(...nums);
+        let maxCnt = 0, l = 0, res = 0;
+
+        for (let r = 0; r < nums.length; r++) {
+            if (nums[r] === maxN) {
+                maxCnt++;
+            }
+
+            while (maxCnt > k || (l <= r && maxCnt === k && nums[l] !== maxN)) {
+                if (nums[l] === maxN) {
+                    maxCnt--;
+                }
+                l++;
+            }
+
+            if (maxCnt === k) {
+                res += l + 1;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
+
+---
+
+## 3. Variable Size Sliding Window (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        max_n, max_cnt = max(nums), 0
+        l = res = 0
+
+        for r in range(len(nums)):
+            if nums[r] == max_n:
+                max_cnt += 1
+            while max_cnt == k:
+                if nums[l] == max_n:
+                    max_cnt -= 1
+                l += 1
+            res += l
+
+        return res
+```
+
+```java
+public class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int max_n = Integer.MIN_VALUE, max_cnt = 0, l = 0;
+        long res = 0;
+        for (int num : nums) {
+            max_n = Math.max(max_n, num);
+        }
+
+        for (int r = 0; r < nums.length; r++) {
+            if (nums[r] == max_n) {
+                max_cnt++;
+            }
+            while (max_cnt == k) {
+                if (nums[l] == max_n) {
+                    max_cnt--;
+                }
+                l++;
+            }
+            res += l;
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        int max_n = *max_element(nums.begin(), nums.end());
+        int max_cnt = 0, l = 0;
+        long long res = 0;
+
+        for (int r = 0; r < nums.size(); r++) {
+            if (nums[r] == max_n) {
+                max_cnt++;
+            }
+            while (max_cnt == k) {
+                if (nums[l] == max_n) {
+                    max_cnt--;
+                }
+                l++;
+            }
+            res += l;
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    countSubarrays(nums, k) {
+        let max_n = Math.max(...nums), max_cnt = 0, l = 0, res = 0;
+
+        for (let r = 0; r < nums.length; r++) {
+            if (nums[r] === max_n) {
+                max_cnt++;
+            }
+            while (max_cnt === k) {
+                if (nums[l] === max_n) {
+                    max_cnt--;
+                }
+                l++;
+            }
+            res += l;
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
+
+---
+
+## 4. Fixed Size Sliding Window + Math
+
+::tabs-start
+
+```python
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        max_n = max(nums)
+        max_indexes = [-1]
+        for i, num in enumerate(nums):
+            if num == max_n:
+                max_indexes.append(i)
+        
+        res = 0
+        for i in range(1, len(max_indexes) - k + 1):
+            cur = (max_indexes[i] - max_indexes[i - 1])
+            cur *= (n - max_indexes[i + k - 1])
+            res += cur
+        
+        return res
+```
+
+```java
+public class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int n = nums.length;
+        int max_n = Integer.MIN_VALUE;
+        for (int num : nums) {
+            max_n = Math.max(max_n, num);
+        }
+
+        List<Integer> max_indexes = new ArrayList<>();
+        max_indexes.add(-1);
+        for (int i = 0; i < n; i++) {
+            if (nums[i] == max_n) {
+                max_indexes.add(i);
+            }
+        }
+
+        long res = 0;
+        for (int i = 1; i <= max_indexes.size() - k; i++) {
+            long cur = (max_indexes.get(i) - max_indexes.get(i - 1));
+            cur *= (n - max_indexes.get(i + k - 1));
+            res += cur;
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        int n = nums.size();
+        int max_n = *max_element(nums.begin(), nums.end());
+        vector<int> max_indexes = {-1};
+
+        for (int i = 0; i < n; i++) {
+            if (nums[i] == max_n) {
+                max_indexes.push_back(i);
+            }
+        }
+
+        long long res = 0;
+        for (int i = 1; i <= int(max_indexes.size()) - k; i++) {
+            long long cur = (max_indexes[i] - max_indexes[i - 1]);
+            cur *= (n - max_indexes[i + k - 1]);
+            res += cur;
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    countSubarrays(nums, k) {
+        const n = nums.length;
+        const max_n = Math.max(...nums);
+        const max_indexes = [-1];
+
+        for (let i = 0; i < n; i++) {
+            if (nums[i] === max_n) {
+                max_indexes.push(i);
+            }
+        }
+
+        let res = 0;
+        for (let i = 1; i <= max_indexes.length - k; i++) {
+            res += (max_indexes[i] - max_indexes[i - 1]) * (n - max_indexes[i + k - 1]);
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 5. Fixed Size Sliding Window (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def countSubarrays(self, nums: List[int], k: int) -> int:
+        max_n = max(nums)
+        max_indexes = deque()
+        res = 0
+
+        for i, num in enumerate(nums):
+            if num == max_n:
+                max_indexes.append(i)
+            
+            if len(max_indexes) > k:
+                max_indexes.popleft()
+            
+            if len(max_indexes) == k:
+                res += max_indexes[0] + 1
+        
+        return res
+```
+
+```java
+public class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int maxN = Integer.MIN_VALUE;
+        for (int num : nums) {
+            maxN = Math.max(maxN, num);
+        }
+        
+        Queue<Integer> maxIndexes = new LinkedList<>();
+        long res = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == maxN) {
+                maxIndexes.add(i);
+            }
+            
+            if (maxIndexes.size() > k) {
+                maxIndexes.poll();
+            }
+            
+            if (maxIndexes.size() == k) {
+                res += maxIndexes.peek() + 1;
+            }
+        }
+        
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    long long countSubarrays(vector<int>& nums, int k) {
+        int maxN = *max_element(nums.begin(), nums.end());
+        queue<int> maxIndexes;
+        long long res = 0;
+
+        for (int i = 0; i < nums.size(); i++) {
+            if (nums[i] == maxN) {
+                maxIndexes.push(i);
+            }
+            
+            if (maxIndexes.size() > k) {
+                maxIndexes.pop();
+            }
+            
+            if (maxIndexes.size() == k) {
+                res += maxIndexes.front() + 1;
+            }
+        }
+        
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    countSubarrays(nums, k) {
+        const maxN = Math.max(...nums);
+        const maxIndexes = new Queue();
+        let res = 0;
+
+        for (let i = 0; i < nums.length; i++) {
+            if (nums[i] === maxN) {
+                maxIndexes.push(i);
+            }
+            
+            if (maxIndexes.size() > k) {
+                maxIndexes.pop();
+            }
+            
+            if (maxIndexes.size() === k) {
+                res += maxIndexes.front() + 1;
+            }
+        }
+        
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
\ No newline at end of file
diff --git a/articles/length-of-longest-subarray-with-at-most-k-frequency.md b/articles/length-of-longest-subarray-with-at-most-k-frequency.md
new file mode 100644
index 000000000..5726525c2
--- /dev/null
+++ b/articles/length-of-longest-subarray-with-at-most-k-frequency.md
@@ -0,0 +1,278 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def maxSubarrayLength(self, nums: List[int], k: int) -> int:
+        n, res = len(nums), 0
+
+        for i in range(n):
+            count = defaultdict(int)
+            for j in range(i, n):
+                count[nums[j]] += 1
+                if count[nums[j]] > k:
+                    break
+                res = max(res, j - i + 1)
+        
+        return res
+```
+
+```java
+public class Solution {
+    public int maxSubarrayLength(int[] nums, int k) {
+        int n = nums.length, res = 0;
+
+        for (int i = 0; i < n; i++) {
+            Map<Integer, Integer> count = new HashMap<>();
+            for (int j = i; j < n; j++) {
+                count.put(nums[j], count.getOrDefault(nums[j], 0) + 1);
+                if (count.get(nums[j]) > k) {
+                    break;
+                }
+                res = Math.max(res, j - i + 1);
+            }
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int maxSubarrayLength(vector<int>& nums, int k) {
+        int n = nums.size(), res = 0;
+
+        for (int i = 0; i < n; i++) {
+            unordered_map<int, int> count;
+            for (int j = i; j < n; j++) {
+                count[nums[j]]++;
+                if (count[nums[j]] > k) {
+                    break;
+                }
+                res = max(res, j - i + 1);
+            }
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    maxSubarrayLength(nums, k) {
+        let n = nums.length, res = 0;
+
+        for (let i = 0; i < n; i++) {
+            let count = new Map();
+            for (let j = i; j < n; j++) {
+                count.set(nums[j], (count.get(nums[j]) || 0) + 1);
+                if (count.get(nums[j]) > k) {
+                    break;
+                }
+                res = Math.max(res, j - i + 1);
+            }
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(n)$
+
+---
+
+## 2. Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def maxSubarrayLength(self, nums: List[int], k: int) -> int:
+        res = 0
+        count = defaultdict(int)
+        l = 0
+        for r in range(len(nums)):
+            count[nums[r]] += 1
+            while count[nums[r]] > k:
+                count[nums[l]] -= 1
+                l += 1
+            res = max(res, r - l + 1)
+        return res
+```
+
+```java
+public class Solution {
+    public int maxSubarrayLength(int[] nums, int k) {
+        int res = 0;
+        Map<Integer, Integer> count = new HashMap<>();
+        int l = 0;
+
+        for (int r = 0; r < nums.length; r++) {
+            count.put(nums[r], count.getOrDefault(nums[r], 0) + 1);
+            while (count.get(nums[r]) > k) {
+                count.put(nums[l], count.get(nums[l]) - 1);
+                l++;
+            }
+            res = Math.max(res, r - l + 1);
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int maxSubarrayLength(vector<int>& nums, int k) {
+        int res = 0;
+        unordered_map<int, int> count;
+        int l = 0;
+
+        for (int r = 0; r < nums.size(); r++) {
+            count[nums[r]]++;
+            while (count[nums[r]] > k) {
+                count[nums[l]]--;
+                l++;
+            }
+            res = max(res, r - l + 1);
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    maxSubarrayLength(nums, k) {
+        let res = 0;
+        let count = new Map();
+        let l = 0;
+
+        for (let r = 0; r < nums.length; r++) {
+            count.set(nums[r], (count.get(nums[r]) || 0) + 1);
+            while (count.get(nums[r]) > k) {
+                count.set(nums[l], count.get(nums[l]) - 1);
+                l++;
+            }
+            res = Math.max(res, r - l + 1);
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Sliding Window (Optimal)
+
+::tabs-start
+
+```python
+class Solution:
+    def maxSubarrayLength(self, nums: List[int], k: int) -> int:
+        count = defaultdict(int)
+        l = res = 0
+        cnt = 0  # count of numbers with freq > k
+        for r in range(len(nums)):
+            count[nums[r]] += 1
+            cnt += count[nums[r]] > k
+            if cnt > 0:
+                cnt -= count[nums[l]] > k
+                count[nums[l]] -= 1
+                l += 1
+        return len(nums) - l
+```
+
+```java
+public class Solution {
+    public int maxSubarrayLength(int[] nums, int k) {
+        HashMap<Integer, Integer> count = new HashMap<>();
+        int l = 0, cnt = 0; // count of numbers with freq > k
+        for (int r = 0; r < nums.length; r++) {
+            count.put(nums[r], count.getOrDefault(nums[r], 0) + 1);
+            if (count.get(nums[r]) > k) cnt++;
+            if (cnt > 0) {
+                if (count.get(nums[l]) > k) cnt--;
+                count.put(nums[l], count.get(nums[l]) - 1);
+                l++;
+            }
+        }
+        return nums.length - l;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int maxSubarrayLength(vector<int>& nums, int k) {
+        unordered_map<int, int> count;
+        int l = 0, cnt = 0; // count of numbers with freq > k
+        for (int r = 0; r < nums.size(); r++) {
+            count[nums[r]]++;
+            cnt += count[nums[r]] > k;
+            if (cnt > 0) {
+                cnt -= count[nums[l]] > k;
+                count[nums[l]]--;
+                l++;
+            }
+        }
+        return nums.size() - l;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    maxSubarrayLength(nums, k) {
+        let count = new Map();
+        let l = 0, cnt = 0; // count of numbers with freq > k
+        for (let r = 0; r < nums.length; r++) {
+            count.set(nums[r], (count.get(nums[r]) || 0) + 1);
+            if (count.get(nums[r]) > k) cnt++;
+            if (cnt > 0) {
+                if (count.get(nums[l]) > k) cnt--;
+                count.set(nums[l], count.get(nums[l]) - 1);
+                l++;
+            }
+        }
+        return nums.length - l;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
\ No newline at end of file
diff --git a/articles/minimum-number-of-operations-to-make-array-continuous.md b/articles/minimum-number-of-operations-to-make-array-continuous.md
new file mode 100644
index 000000000..ca4acc077
--- /dev/null
+++ b/articles/minimum-number-of-operations-to-make-array-continuous.md
@@ -0,0 +1,142 @@
+## 1. Recursion
+
+::tabs-start
+
+```python
+
+```
+
+```java
+
+```
+
+```cpp
+
+```
+
+```javascript
+
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(2 ^ n)$
+* Space complexity: $O(n)$
+
+---
+
+## 2. Dynamic Programming (Top-Down)
+
+::tabs-start
+
+```python
+
+```
+
+```java
+
+```
+
+```cpp
+
+```
+
+```javascript
+
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Dynamic Programming (Bottom-Up)
+
+::tabs-start
+
+```python
+
+```
+
+```java
+
+```
+
+```cpp
+
+```
+
+```javascript
+
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Dynamic Programming (Space Optimized)
+
+::tabs-start
+
+```python
+
+```
+
+```java
+
+```
+
+```cpp
+
+```
+
+```javascript
+
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
+
+---
+
+## 5. Dynamic Programming (Optimal)
+
+::tabs-start
+
+```python
+
+```
+
+```java
+
+```
+
+```cpp
+
+```
+
+```javascript
+
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
\ No newline at end of file
diff --git a/articles/subarray-product-less-than-k.md b/articles/subarray-product-less-than-k.md
new file mode 100644
index 000000000..dd7807c14
--- /dev/null
+++ b/articles/subarray-product-less-than-k.md
@@ -0,0 +1,313 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:
+        n, res = len(nums), 0
+
+        for i in range(n):
+            curProd = 1
+            for j in range(i, n):
+                curProd *= nums[j]
+                if curProd >= k:
+                    break
+                res += 1
+        
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        int n = nums.length, res = 0;
+
+        for (int i = 0; i < n; i++) {
+            int curProd = 1;
+            for (int j = i; j < n; j++) {
+                curProd *= nums[j];
+                if (curProd >= k) break;
+                res++;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
+        int n = nums.size(), res = 0;
+
+        for (int i = 0; i < n; i++) {
+            int curProd = 1;
+            for (int j = i; j < n; j++) {
+                curProd *= nums[j];
+                if (curProd >= k) break;
+                res++;
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    numSubarrayProductLessThanK(nums, k) {
+        let n = nums.length, res = 0;
+
+        for (let i = 0; i < n; i++) {
+            let curProd = 1;
+            for (let j = i; j < n; j++) {
+                curProd *= nums[j];
+                if (curProd >= k) break;
+                res++;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(1)$
+
+---
+
+## 2. Binary Search
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:
+        if k <= 1:
+            return 0
+
+        n = len(nums)
+        res = 0
+        logs = [0] * (n + 1)
+        logK = log(k)
+        for i in range(n):
+            logs[i + 1] = logs[i] + log(nums[i])
+
+        for i in range(n):
+            l, r = i + 1, n + 1
+            while l < r:
+                mid = (l + r) >> 1
+                if logs[mid] < logs[i] + logK:
+                    l = mid + 1
+                else:
+                    r = mid
+    
+            res += l - (i + 1)
+
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        if (k <= 1) return 0;
+
+        int n = nums.length, res = 0;
+        double[] logs = new double[n + 1];
+        double logK = Math.log(k);
+
+        for (int i = 0; i < n; i++) {
+            logs[i + 1] = logs[i] + Math.log(nums[i]);
+        }
+
+        for (int i = 0; i < n; i++) {
+            int l = i + 1, r = n + 1;
+            while (l < r) {
+                int mid = (l + r) / 2;
+                if (logs[mid] < logs[i] + logK) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            }
+            res += l - (i + 1);
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
+        if (k <= 1) return 0;
+
+        int n = nums.size(), res = 0;
+        vector<double> logs(n + 1, 0);
+        double logK = log(k);
+
+        for (int i = 0; i < n; i++) {
+            logs[i + 1] = logs[i] + log(nums[i]);
+        }
+
+        for (int i = 0; i < n; i++) {
+            int l = i + 1, r = n + 1;
+            while (l < r) {
+                int mid = (l + r) / 2;
+                if (logs[mid] < logs[i] + logK) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            }
+            res += l - (i + 1);
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    numSubarrayProductLessThanK(nums, k) {
+        if (k <= 1) return 0;
+
+        const n = nums.length;
+        let res = 0;
+        const logs = new Array(n + 1).fill(0);
+        const logK = Math.log(k);
+
+        for (let i = 0; i < n; i++) {
+            logs[i + 1] = logs[i] + Math.log(nums[i]);
+        }
+
+        for (let i = 0; i < n; i++) {
+            let l = i + 1, r = n + 1;
+            while (l < r) {
+                const mid = Math.floor((l + r) / 2);
+                if (logs[mid] < logs[i] + logK) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            }
+            res += l - (i + 1);
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:
+        res = 0
+        l = 0
+        product = 1
+        for r in range(len(nums)):
+            product *= nums[r]
+            while l <= r and product >= k:
+                product //= nums[l]
+                l += 1
+            res += (r - l + 1)
+        return res
+```
+
+```java
+public class Solution {
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        int res = 0, l = 0;
+        long product = 1;
+        for (int r = 0; r < nums.length; r++) {
+            product *= nums[r];
+            while (l <= r && product >= k) {
+                product /= nums[l++];
+            }
+            res += (r - l + 1);
+        }
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
+        int res = 0, l = 0;
+        long long product = 1;
+        for (int r = 0; r < nums.size(); r++) {
+            product *= nums[r];
+            while (l <= r && product >= k) {
+                product /= nums[l++];
+            }
+            res += (r - l + 1);
+        }
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    numSubarrayProductLessThanK(nums, k) {
+        let res = 0, l = 0, product = 1;
+        for (let r = 0; r < nums.length; r++) {
+            product *= nums[r];
+            while (l <= r && product >= k) {
+                product = Math.floor(product / nums[l++]);
+            }
+            res += (r - l + 1);
+        }
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$
\ No newline at end of file
diff --git a/articles/subarrays-with-k-different-integers.md b/articles/subarrays-with-k-different-integers.md
new file mode 100644
index 000000000..26328205c
--- /dev/null
+++ b/articles/subarrays-with-k-different-integers.md
@@ -0,0 +1,546 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def subarraysWithKDistinct(self, nums: List[int], k: int) -> int:
+        n, res = len(nums), 0
+        
+        for i in range(n):
+            seen = set()
+            for j in range(i, n):
+                seen.add(nums[j])
+                if len(seen) > k:
+                    break
+                
+                if len(seen) == k:
+                    res += 1
+        
+        return res
+```
+
+```java
+public class Solution {
+    public int subarraysWithKDistinct(int[] nums, int k) {
+        int n = nums.length, res = 0;
+
+        for (int i = 0; i < n; i++) {
+            Set<Integer> seen = new HashSet<>();
+            for (int j = i; j < n; j++) {
+                seen.add(nums[j]);
+                if (seen.size() > k) {
+                    break;
+                }
+                if (seen.size() == k) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int subarraysWithKDistinct(vector<int>& nums, int k) {
+        int n = nums.size(), res = 0;
+
+        for (int i = 0; i < n; i++) {
+            unordered_set<int> seen;
+            for (int j = i; j < n; j++) {
+                seen.insert(nums[j]);
+                if (seen.size() > k) {
+                    break;
+                }
+                if (seen.size() == k) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    subarraysWithKDistinct(nums, k) {
+        let n = nums.length, res = 0;
+
+        for (let i = 0; i < n; i++) {
+            let seen = new Set();
+            for (let j = i; j < n; j++) {
+                seen.add(nums[j]);
+                if (seen.size > k) {
+                    break;
+                }
+                if (seen.size === k) {
+                    res++;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(n)$
+
+---
+
+## 2. Sliding Window
+
+::tabs-start
+
+```python
+class Solution:
+    def subarraysWithKDistinct(self, nums: List[int], k: int) -> int:
+        
+        def atMostK(k):
+            count = defaultdict(int)
+            res = l = 0
+
+            for r in range(len(nums)):
+                count[nums[r]] += 1
+                if count[nums[r]] == 1:
+                    k -= 1
+                
+                while k < 0:
+                    count[nums[l]] -= 1
+                    if count[nums[l]] == 0:
+                        k += 1
+                    l += 1
+                
+                res += (r - l + 1)
+            
+            return res
+        
+        return atMostK(k) - atMostK(k - 1)
+```
+
+```java
+public class Solution {
+    public int subarraysWithKDistinct(int[] nums, int k) {
+        return atMostK(nums, k) - atMostK(nums, k - 1);
+    }
+    
+    private int atMostK(int[] nums, int k) {
+        HashMap<Integer, Integer> count = new HashMap<>();
+        int res = 0, l = 0;
+        
+        for (int r = 0; r < nums.length; r++) {
+            count.put(nums[r], count.getOrDefault(nums[r], 0) + 1);
+            if (count.get(nums[r]) == 1) {
+                k--;
+            }
+            
+            while (k < 0) {
+                count.put(nums[l], count.get(nums[l]) - 1);
+                if (count.get(nums[l]) == 0) {
+                    k++;
+                }
+                l++;
+            }
+            
+            res += (r - l + 1);
+        }
+        
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int subarraysWithKDistinct(vector<int>& nums, int k) {
+        return atMostK(nums, k) - atMostK(nums, k - 1);
+    }
+
+private:
+    int atMostK(vector<int>& nums, int k) {
+        unordered_map<int, int> count;
+        int res = 0, l = 0;
+
+        for (int r = 0; r < nums.size(); r++) {
+            count[nums[r]]++;
+            if (count[nums[r]] == 1) {
+                k--;
+            }
+
+            while (k < 0) {
+                count[nums[l]]--;
+                if (count[nums[l]] == 0) {
+                    k++;
+                }
+                l++;
+            }
+
+            res += (r - l + 1);
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    subarraysWithKDistinct(nums, k) {
+        const atMostK = (k) => {
+            const count = new Map();
+            let res = 0, l = 0;
+
+            for (let r = 0; r < nums.length; r++) {
+                count.set(nums[r], (count.get(nums[r]) || 0) + 1);
+                if (count.get(nums[r]) === 1) {
+                    k--;
+                }
+
+                while (k < 0) {
+                    count.set(nums[l], count.get(nums[l]) - 1);
+                    if (count.get(nums[l]) === 0) {
+                        k++;
+                    }
+                    l++;
+                }
+
+                res += (r - l + 1);
+            }
+
+            return res;
+        };
+
+        return atMostK(k) - atMostK(k - 1);
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Slidingt Window (One Pass) - I
+
+::tabs-start
+
+```python
+class Solution:
+    def subarraysWithKDistinct(self, nums: List[int], k: int) -> int:
+        count = defaultdict(int)
+        res = 0
+        l_far = 0
+        l_near = 0
+
+        for r in range(len(nums)):
+            count[nums[r]] += 1
+
+            while len(count) > k:
+                count[nums[l_near]] -= 1
+                if count[nums[l_near]] == 0:
+                    count.pop(nums[l_near])
+                l_near += 1
+                l_far = l_near
+
+            while count[nums[l_near]] > 1:
+                count[nums[l_near]] -= 1
+                l_near += 1
+
+            if len(count) == k:
+                res += l_near - l_far + 1
+
+        return res
+```
+
+```java
+public class Solution {
+    public int subarraysWithKDistinct(int[] nums, int k) {
+        HashMap<Integer, Integer> count = new HashMap<>();
+        int res = 0, l_far = 0, l_near = 0;
+
+        for (int r = 0; r < nums.length; r++) {
+            count.put(nums[r], count.getOrDefault(nums[r], 0) + 1);
+
+            while (count.size() > k) {
+                count.put(nums[l_near], count.get(nums[l_near]) - 1);
+                if (count.get(nums[l_near]) == 0) {
+                    count.remove(nums[l_near]);
+                }
+                l_near++;
+                l_far = l_near;
+            }
+
+            while (count.get(nums[l_near]) > 1) {
+                count.put(nums[l_near], count.get(nums[l_near]) - 1);
+                l_near++;
+            }
+
+            if (count.size() == k) {
+                res += l_near - l_far + 1;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int subarraysWithKDistinct(vector<int>& nums, int k) {
+        unordered_map<int, int> count;
+        int res = 0, l_far = 0, l_near = 0;
+
+        for (int r = 0; r < nums.size(); r++) {
+            count[nums[r]]++;
+
+            while (count.size() > k) {
+                count[nums[l_near]]--;
+                if (count[nums[l_near]] == 0) {
+                    count.erase(nums[l_near]);
+                }
+                l_near++;
+                l_far = l_near;
+            }
+
+            while (count[nums[l_near]] > 1) {
+                count[nums[l_near]]--;
+                l_near++;
+            }
+
+            if (count.size() == k) {
+                res += l_near - l_far + 1;
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    subarraysWithKDistinct(nums, k) {
+        const count = new Map();
+        let res = 0, l_far = 0, l_near = 0;
+
+        for (let r = 0; r < nums.length; r++) {
+            count.set(nums[r], (count.get(nums[r]) || 0) + 1);
+
+            while (count.size > k) {
+                count.set(nums[l_near], count.get(nums[l_near]) - 1);
+                if (count.get(nums[l_near]) === 0) {
+                    count.delete(nums[l_near]);
+                }
+                l_near++;
+            }
+
+            while (count.get(nums[l_near]) > 1) {
+                count.set(nums[l_near], count.get(nums[l_near]) - 1);
+                l_near++;
+            }
+
+            if (count.size === k) {
+                res += l_near - l_far + 1;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Sliding Window (One Pass) - II
+
+::tabs-start
+
+```python
+class Solution:
+    def subarraysWithKDistinct(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        count = [0] * (n + 1)
+        res = l = cnt = 0
+
+        for r in range(n):
+            count[nums[r]] += 1
+            if count[nums[r]] == 1:
+                k -= 1
+
+            if k < 0:
+                count[nums[l]] -= 1
+                l += 1
+                k += 1
+                cnt = 0
+
+            if k == 0:
+                while count[nums[l]] > 1:
+                    count[nums[l]] -= 1
+                    l += 1
+                    cnt += 1
+
+                res += (cnt + 1)
+
+        return res
+```
+
+```java
+public class Solution {
+    public int subarraysWithKDistinct(int[] nums, int k) {
+        int n = nums.length;
+        int[] count = new int[n + 1];
+        int res = 0, l = 0, cnt = 0;
+
+        for (int r = 0; r < n; r++) {
+            count[nums[r]]++;
+            if (count[nums[r]] == 1) {
+                k--;
+            }
+
+            if (k < 0) {
+                count[nums[l]]--;
+                l++;
+                k++;
+                cnt = 0;
+            }
+
+            if (k == 0) {
+                while (count[nums[l]] > 1) {
+                    count[nums[l]]--;
+                    l++;
+                    cnt++;
+                }
+
+                res += (cnt + 1);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int subarraysWithKDistinct(vector<int>& nums, int k) {
+        int n = nums.size();
+        vector<int> count(n + 1, 0);
+        int res = 0, l = 0, cnt = 0;
+
+        for (int r = 0; r < n; r++) {
+            count[nums[r]]++;
+            if (count[nums[r]] == 1) {
+                k--;
+            }
+
+            if (k < 0) {
+                count[nums[l]]--;
+                l++;
+                k++;
+                cnt = 0;
+            }
+
+            if (k == 0) {
+                while (count[nums[l]] > 1) {
+                    count[nums[l]]--;
+                    l++;
+                    cnt++;
+                }
+
+                res += (cnt + 1);
+            }
+        }
+
+        return res;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    subarraysWithKDistinct(nums, k) {
+        const n = nums.length;
+        const count = new Array(n + 1).fill(0);
+        let res = 0, l = 0, cnt = 0;
+
+        for (let r = 0; r < n; r++) {
+            count[nums[r]]++;
+            if (count[nums[r]] === 1) {
+                k--;
+            }
+
+            if (k < 0) {
+                count[nums[l]]--;
+                l++;
+                k++;
+                cnt = 0;
+            }
+
+            if (k === 0) {
+                while (count[nums[l]] > 1) {
+                    count[nums[l]]--;
+                    l++;
+                    cnt++;
+                }
+
+                res += (cnt + 1);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
\ No newline at end of file

From 0b1d69b3039a1b2581cbc261f436eadf0a6363b9 Mon Sep 17 00:00:00 2001
From: Sri Hari <kataresrihari@gmail.com>
Date: Sun, 26 Jan 2025 19:58:08 +0530
Subject: [PATCH 4/4] Batch-5/Neetcode-ALL/Added-articles

---
 articles/make-the-string-great.md             | 334 ++++++++++++++
 ...-of-operations-to-make-array-continuous.md | 415 +++++++++++++++---
 2 files changed, 695 insertions(+), 54 deletions(-)
 create mode 100644 articles/make-the-string-great.md

diff --git a/articles/make-the-string-great.md b/articles/make-the-string-great.md
new file mode 100644
index 000000000..10b297d5c
--- /dev/null
+++ b/articles/make-the-string-great.md
@@ -0,0 +1,334 @@
+## 1. Brute Force
+
+::tabs-start
+
+```python
+class Solution:
+    def makeGood(self, s: str) -> str:
+        n = len(s)
+        i = 0
+        while i < n:
+            if i and s[i] != s[i - 1] and s[i].lower() == s[i - 1].lower():
+                s = s[:i - 1] + s[i + 1:]
+                n -= 2
+                i -= 2
+            i += 1
+        return s
+```
+
+```java
+public class Solution {
+    public String makeGood(String s) {
+        int n = s.length();
+        int i = 0;
+        while (i < n) {
+            if (i > 0 && s.charAt(i) != s.charAt(i - 1) && 
+                Character.toLowerCase(s.charAt(i)) == Character.toLowerCase(s.charAt(i - 1))) {
+                s = s.substring(0, i - 1) + s.substring(i + 1);
+                n -= 2;
+                i -= 2;
+            }
+            i++;
+        }
+        return s;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string makeGood(string s) {
+        int n = s.length();
+        int i = 0;
+        while (i < n) {
+            if (i > 0 && s[i] != s[i - 1] && tolower(s[i]) == tolower(s[i - 1])) {
+                s.erase(i - 1, 2);
+                n -= 2;
+                i -= 2;
+            }
+            i++;
+        }
+        return s;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    makeGood(s) {
+        let n = s.length;
+        let i = 0;
+        while (i < n) {
+            if (i > 0 && s[i] !== s[i - 1] && s[i].toLowerCase() === s[i - 1].toLowerCase()) {
+                s = s.slice(0, i - 1) + s.slice(i + 1);
+                n -= 2;
+                i -= 2;
+            }
+            i++;
+        }
+        return s;
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n ^ 2)$
+* Space complexity: $O(n)$
+
+---
+
+## 2. Stack - I
+
+::tabs-start
+
+```python
+class Solution:
+    def makeGood(self, s: str) -> str:
+        def lower(c):
+            if ord(c) < ord('a'):
+                return chr(ord('a') + ord(c) - ord('A'))
+            return c
+
+        stack = []
+        i = 0
+        while i < len(s):
+            if stack and stack[-1] != s[i] and lower(stack[-1]) == lower(s[i]):
+                stack.pop()
+            else:
+                stack.append(s[i])
+            i += 1
+        return "".join(stack)
+```
+
+```java
+public class Solution {
+    public String makeGood(String s) {
+        StringBuilder stack = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (stack.length() > 0 && stack.charAt(stack.length() - 1) != c && 
+                Character.toLowerCase(stack.charAt(stack.length() - 1)) == Character.toLowerCase(c)) {
+                stack.deleteCharAt(stack.length() - 1);
+            } else {
+                stack.append(c);
+            }
+        }
+        return stack.toString();
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string makeGood(string s) {
+        string stack;
+        for (char c : s) {
+            if (!stack.empty() && stack.back() != c && 
+                tolower(stack.back()) == tolower(c)) {
+                stack.pop_back();
+            } else {
+                stack.push_back(c);
+            }
+        }
+        return stack;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    makeGood(s) {
+        const stack = [];
+        for (const c of s) {
+            if (stack.length > 0 && stack[stack.length - 1] !== c && 
+                stack[stack.length - 1].toLowerCase() === c.toLowerCase()) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        return stack.join("");
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 3. Stack - II
+
+::tabs-start
+
+```python
+class Solution:
+    def makeGood(self, s: str) -> str:
+        stack = []
+        for i in range(len(s)):
+            if stack and abs(ord(s[i]) - ord(stack[-1])) == 32:
+                stack.pop()
+            else:
+                stack.append(s[i])
+        return "".join(stack)
+```
+
+```java
+public class Solution {
+    public String makeGood(String s) {
+        StringBuilder stack = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            if (stack.length() > 0 && 
+                Math.abs(stack.charAt(stack.length() - 1) - s.charAt(i)) == 32) {
+                stack.deleteCharAt(stack.length() - 1);
+            } else {
+                stack.append(s.charAt(i));
+            }
+        }
+        return stack.toString();
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string makeGood(string s) {
+        string stack;
+        for (char& c : s) {
+            if (!stack.empty() && abs(stack.back() - c) == 32) {
+                stack.pop_back();
+            } else {
+                stack.push_back(c);
+            }
+        }
+        return stack;
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    makeGood(s) {
+        const stack = [];
+        for (const c of s) {
+            if (stack.length > 0 && 
+                Math.abs(stack[stack.length - 1].charCodeAt(0) - c.charCodeAt(0)) === 32) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        return stack.join("");
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(n)$
+
+---
+
+## 4. Two Pointers
+
+::tabs-start
+
+```python
+class Solution:
+    def makeGood(self, s: str) -> str:
+        l = 0
+        s = list(s)
+        for r in range(len(s)):
+            if l > 0 and abs(ord(s[r]) - ord(s[l - 1])) == 32:
+                l -= 1
+            else:
+                s[l] = s[r]
+                l += 1
+        return ''.join(s[:l])
+```
+
+```java
+public class Solution {
+    public String makeGood(String s) {
+        int l = 0;
+        char[] arr = s.toCharArray();
+        for (int r = 0; r < arr.length; r++) {
+            if (l > 0 && Math.abs(arr[r] - arr[l - 1]) == 32) {
+                l--;
+            } else {
+                arr[l++] = arr[r];
+            }
+        }
+        return new String(arr, 0, l);
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    string makeGood(string s) {
+        int l = 0;
+        for (int r = 0; r < s.length(); r++) {
+            if (l > 0 && abs(s[r] - s[l - 1]) == 32) {
+                l--;
+            } else {
+                s[l++] = s[r];
+            }
+        }
+        return s.substr(0, l);
+    }
+};
+```
+
+```javascript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {string}
+     */
+    makeGood(s) {
+        let l = 0;
+        let arr = s.split('');
+        for (let r = 0; r < arr.length; r++) {
+            if (l > 0 && Math.abs(arr[r].charCodeAt(0) - arr[l - 1].charCodeAt(0)) === 32) {
+                l--;
+            } else {
+                arr[l++] = arr[r];
+            }
+        }
+        return arr.slice(0, l).join('');
+    }
+}
+```
+
+::tabs-end
+
+### Time & Space Complexity
+
+* Time complexity: $O(n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the language.
\ No newline at end of file
diff --git a/articles/minimum-number-of-operations-to-make-array-continuous.md b/articles/minimum-number-of-operations-to-make-array-continuous.md
index ca4acc077..fda4f013d 100644
--- a/articles/minimum-number-of-operations-to-make-array-continuous.md
+++ b/articles/minimum-number-of-operations-to-make-array-continuous.md
@@ -1,142 +1,449 @@
-## 1. Recursion
+## 1. Brute Force
 
 ::tabs-start
 
 ```python
-
+class Solution:
+    def minOperations(self, nums: List[int]) -> int:
+        N = len(nums)
+        res = float("inf")
+        nums = sorted(set(nums))
+        n = len(nums)
+
+        for i in range(n):
+            noChange = 1
+            for j in range(i + 1, n):
+                if nums[i] < nums[j] < nums[i] + N:
+                    noChange += 1
+            res = min(res, N - noChange)
+
+        return res
 ```
 
 ```java
-
+public class Solution {
+    public int minOperations(int[] nums) {
+        int N = nums.length;
+        int res = Integer.MAX_VALUE;
+        TreeSet<Integer> set = new TreeSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        Integer[] sortedNums = set.toArray(new Integer[0]);
+        int n = sortedNums.length;
+
+        for (int i = 0; i < n; i++) {
+            int noChange = 1;
+            for (int j = i + 1; j < n; j++) {
+                if (sortedNums[j] < sortedNums[i] + N) {
+                    noChange++;
+                }
+            }
+            res = Math.min(res, N - noChange);
+        }
+
+        return res;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minOperations(vector<int>& nums) {
+        int N = nums.size();
+        int res = INT_MAX;
+        set<int> uniqueNums(nums.begin(), nums.end());
+        vector<int> sortedNums(uniqueNums.begin(), uniqueNums.end());
+        int n = sortedNums.size();
+
+        for (int i = 0; i < n; i++) {
+            int noChange = 1;
+            for (int j = i + 1; j < n; j++) {
+                if (sortedNums[j] < sortedNums[i] + N) {
+                    noChange++;
+                }
+            }
+            res = min(res, N - noChange);
+        }
+
+        return res;
+    }
+};
 ```
 
 ```javascript
-
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    minOperations(nums) {
+        const N = nums.length;
+        let res = Infinity;
+        const uniqueNums = Array.from(new Set(nums)).sort((a, b) => a - b);
+        const n = uniqueNums.length;
+
+        for (let i = 0; i < n; i++) {
+            let noChange = 1;
+            for (let j = i + 1; j < n; j++) {
+                if (uniqueNums[j] < uniqueNums[i] + N) {
+                    noChange++;
+                }
+            }
+            res = Math.min(res, N - noChange);
+        }
+
+        return res;
+    }
+}
 ```
 
 ::tabs-end
 
 ### Time & Space Complexity
 
-* Time complexity: $O(2 ^ n)$
+* Time complexity: $O(n ^ 2)$
 * Space complexity: $O(n)$
 
 ---
 
-## 2. Dynamic Programming (Top-Down)
+## 2. Binary Search
 
 ::tabs-start
 
 ```python
-
+class Solution:
+    def minOperations(self, nums: List[int]) -> int:
+        N = len(nums)
+        res = float("inf")
+        nums = sorted(set(nums))
+        n = len(nums)
+
+        for i in range(n):
+            l, r = i, n
+            while l < r:
+                mid = (l + r) // 2
+                if nums[mid] < nums[i] + N:
+                    l = mid + 1
+                else:
+                    r = mid
+            noChange = l - i
+            res = min(res, N - noChange)
+
+        return res
 ```
 
 ```java
-
+public class Solution {
+    public int minOperations(int[] nums) {
+        int N = nums.length;
+        int res = Integer.MAX_VALUE;
+        TreeSet<Integer> set = new TreeSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        Integer[] sortedNums = set.toArray(new Integer[0]);
+        int n = sortedNums.length;
+
+        for (int i = 0; i < n; i++) {
+            int l = i, r = n;
+            while (l < r) {
+                int mid = l + (r - l) / 2;
+                if (sortedNums[mid] < sortedNums[i] + N) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            }
+            int noChange = l - i;
+            res = Math.min(res, N - noChange);
+        }
+
+        return res;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minOperations(vector<int>& nums) {
+        int N = nums.size();
+        int res = INT_MAX;
+        set<int> uniqueNums(nums.begin(), nums.end());
+        vector<int> sortedNums(uniqueNums.begin(), uniqueNums.end());
+        int n = sortedNums.size();
+
+        for (int i = 0; i < n; i++) {
+            int l = i, r = n;
+            while (l < r) {
+                int mid = l + (r - l) / 2;
+                if (sortedNums[mid] < sortedNums[i] + N) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            }
+            int noChange = l - i;
+            res = min(res, N - noChange);
+        }
+
+        return res;
+    }
+};
 ```
 
 ```javascript
-
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    minOperations(nums) {
+        const N = nums.length;
+        let res = Infinity;
+        const uniqueNums = Array.from(new Set(nums)).sort((a, b) => a - b);
+        const n = uniqueNums.length;
+
+        for (let i = 0; i < n; i++) {
+            let l = i, r = n;
+            while (l < r) {
+                const mid = Math.floor((l + r) / 2);
+                if (uniqueNums[mid] < uniqueNums[i] + N) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            }
+            const noChange = l - i;
+            res = Math.min(res, N - noChange);
+        }
+
+        return res;
+    }
+}
 ```
 
 ::tabs-end
 
 ### Time & Space Complexity
 
-* Time complexity: $O(n)$
+* Time complexity: $O(n \log n)$
 * Space complexity: $O(n)$
 
 ---
 
-## 3. Dynamic Programming (Bottom-Up)
+## 3. Sliding Window
 
 ::tabs-start
 
 ```python
-
+class Solution:
+    def minOperations(self, nums: List[int]) -> int:
+        length = len(nums)
+        nums = sorted(set(nums))
+        res = length
+        r = 0
+
+        for l in range(len(nums)):
+            while r < len(nums) and nums[r] < nums[l] + length:
+                r += 1
+            window = r - l
+            res = min(res, length - window)
+
+        return res
 ```
 
 ```java
-
+public class Solution {
+    public int minOperations(int[] nums) {
+        int length = nums.length;
+        TreeSet<Integer> set = new TreeSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        List<Integer> sortedNums = new ArrayList<>(set);
+        int res = length, r = 0;
+
+        for (int l = 0; l < sortedNums.size(); l++) {
+            while (r < sortedNums.size() && sortedNums.get(r) < sortedNums.get(l) + length) {
+                r++;
+            }
+            int window = r - l;
+            res = Math.min(res, length - window);
+        }
+
+        return res;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minOperations(vector<int>& nums) {
+        int length = nums.size();
+        set<int> uniqueNums(nums.begin(), nums.end());
+        vector<int> sortedNums(uniqueNums.begin(), uniqueNums.end());
+        int res = length, r = 0;
+
+        for (int l = 0; l < sortedNums.size(); l++) {
+            while (r < sortedNums.size() && sortedNums[r] < sortedNums[l] + length) {
+                r++;
+            }
+            int window = r - l;
+            res = min(res, length - window);
+        }
+
+        return res;
+    }
+};
 ```
 
 ```javascript
-
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    minOperations(nums) {
+        const length = nums.length;
+        const uniqueNums = Array.from(new Set(nums)).sort((a, b) => a - b);
+        let res = length, r = 0;
+
+        for (let l = 0; l < uniqueNums.length; l++) {
+            while (r < uniqueNums.length && uniqueNums[r] < uniqueNums[l] + length) {
+                r++;
+            }
+            const window = r - l;
+            res = Math.min(res, length - window);
+        }
+
+        return res;
+    }
+}
 ```
 
 ::tabs-end
 
 ### Time & Space Complexity
 
-* Time complexity: $O(n)$
+* Time complexity: $O(n \log n)$
 * Space complexity: $O(n)$
 
 ---
 
-## 4. Dynamic Programming (Space Optimized)
-
-::tabs-start
-
-```python
-
-```
-
-```java
-
-```
-
-```cpp
-
-```
-
-```javascript
-
-```
-
-::tabs-end
-
-### Time & Space Complexity
-
-* Time complexity: $O(n)$
-* Space complexity: $O(1)$
-
----
-
-## 5. Dynamic Programming (Optimal)
+## 4. Sliding Window (Optimal)
 
 ::tabs-start
 
 ```python
-
+class Solution:
+    def minOperations(self, nums: List[int]) -> int:
+        length = len(nums)
+        nums.sort()
+        res = length
+        n = 1
+
+        for i in range(1, length):
+            if nums[i] != nums[i - 1]:
+                nums[n] = nums[i]
+                n += 1
+        
+        l = 0
+        for r in range(n):
+            l += (nums[r] - nums[l] > length - 1)
+
+        return length - (n - l)
 ```
 
 ```java
-
+public class Solution {
+    public int minOperations(int[] nums) {
+        int length = nums.length;
+        Arrays.sort(nums);
+        int n = 1;
+
+        for (int i = 1; i < length; i++) {
+            if (nums[i] != nums[i - 1]) {
+                nums[n] = nums[i];
+                n++;
+            }
+        }
+        
+        int l = 0;
+        for (int r = 0; r < n; r++) {
+            if (nums[r] - nums[l] > length - 1) {
+                l++;
+            }
+        }
+
+        return length - (n - l);
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    int minOperations(vector<int>& nums) {
+        int length = nums.size();
+        sort(nums.begin(), nums.end());
+        int n = 1;
+
+        for (int i = 1; i < length; i++) {
+            if (nums[i] != nums[i - 1]) {
+                nums[n] = nums[i];
+                n++;
+            }
+        }
+
+        int l = 0;
+        for (int r = 0; r < n; r++) {
+            if (nums[r] - nums[l] > length - 1) {
+                l++;
+            }
+        }
+
+        return length - (n - l);
+    }
+};
 ```
 
 ```javascript
-
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    minOperations(nums) {
+        const length = nums.length;
+        nums.sort((a, b) => a - b);
+        let n = 1;
+
+        for (let i = 1; i < length; i++) {
+            if (nums[i] !== nums[i - 1]) {
+                nums[n] = nums[i];
+                n++;
+            }
+        }
+
+        let l = 0;
+        for (let r = 0; r < n; r++) {
+            if (nums[r] - nums[l] > length - 1) {
+                l++;
+            }
+        }
+
+        return length - (n - l);
+    }
+}
 ```
 
 ::tabs-end
 
 ### Time & Space Complexity
 
-* Time complexity: $O(n)$
-* Space complexity: $O(1)$
\ No newline at end of file
+* Time complexity: $O(n \log n)$
+* Space complexity: $O(1)$ or $O(n)$ depending on the sorting algorithm.
\ No newline at end of file