Largest Subarray Length K

Largest Subarray Length K - Problem

Array Greedy Easy

An array A is larger than some array B if for the first index i where A[i] != B[i], we have A[i] > B[i].

For example, consider 0-indexing: [1,3,2,4] > [1,2,2,4], since at index 1, 3 > 2. Similarly, [1,4,4,4] < [2,1,1,1], since at index 0, 1 < 2.

A subarray is a contiguous subsequence of the array. Given an integer array nums of distinct integers, return the largest subarray of nums of length k.

Input & Output

Example 1 — Basic Case

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

› Output: [4,3,2]

💡 Note: Possible subarrays: [1,4,3], [4,3,2], [3,2,5]. Compare lexicographically: [4,3,2] > [1,4,3] (4 > 1) and [4,3,2] > [3,2,5] (4 > 3)

Example 2 — Larger Array

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

› Output: [3,4]

💡 Note: Possible subarrays: [1,2], [2,3], [3,4]. Compare: [3,4] > [2,3] (3 > 2) and [3,4] > [1,2] (3 > 1)

Example 3 — Single Element

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

› Output: [5]

💡 Note: All subarrays of length 1: [1], [4], [3], [2], [5]. The largest is [5] since 5 is the maximum element

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁹
All integers in nums are distinct

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22

The key insight is to understand lexicographic comparison of arrays. The greedy approach works best by selecting the maximum possible element at each position while ensuring enough elements remain. Time: O(nk), Space: O(k)

Common Approaches

✓ Brute Force

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

Generate every possible subarray of length k, then compare each pair lexicographically to find the largest one. This involves checking all n-k+1 possible starting positions.

Greedy Approach

⏱️ Time: O(nk) Space: O(k)

Use a greedy approach to build the largest subarray. At each position in the result, choose the maximum possible element from the remaining positions that still allows us to fill the remaining slots.

Sliding Window with Stack

⏱️ Time: O(nk) Space: O(k)

Use a sliding window approach combined with a monotonic decreasing stack to efficiently find the largest subarray. The stack helps us track potential maximum elements for each window position.

Brute Force — Algorithm Steps

Generate all subarrays of length k
Compare each pair lexicographically
Return the largest subarray found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible subarrays of length k

Compare

Compare each subarray lexicographically

Result

Return the lexicographically largest subarray

Code -

solution.c — C

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

static int nums[1000];
static int result[1000];

int parseArray(char* s, int* arr) {
    int n = 0;
    int i = 0;
    int len = strlen(s);
    
    // Skip initial '['
    while (i < len && s[i] != '[') i++;
    i++;
    
    while (i < len && s[i] != ']') {
        // Skip whitespace and commas
        while (i < len && (s[i] == ' ' || s[i] == ',')) i++;
        
        if (i < len && s[i] != ']') {
            int num = 0;
            int sign = 1;
            
            if (s[i] == '-') {
                sign = -1;
                i++;
            }
            
            while (i < len && s[i] >= '0' && s[i] <= '9') {
                num = num * 10 + (s[i] - '0');
                i++;
            }
            
            arr[n++] = sign * num;
        }
    }
    
    return n;
}

int isLarger(int* a, int* b, int k) {
    for (int i = 0; i < k; i++) {
        if (a[i] > b[i]) return 1;
        if (a[i] < b[i]) return 0;
    }
    return 0; // equal
}

void solve(int* nums, int n, int k, int* result) {
    int bestStart = 0;
    
    // Find the lexicographically largest subarray of length k
    for (int i = 1; i <= n - k; i++) {
        if (isLarger(&nums[i], &nums[bestStart], k)) {
            bestStart = i;
        }
    }
    
    // Copy result
    for (int i = 0; i < k; i++) {
        result[i] = nums[bestStart + i];
    }
}

int main() {
    char line[1000];
    int k;
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    scanf("%d", &k);
    
    int n = parseArray(line, nums);
    
    solve(nums, n, k, result);
    
    printf("[");
    for (int i = 0; i < k; i++) {
        printf("%d", result[i]);
        if (i < k - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²k)

O(n) subarrays × O(n) comparisons × O(k) comparison time

⚠ Quadratic Growth

Space Complexity

O(k)

Store the current best subarray of length k

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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