Adjacent Increasing Subarrays Detection I

Adjacent Increasing Subarrays Detection I - Problem

Array Easy

Given an array nums of n integers and an integer k, determine whether there exist two adjacent subarrays of length k such that both subarrays are strictly increasing.

Specifically, check if there are two subarrays starting at indices a and b (a < b), where:

Both subarrays nums[a..a + k - 1] and nums[b..b + k - 1] are strictly increasing
The subarrays must be adjacent, meaning b = a + k

Return true if it is possible to find two such subarrays, and false otherwise.

Input & Output

Example 1 — Basic Valid Case

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

› Output: true

💡 Note: Subarrays [1,2] at index 0 and [2,3] at index 1 are adjacent. [1,2]: 2 > 1 ✓ (strictly increasing). [2,3]: 3 > 2 ✓ (strictly increasing). Both adjacent subarrays are strictly increasing.

Example 2 — Valid Adjacent Increasing Subarrays

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

› Output: true

Example 3 — No Valid Adjacent Pairs

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

› Output: false

💡 Note: Position 0: [1,3] (increasing) + [3,2] (decreasing) = false. Position 1: [3,2] (decreasing) + [2,4] (increasing) = false. No adjacent pair of increasing subarrays exists.

Constraints

2 ≤ nums.length ≤ 100
1 ≤ k ≤ nums.length / 2
-100 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to efficiently determine if subarrays are strictly increasing by precomputing increasing sequence lengths. The optimized approach uses O(n) preprocessing to enable O(1) subarray validation. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force

⏱️ Time: O(n×k) Space: O(1)

For each valid starting position, check if both the current k-length subarray and the next adjacent k-length subarray are strictly increasing. This requires checking all elements in both subarrays for each position.

Single Pass with Length Tracking

⏱️ Time: O(n) Space: O(n)

Precompute the length of strictly increasing sequence ending at each position, then use this information to quickly determine if two adjacent k-length subarrays are both strictly increasing.

Brute Force — Algorithm Steps

Step 1: Iterate through all possible starting positions for first subarray
Step 2: For each position, check if current k-length subarray is strictly increasing
Step 3: Check if the adjacent k-length subarray is also strictly increasing
Step 4: Return true if both conditions are met

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position 0

Verify if subarrays [0,k-1] and [k,2k-1] are both increasing

Check Position 1

Verify if subarrays [1,k] and [k+1,2k] are both increasing

Continue Until Valid Pair Found

Keep checking until a valid pair is found or all positions exhausted

Code -

solution.c — C

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

bool isStrictlyIncreasing(int* nums, int start, int length) {
    for (int i = start + 1; i < start + length; i++) {
        if (nums[i] <= nums[i - 1]) {
            return false;
        }
    }
    return true;
}

bool solution(int* nums, int numsSize, int k) {
    if (numsSize < 2 * k) return false;
    
    for (int i = 0; i <= numsSize - 2 * k; i++) {
        if (isStrictlyIncreasing(nums, i, k) && isStrictlyIncreasing(nums, i + k, k)) {
            return true;
        }
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    // Remove brackets and parse numbers
    char* ptr = line;
    while (*ptr != '\0') {
        if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
            nums[numsSize++] = atoi(ptr);
            // Skip the number
            if (*ptr == '-') ptr++;
            while (*ptr >= '0' && *ptr <= '9') ptr++;
        } else {
            ptr++;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    bool result = solution(nums, numsSize, k);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

For each of n-2k+1 positions, we check 2k elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

245 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler