Largest Subarray Length K - Practice Coding Problems

Largest Subarray Length K - Problem

Array Greedy Easy

Imagine you're a judge comparing two sequences of numbers. When comparing arrays, you look at them lexicographically - just like comparing words in a dictionary!

An array A is considered larger than array B if at the first position where they differ, A has a bigger number than B.

Examples:

[1,3,2,4] > [1,2,2,4] because at index 1: 3 > 2
[1,4,4,4] < [2,1,1,1] because at index 0: 1 < 2

Given an array nums of distinct integers, your task is to find the largest possible subarray of exactly length k. A subarray means consecutive elements from the original array.

Goal: Return the lexicographically largest subarray of length k.

Input & Output

example_1.py — Basic Case

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

› Output: [5,2,3]

💡 Note: The subarrays of length 3 are [1,4,5], [4,5,2], and [5,2,3]. Among these, [5,2,3] is lexicographically largest because 5 > 1 and 5 > 4.

example_2.py — All Elements

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

› Output: [1,4,5,2,3]

💡 Note: When k equals the array length, there's only one possible subarray - the entire array.

example_3.py — Single Element

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

› Output: [5]

💡 Note: Among all single elements [1], [4], [5], [2], [3], the largest is [5].

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Mark Valid Positions

Identify positions where we can form a complete k-length subarray

Find Maximum

Look for the largest number among these valid starting positions

Extract Result

Take k consecutive elements starting from the maximum position

Key Takeaway

🎯 Key Insight: For lexicographically largest subarray, we need the largest possible first element. Find the maximum element among valid starting positions and take k elements from there!

Asked in

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

The optimal solution uses a greedy approach to find the maximum element among valid starting positions (positions where we can still form a k-length subarray). Since we want the lexicographically largest subarray, we want the largest possible first element. Time complexity: O(n), Space complexity: O(k).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n*k)	O(k)	Generate all possible subarrays of length k and find the lexicographically largest one
Greedy Approach (Optimal)	O(n)	O(k)	Find the maximum element that can start a k-length subarray, then take k elements from there

Brute Force (Check All Subarrays) — Algorithm Steps

Initialize result as the first k elements
For each starting position i from 0 to n-k:
Extract subarray of length k starting at position i
Compare this subarray lexicographically with current result
Update result if current subarray is larger
Return the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first k elements as current best

Iterate

Check each possible starting position

Compare

Compare each subarray lexicographically

Update

Keep the largest subarray found so far

Code -

solution.c — C

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

int* largestSubarray(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = k;
    int* result = (int*)malloc(k * sizeof(int));
    memcpy(result, nums, k * sizeof(int));
    
    // Check all possible subarrays of length k
    for (int i = 1; i <= numsSize - k; i++) {
        int* currentSubarray = nums + i;
        
        // Compare lexicographically
        int isLarger = 0;
        for (int j = 0; j < k; j++) {
            if (currentSubarray[j] > result[j]) {
                isLarger = 1;
                break;
            } else if (currentSubarray[j] < result[j]) {
                break;
            }
        }
        
        if (isLarger) {
            memcpy(result, currentSubarray, k * sizeof(int));
        }
    }
    
    return result;
}

int main() {
    int nums[] = {1, 4, 5, 2, 3};
    int k = 3;
    int returnSize;
    int* result = largestSubarray(nums, 5, k, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We check n-k+1 subarrays, and each comparison takes O(k) time in worst case

✓ Linear Growth

Space Complexity

O(k)

Only need space to store the result subarray of length k

✓ Linear Space

24.6K Views

Medium Frequency

~15 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 (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler