Find the Power of K-Size Subarrays II - Practice Coding Problems

Find the Power of K-Size Subarrays II - Problem

Find the Power of K-Size Subarrays II

You are given an array of integers nums of length n and a positive integer k. Your task is to analyze the "power" of every possible subarray of size k.

The power of an array is defined as:
• Its maximum element if all elements are consecutive integers in ascending order
• -1 otherwise

For example:
• [1, 2, 3] has power 3 (consecutive ascending)
• [2, 1, 3] has power -1 (not consecutive ascending)
• [5, 6, 7, 8] has power 8 (consecutive ascending)

Return an array results where results[i] is the power of the subarray starting at index i.

Input & Output

example_1.py — Basic consecutive sequence

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

› Output: [3,4]

💡 Note: Subarray [1,2,3] is consecutive ascending with max 3. Subarray [2,3,4] is consecutive ascending with max 4.

example_2.py — Mixed valid/invalid subarrays

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

› Output: [-1,-1]

💡 Note: All elements are the same, so no subarray has consecutive ascending elements.

example_3.py — Large gap between consecutive

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

› Output: [-1,-1,-1,-1,-1]

💡 Note: No adjacent pair forms a consecutive ascending sequence.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ k ≤ n
-10⁹ ≤ nums[i] ≤ 10⁹
Follow-up: Can you solve this in O(n) time?

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Set up first k-size window and count consecutive elements

Slide and Check

Move window one position, check if new element extends sequence

Update Counter

Increment consecutive count or reset to 1 based on continuity

Record Power

If count ≥ k, record max element; otherwise record -1

Key Takeaway

🎯 Key Insight: By tracking the consecutive count as we slide the window, we avoid redundant checks and achieve O(n) time complexity instead of O(n×k).

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal solution uses a sliding window approach with consecutive count tracking. Instead of checking each k-size subarray from scratch, we maintain a count of consecutive ascending elements and update it efficiently as we slide the window. This reduces time complexity from O(n×k) to O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Subarray)	O(n * k)	O(1)	Check every k-size subarray independently for consecutive ascending property
Sliding Window (Optimal)	O(n)	O(1)	Track consecutive count as we slide the window, avoiding redundant checks

Brute Force (Check Each Subarray) — Algorithm Steps

Iterate through all possible starting positions (0 to n-k)
For each position, extract the k-size subarray
Check if elements are consecutive and ascending: nums[i+1] == nums[i] + 1
If valid, store the maximum element; otherwise store -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Window

Choose a k-size subarray starting at position i

Check Consecutive

Verify each adjacent pair differs by exactly 1

Record Result

Store max element if valid, -1 otherwise

Move Window

Repeat for next starting position

Code -

solution.c — C

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

int* findPower(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = numsSize - k + 1;
    int* results = (int*)malloc(*returnSize * sizeof(int));
    
    for (int i = 0; i <= numsSize - k; i++) {
        // Check if subarray nums[i:i+k] is consecutive ascending
        bool isConsecutive = true;
        for (int j = i + 1; j < i + k; j++) {
            if (nums[j] != nums[j-1] + 1) {
                isConsecutive = false;
                break;
            }
        }
        
        if (isConsecutive) {
            results[i] = nums[i + k - 1]; // Maximum element
        } else {
            results[i] = -1;
        }
    }
    
    return results;
}

int main() {
    int nums[1000];
    int n = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
        if (getchar() == '\n') break;
    }
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* result = findPower(nums, n, k, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(" ");
    }
    printf("\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

For each of (n-k+1) subarrays, we check k elements for consecutive property

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for temporary variables

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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 Each Subarray) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler