chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-10-15-3350-Adjacent-Increasing-Subarrays-Detection-II/explanation.md

@@ -0,0 +1,31 @@
+# Adjacent Increasing Subarrays Detection II (Medium)
+
+**Problem ID:** 3350  
+**Date:** 2025-10-15  
+**Link:** https://leetcode.com/problems/adjacent-increasing-subarrays-detection-ii/
+
+## Approach
+
+To solve the problem of detecting the maximum value of \( k \) for which there exist two adjacent strictly increasing subarrays of length \( k \) in the given array `nums`, we can follow a structured approach:
+
+### Main Idea:
+The key is to identify and store the lengths of strictly increasing segments in the array. Once we have the lengths of these segments, we can check for adjacent segments that meet the criteria of being strictly increasing and adjacent.
+
+### Steps:
+1. **Identify Increasing Segments**: Iterate through the array and determine the lengths of all strictly increasing segments. For each element, compare it to the next one. If it is less than the next, increase the current segment length. If it is not, store the length of the current segment (if greater than 1) and reset the length counter.
+
+2. **Store Segment Lengths**: Maintain a list of the lengths of these increasing segments. For example, if the array is `[2,5,7,8,9,2,3,4,3,1]`, the lengths of increasing segments would be `[5, 3]` (for segments `[2,5,7,8,9]` and `[2,3,4]`).
+
+3. **Check for Adjacent Segments**: Once the lengths of increasing segments are identified, check pairs of adjacent segments. For segments at indices \( i \) and \( i+1 \), the maximum \( k \) is determined by the minimum of the two lengths (i.e., \( k = \min(\text{length}[i], \text{length}[i+1]) \)).
+
+4. **Track Maximum \( k \)**: As you check each pair of adjacent segments, keep track of the maximum value of \( k \) found.
+
+### Data Structures:
+- A simple list to store the lengths of the increasing segments will suffice.
+- Variables to store the current segment length and the maximum \( k \) found.
+
+### Complexity:
+- **Time Complexity**: \( O(n) \) where \( n \) is the length of the input array. This is because we make a single pass through the array to identify increasing segments and another pass through the segment lengths to find adjacent pairs.
+- **Space Complexity**: \( O(m) \) where \( m \) is the number of increasing segments identified. In the worst case, this could be \( O(n) \), but typically it will be much smaller as segments of increasing lengths are often merged.
+
+By following this structured approach, we can efficiently determine the maximum \( k \) for which two adjacent strictly increasing subarrays exist in the given array.

Medium/2025-10-15-3350-Adjacent-Increasing-Subarrays-Detection-II/solution.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int maxLengthBetweenIncreasingSubarrays(int[] nums) {
+        int n = nums.length;
+        int maxK = 0;
+        
+        // Array to store lengths of increasing subarrays
+        int[] lengths = new int[n];
+        
+        // Calculate lengths of strictly increasing subarrays
+        for (int i = 1; i < n; i++) {
+            if (nums[i] > nums[i - 1]) {
+                lengths[i] = lengths[i - 1] + 1;
+            }
+        }
+        
+        // Find the maximum k for adjacent increasing subarrays
+        for (int i = 1; i < n; i++) {
+            if (lengths[i] > 0 && lengths[i - 1] > 0) {
+                maxK = Math.max(maxK, Math.min(lengths[i], lengths[i - 1]) + 1);
+            }
+        }
+        
+        return maxK;
+    }
+}

Medium/2025-10-15-3350-Adjacent-Increasing-Subarrays-Detection-II/solution.js

@@ -0,0 +1,22 @@
+var maxK = function(nums) {
+    const n = nums.length;
+    let maxK = 0;
+    const lengths = new Array(n).fill(0);
+
+    // Calculate lengths of strictly increasing subarrays
+    for (let i = 1; i < n; i++) {
+        if (nums[i] > nums[i - 1]) {
+            lengths[i] = lengths[i - 1] + 1;
+        }
+    }
+
+    // Find the maximum k for adjacent strictly increasing subarrays
+    for (let i = 1; i < n; i++) {
+        if (lengths[i] > 0 && lengths[i - 1] > 0) {
+            const k = Math.min(lengths[i], lengths[i - 1]) + 1;
+            maxK = Math.max(maxK, k);
+        }
+    }
+
+    return maxK;
+};

Medium/2025-10-15-3350-Adjacent-Increasing-Subarrays-Detection-II/solution.py

@@ -0,0 +1,20 @@
+class Solution:
+    def maxK(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n < 2:
+            return 0
+        
+        lengths = [0] * n
+        
+        for i in range(1, n):
+            if nums[i] > nums[i - 1]:
+                lengths[i] = lengths[i - 1] + 1
+        
+        max_k = 0
+        
+        for i in range(1, n):
+            if lengths[i] > 0 and lengths[i - 1] > 0:
+                k = min(lengths[i], lengths[i - 1]) + 1
+                max_k = max(max_k, k)
+        
+        return max_k

README.md

@@ -248,3 +248,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-10-12 — [Find Sum of Array Product of Magical Sequences](https://leetcode.com/problems/find-sum-of-array-product-of-magical-sequences/) (Hard) → `Hard/2025-10-12-3539-Find-Sum-of-Array-Product-of-Magical-Sequences`
 - 2025-10-13 — [Find Resultant Array After Removing Anagrams](https://leetcode.com/problems/find-resultant-array-after-removing-anagrams/) (Easy) → `Easy/2025-10-13-2273-Find-Resultant-Array-After-Removing-Anagrams`
 - 2025-10-14 — [Adjacent Increasing Subarrays Detection I](https://leetcode.com/problems/adjacent-increasing-subarrays-detection-i/) (Easy) → `Easy/2025-10-14-3349-Adjacent-Increasing-Subarrays-Detection-I`
+- 2025-10-15 — [Adjacent Increasing Subarrays Detection II](https://leetcode.com/problems/adjacent-increasing-subarrays-detection-ii/) (Medium) → `Medium/2025-10-15-3350-Adjacent-Increasing-Subarrays-Detection-II`