Minimum Operations to Collect Elements - Practice Coding Problems

Minimum Operations to Collect Elements - Problem

You're given an array nums containing positive integers and an integer k. Your goal is to collect all elements from 1 to k by removing elements from the end of the array.

In each operation, you can:

Remove the last element from the array
Add it to your collection

Return the minimum number of operations needed to collect all elements from 1, 2, 3, ..., up to k.

Example: If nums = [3, 1, 5, 4, 2] and k = 2, you need to collect elements 1 and 2. Starting from the end: remove 2 (1 operation), remove 4 (2 operations), remove 5 (3 operations), remove 1 (4 operations). Now you have both 1 and 2, so the answer is 4 operations.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We need to collect elements 1 and 2. Working backwards: remove 2 (1 op), remove 4 (2 ops), remove 5 (3 ops), remove 1 (4 ops). Now we have both 1 and 2.

example_2.py — All Elements at End

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

› Output: 3

💡 Note: We need elements 1 and 2. Working backwards: remove 2 (1 op), remove 1 (2 ops), remove 5 (3 ops). Now we have both required elements.

example_3.py — Single Element

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

› Output: 1

💡 Note: We need element 1, but we only have 2. We must remove 2 (1 operation) to satisfy the condition of performing operations, though we won't actually collect 1.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 1000
nums contains all integers from 1 to k at least once

Visualization

Tap to expand

Understanding the Visualization

Identify Target

You need to collect book volumes 1 through k from your stack

Work from Top

Start removing books from the top, keeping track of which required volumes you find

Track Progress

Use a checklist (hash set) to mark off each required volume as you find it

Stop When Complete

Once you've found all required volumes, count how many books you removed

Key Takeaway

🎯 Key Insight: By working backwards and using a hash set to track progress, we can stop immediately when all required elements are collected, minimizing unnecessary operations.

Asked in

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

The optimal approach uses a hash set to track collected elements while iterating backwards through the array. This achieves O(n) time complexity and stops as soon as all required elements are found, making it efficient for early termination cases.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Suffixes)	O(n² × k)	O(1)	Try every possible suffix length until all elements 1 to k are found
One-Pass Hash Set (Optimal)	O(n)	O(k)	Iterate backwards using a hash set to track collected elements

Brute Force (Check All Suffixes) — Algorithm Steps

Start with suffix length 1 (just the last element)
For each suffix length, check if it contains all elements 1 to k
Use nested loops to verify presence of each required element
Return the first suffix length that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with length 1

Check if last 1 element contains all numbers 1 to k

Try length 2

Check if last 2 elements contain all numbers 1 to k

Continue until found

Keep increasing suffix length until all required numbers are found

Code -

solution.c — C

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

int minOperations(int* nums, int numsSize, int k) {
    // Try each suffix length from 1 to numsSize
    for (int length = 1; length <= numsSize; length++) {
        // Check if current suffix contains all elements 1 to k
        bool foundAll = true;
        
        for (int target = 1; target <= k; target++) {
            bool found = false;
            // Check last 'length' elements for target
            for (int i = numsSize - length; i < numsSize; i++) {
                if (nums[i] == target) {
                    found = true;
                    break;
                }
            }
            
            if (!found) {
                foundAll = false;
                break;
            }
        }
        
        if (foundAll) {
            return length;
        }
    }
    
    return numsSize;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int k;
    
    // Read array elements
    char c;
    while (scanf("%d%c", &nums[numsSize], &c) > 0) {
        numsSize++;
        if (c == '\n') break;
    }
    
    scanf("%d", &k);
    
    printf("%d\n", minOperations(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

For each of n possible suffix lengths, we check k elements, and for each element we scan up to n positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures

✓ Linear Space

23.0K Views

Medium Frequency

~15 min Avg. Time

850 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 Suffixes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler