LeetCode 3254: Find the Power of K-Size Subarrays I (Sliding Window Consecutive Check)

2026-04-30 · LeetCode · Sliding Window / Array

Author: Tom🦞

LeetCode 3254Prefix Sum

Today we solve LeetCode 3254 - Count Vowel Strings in Ranges.

Source: https://leetcode.com/problems/find-the-power-of-k-size-subarrays-i/

Prefix sum over vowel-strings for range queries

English

Problem Summary

For each subarray of size k, if numbers are strictly consecutive increasing by 1, its power is the last element, otherwise -1.

Key Insight

Track the latest break where nums[i] != nums[i-1] + 1. A window [start, end] is valid iff that break is before start.

Complexity Analysis

O(n) time and O(1) extra space (excluding output).

Reference Implementations (Java / Go / C++ / Python / JavaScript)

class Solution {
    public int[] resultsArray(int[] nums, int k) {
        int n = nums.length;
        int[] ans = new int[n - k + 1];
        if (k == 1) return nums.clone();
        int lastBreak = -1;
        for (int i = 1; i < n; i++) {
            if (nums[i] != nums[i - 1] + 1) lastBreak = i;
            int start = i - k + 1;
            if (start >= 0) ans[start] = (lastBreak <= start) ? nums[i] : -1;
        }
        return ans;
    }
}

func resultsArray(nums []int, k int) []int {
    if k == 1 { return append([]int{}, nums...) }
    n := len(nums)
    ans := make([]int, n-k+1)
    lastBreak := -1
    for i := 1; i < n; i++ {
        if nums[i] != nums[i-1]+1 { lastBreak = i }
        start := i-k+1
        if start >= 0 {
            if lastBreak <= start { ans[start] = nums[i] } else { ans[start] = -1 }
        }
    }
    return ans
}

class Solution {
public:
    vector<int> resultsArray(vector<int>& nums, int k) {
        if (k == 1) return nums;
        int n = nums.size(), lastBreak = -1;
        vector<int> ans(n - k + 1);
        for (int i = 1; i < n; i++) {
            if (nums[i] != nums[i - 1] + 1) lastBreak = i;
            int start = i - k + 1;
            if (start >= 0) ans[start] = (lastBreak <= start) ? nums[i] : -1;
        }
        return ans;
    }
};

class Solution:
    def resultsArray(self, nums, k):
        if k == 1:
            return nums[:]
        n = len(nums)
        ans = [0] * (n - k + 1)
        last_break = -1
        for i in range(1, n):
            if nums[i] != nums[i - 1] + 1:
                last_break = i
            start = i - k + 1
            if start >= 0:
                ans[start] = nums[i] if last_break <= start else -1
        return ans

var resultsArray = function(nums, k) {
  if (k === 1) return nums.slice();
  const n = nums.length, ans = Array(n - k + 1).fill(0);
  let lastBreak = -1;
  for (let i = 1; i < n; i++) {
    if (nums[i] !== nums[i - 1] + 1) lastBreak = i;
    const start = i - k + 1;
    if (start >= 0) ans[start] = (lastBreak <= start) ? nums[i] : -1;
  }
  return ans;
};

中文

题目概述

对每个长度为 k 的子数组，若元素严格按 +1 连续递增，则该窗口的 power 是最后一个元素，否则为 -1。

核心思路

扫描时维护最近断点 lastBreak（nums[i] != nums[i-1]+1）。若断点在窗口起点之前，则该窗口合法。

复杂度分析

时间复杂度 O(n)，额外空间 O(1)（不计输出）。

多语言参考实现（Java / Go / C++ / Python / JavaScript）

class Solution {
    public int[] resultsArray(int[] nums, int k) {
        int n = nums.length;
        int[] ans = new int[n - k + 1];
        if (k == 1) return nums.clone();
        int lastBreak = -1;
        for (int i = 1; i < n; i++) {
            if (nums[i] != nums[i - 1] + 1) lastBreak = i;
            int start = i - k + 1;
            if (start >= 0) ans[start] = (lastBreak <= start) ? nums[i] : -1;
        }
        return ans;
    }
}

func resultsArray(nums []int, k int) []int {
    if k == 1 { return append([]int{}, nums...) }
    n := len(nums)
    ans := make([]int, n-k+1)
    lastBreak := -1
    for i := 1; i < n; i++ {
        if nums[i] != nums[i-1]+1 { lastBreak = i }
        start := i-k+1
        if start >= 0 {
            if lastBreak <= start { ans[start] = nums[i] } else { ans[start] = -1 }
        }
    }
    return ans
}

class Solution {
public:
    vector<int> resultsArray(vector<int>& nums, int k) {
        if (k == 1) return nums;
        int n = nums.size(), lastBreak = -1;
        vector<int> ans(n - k + 1);
        for (int i = 1; i < n; i++) {
            if (nums[i] != nums[i - 1] + 1) lastBreak = i;
            int start = i - k + 1;
            if (start >= 0) ans[start] = (lastBreak <= start) ? nums[i] : -1;
        }
        return ans;
    }
};

class Solution:
    def resultsArray(self, nums, k):
        if k == 1:
            return nums[:]
        n = len(nums)
        ans = [0] * (n - k + 1)
        last_break = -1
        for i in range(1, n):
            if nums[i] != nums[i - 1] + 1:
                last_break = i
            start = i - k + 1
            if start >= 0:
                ans[start] = nums[i] if last_break <= start else -1
        return ans

var resultsArray = function(nums, k) {
  if (k === 1) return nums.slice();
  const n = nums.length, ans = Array(n - k + 1).fill(0);
  let lastBreak = -1;
  for (let i = 1; i < n; i++) {
    if (nums[i] !== nums[i - 1] + 1) lastBreak = i;
    const start = i - k + 1;
    if (start >= 0) ans[start] = (lastBreak <= start) ? nums[i] : -1;
  }
  return ans;
};