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

Find the Power of K-Size Subarrays I - Problem

Find the Power of K-Size Subarrays I

You are given an array of integers nums and a positive integer k. Your task is to find the power of every subarray of size k.

The power of an array is defined as:
• Maximum element if all elements are consecutive and sorted in ascending order
• -1 otherwise

For example, the array [1, 2, 3] has power 3 (consecutive ascending), while [1, 3, 5] has power -1 (not consecutive).

Goal: Return an array results where results[i] is the power of the subarray starting at index i with length k.

Input & Output

example_1.py — Basic consecutive sequence

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

› Output: [3,4]

💡 Note: Subarray [1,2,3] has consecutive ascending elements, so power = 3. Subarray [2,3,4] has consecutive ascending elements, so power = 4.

example_2.py — Mixed valid/invalid subarrays

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

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

💡 Note: No subarray of size 3 has consecutive ascending elements. [2,2,2] has duplicates, [2,5,4] is not ascending, [5,4,3] is descending, etc.

example_3.py — Single element window

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

› Output: [3,2,3,2,3,2]

💡 Note: Every single element forms a valid consecutive sequence of length 1, so power equals the element itself.

Constraints

1 ≤ n ≤ 500
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ n
All elements in nums are distinct

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Set up first k-size window and count consecutive elements

Slide and Update

Move window right, check if new element continues sequence

Determine Power

If consecutive count ≥ k, power = max element, else -1

Key Takeaway

🎯 Key Insight: Track consecutive count as window slides to avoid redundant checks and achieve O(n) time complexity

Asked in

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

The optimal solution uses a sliding window approach with consecutive count tracking. Instead of checking each 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) while using only O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Each Subarray)	O(n * k)	O(1)	Check each k-size subarray independently for consecutive ascending order
Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to track consecutive count efficiently

Brute Force (Check Each Subarray) — Algorithm Steps

Iterate through all possible starting positions (0 to n-k)
For each position, check the k-size subarray
Verify if elements are consecutive and ascending
If valid, add maximum element to result, otherwise add -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check first k elements for consecutive ascending order

Move to position 1

Check next k elements completely from scratch

Continue sliding

Repeat for all possible starting positions

Code -

solution.c — C

int* findPower(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = numsSize - k + 1;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    
    for (int i = 0; i <= numsSize - k; i++) {
        int isValid = 1;
        for (int j = i + 1; j < i + k; j++) {
            if (nums[j] != nums[j-1] + 1) {
                isValid = 0;
                break;
            }
        }
        
        if (isValid) {
            result[i] = nums[i + k - 1];
        } else {
            result[i] = -1;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

We check n-k+1 subarrays, each taking O(k) time to validate

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~18 min Avg. Time

847 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