Find the Most Competitive Subsequence

Find the Most Competitive Subsequence - Problem

Given an integer array nums and a positive integer k, return the most competitive subsequence of nums of size k.

An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the array.

We define that a subsequence a is more competitive than a subsequence b (of the same length) if in the first position where a and b differ, subsequence a has a number less than the corresponding number in b. For example, [1,3,4] is more competitive than [1,3,5] because the first position they differ is at the final number, and 4 < 5.

Input & Output

Example 1 — Basic Case

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

› Output: [2,6]

💡 Note: Among all possible subsequences of length 2: [3,5], [3,2], [3,6], [5,2], [5,6], [2,6]. The subsequence [2,6] is most competitive because 2 < 3 (first elements compared).

Example 2 — Larger Array

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

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

💡 Note: We need to select 4 elements maintaining order. The most competitive subsequence starts with the smallest possible elements: 2, then 3, then 3, then 4.

Example 3 — All Elements

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

› Output: [1,2,3]

💡 Note: When k equals array length, we must take all elements in their original order.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use a monotonic stack that maintains the smallest possible elements while ensuring we can still select k elements total. The optimal approach uses a greedy strategy with O(n) time complexity by removing larger elements when beneficial.

Common Approaches

✓ Binary Search

⏱️ Time: N/A Space: N/A

Brute Force - Generate All Subsequences

⏱️ Time: O(C(n,k) × k) Space: O(C(n,k) × k)

Generate every possible subsequence of length k from the array, then compare them lexicographically to find the most competitive one. This involves checking all combinations of k elements while maintaining their relative order.

Greedy with Monotonic Stack

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

Build the result using a monotonic increasing stack. For each element, remove larger elements from the stack if we still have enough remaining elements to reach length k. This ensures we always keep the smallest possible elements in the leftmost positions.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* mostCompetitive(int* nums, int numsSize, int k, int* returnSize) {
    int* stack = (int*)malloc(k * sizeof(int));
    int stackSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // Remove elements from stack if current element is smaller
        // and we still have enough elements left to fill k positions
        while (stackSize > 0 && 
               stack[stackSize - 1] > nums[i] && 
               stackSize + (numsSize - i) > k) {
            stackSize--;
        }
        
        // Add current element if we haven't filled k positions
        if (stackSize < k) {
            stack[stackSize++] = nums[i];
        }
    }
    
    *returnSize = k;
    return stack;
}

int* parseArray(char* line, int* size) {
    // Remove brackets and parse numbers
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (!start || !end) {
        *size = 0;
        return NULL;
    }
    
    start++; // Skip '['
    *end = '\0'; // Null terminate before ']'
    
    // Count numbers
    int count = 0;
    char* temp = strdup(start);
    char* token = strtok(temp, ",");
    while (token) {
        count++;
        token = strtok(NULL, ",");
    }
    free(temp);
    
    if (count == 0) {
        *size = 0;
        return NULL;
    }
    
    // Parse numbers
    int* arr = (int*)malloc(count * sizeof(int));
    int idx = 0;
    
    temp = strdup(start);
    token = strtok(temp, ",");
    while (token && idx < count) {
        arr[idx++] = atoi(token);
        token = strtok(NULL, ",");
    }
    free(temp);
    
    *size = count;
    return arr;
}

int main() {
    char line[10000];
    
    // Read array line
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = '\0';
    
    int numsSize;
    int* nums = parseArray(line, &numsSize);
    
    // Read k
    int k;
    if (scanf("%d", &k) != 1) {
        free(nums);
        return 1;
    }
    
    int returnSize;
    int* result = mostCompetitive(nums, numsSize, k, &returnSize);
    
    // Output result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) {
            printf(",");
        }
    }
    printf("]\n");
    
    free(nums);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

89.6K Views

Medium Frequency

~25 min Avg. Time

1.8K 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