Adjacent Increasing Subarrays Detection I

Adjacent Increasing Subarrays Detection I - Problem

Array Easy

You're given an array nums of n integers and an integer k. Your task is to determine if there exist two adjacent subarrays of length k where both subarrays are strictly increasing.

Specifically, you need to find two subarrays:
• nums[a..a + k - 1] (first subarray)
• nums[b..b + k - 1] (second subarray)

Where:
• Both subarrays are strictly increasing (each element is greater than the previous)
• The subarrays are adjacent, meaning b = a + k
• a < b (first subarray comes before second)

Return true if such a pair exists, false otherwise.

Example: For nums = [2,5,7,8,9,2,3,4,3,1] and k = 3, the subarrays [2,5,7] and [8,9,2] are adjacent, but only the first is strictly increasing. However, [5,7,8] and [9,2,3] are adjacent subarrays where the first is strictly increasing but the second is not.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,5,7,8,9,2,3,4,3,1], k = 3

› Output: false

💡 Note: While [2,5,7] is strictly increasing, the adjacent subarray [8,9,2] is not strictly increasing. No valid pair exists.

example_2.py — Valid Case

$ Input: nums = [1,2,3,4,5,6], k = 3

› Output: true

💡 Note: The subarrays [1,2,3] and [4,5,6] are both strictly increasing and adjacent. This satisfies our condition.

example_3.py — Edge Case

$ Input: nums = [1,1,1,1,1,1], k = 2

› Output: false

💡 Note: All elements are equal, so no subarray can be strictly increasing. Return false.

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ nums.length / 2
Follow-up: Can you solve this in O(n) time and O(1) space?

Visualization

Tap to expand

Understanding the Visualization

Start Trail Analysis

Begin with current uphill length = 1

Check Each Step

If elevation increases, extend uphill length; otherwise reset to 1

Monitor Length

When uphill length reaches 2k, we've found our answer

Success Condition

A 2k-length uphill contains two adjacent k-length climbing segments

Key Takeaway

🎯 Key Insight: A strictly increasing sequence of length 2k naturally contains two adjacent subsequences of length k, both of which are strictly increasing.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a one-pass approach with O(n) time complexity. Instead of checking each subarray individually, we track the length of strictly increasing sequences. The key insight is that if we find any increasing sequence of length ≥ 2k, it must contain two adjacent subarrays of length k that are both strictly increasing. This elegant approach avoids redundant comparisons and solves the problem in linear time with constant space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Position)	O(n * k)	O(1)	Check every possible starting position for two adjacent subarrays of length k
One-Pass Optimal Solution	O(n)	O(1)	Track increasing sequence lengths in a single pass to find if any sequence spans 2k elements

Brute Force (Check Every Position) — Algorithm Steps

Iterate through all possible starting positions (0 to n - 2k)
For each position i, check if subarray [i, i+k-1] is strictly increasing
Check if the adjacent subarray [i+k, i+2k-1] is also strictly increasing
If both subarrays are strictly increasing, return true
If no such pair is found, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check if subarray [0, k-1] and [k, 2k-1] are both strictly increasing

Move to position 1

Check if subarray [1, k] and [k+1, 2k] are both strictly increasing

Continue until end

Keep checking until we find a valid pair or exhaust all positions

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool hasIncreasingSubarrays(int* nums, int n, int k) {
    // Need at least 2k elements for two adjacent subarrays
    if (n < 2 * k) {
        return false;
    }
    
    // Check every possible starting position
    for (int i = 0; i <= n - 2 * k; i++) {
        // Check if first subarray [i, i+k-1] is strictly increasing
        bool firstIncreasing = true;
        for (int j = i; j < i + k - 1; j++) {
            if (nums[j] >= nums[j + 1]) {
                firstIncreasing = false;
                break;
            }
        }
        
        if (!firstIncreasing) {
            continue;
        }
        
        // Check if second subarray [i+k, i+2k-1] is strictly increasing
        bool secondIncreasing = true;
        for (int j = i + k; j < i + 2 * k - 1; j++) {
            if (nums[j] >= nums[j + 1]) {
                secondIncreasing = false;
                break;
            }
        }
        
        if (secondIncreasing) {
            return true;
        }
    }
    
    return false;
}

int main() {
    int nums[] = {2, 5, 7, 8, 9, 2, 3, 4, 3, 1};
    int n = 10;
    int k = 3;
    printf("%s\n", hasIncreasingSubarrays(nums, n, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

We iterate through n-2k+1 starting positions, and for each position we check 2k elements for strict increasing property

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current position and validation state

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Every Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler