Minimum Consecutive Cards to Pick Up - Practice Coding Problems

Minimum Consecutive Cards to Pick Up - Problem

Imagine you're a magician performing a card trick where you need to find matching pairs in the quickest way possible! 🎩✨

You are given an integer array cards where cards[i] represents the value of the i-th card. A pair of cards are matching if they have the same value.

Your challenge is to return the minimum number of consecutive cards you have to pick up to guarantee you have a pair of matching cards among the picked cards. If it's impossible to have matching cards (all cards are unique), return -1.

Example: If you have cards [3,4,2,3,4,7], you could pick up cards from index 0 to 3 (that's 4 consecutive cards: [3,4,2,3]) to get a matching pair of 3's. But there's a better way - pick up from index 1 to 4 (that's 4 consecutive cards: [4,2,3,4]) to get matching 4's. The minimum is 4 consecutive cards.

Input & Output

example_1.py — Basic Case

$ Input: [3,4,2,3,4,7]

› Output: 4

💡 Note: We can pick cards from index 0 to 3: [3,4,2,3] (length 4) or from index 1 to 4: [4,2,3,4] (length 4). Both contain matching pairs. The minimum consecutive cards needed is 4.

example_2.py — No Matches

$ Input: [1,2,3,4]

› Output: -1

💡 Note: All cards are unique, so there are no matching pairs. It's impossible to find consecutive cards with duplicates, hence return -1.

example_3.py — Adjacent Duplicates

$ Input: [1,2,2,3]

› Output: 2

💡 Note: We have adjacent matching cards at indices 1 and 2 (both are 2). The minimum consecutive cards to pick up is just these 2 cards.

Constraints

1 ≤ cards.length ≤ 10⁵
0 ≤ cards[i] ≤ 10⁶
At least one duplicate must exist for a valid answer

Visualization

Tap to expand

Understanding the Visualization

Deal First Card (3)

Remember: Card 3 was at position 0

Deal Cards 4, 2

Remember: Card 4 at position 1, Card 2 at position 2

Deal Second Card 3

Aha! Seen card 3 before at position 0. Distance = 3-0+1 = 4 cards

Continue Dealing

Keep tracking minimum distance for any duplicate pairs found

Key Takeaway

🎯 Key Insight: Use a hash map to remember the last position of each card. When you encounter a duplicate, the distance between positions gives you a valid consecutive subarray length!

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28

The optimal solution uses a hash table to track the last seen index of each card value. In a single pass, when we encounter a card we've seen before, we calculate the distance between current and last position. This distance represents the length of a consecutive subarray containing duplicate cards. We track the minimum such distance across all duplicates found.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible consecutive subarray for matching pairs
One-Pass Hash Table (Optimal)	O(n)	O(n)	Track last seen position of each card value in a single pass

Brute Force (Check All Subarrays) — Algorithm Steps

For each starting position i in the array
For each ending position j from i+1 onwards
Check if subarray [i..j] contains any duplicates
If yes, update minimum length and continue
Return the minimum length found, or -1 if none

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin checking subarrays starting from index 0

Expand window

Gradually expand the window and check for duplicates

Find duplicate

When duplicate found, record the length and move to next start position

Repeat process

Continue with all starting positions

Code -

solution.c — C

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

int minimumCardPickup(int* cards, int cardsSize) {
    int minLength = INT_MAX;
    
    // Try all possible starting positions
    for (int i = 0; i < cardsSize; i++) {
        bool seen[100001] = {false}; // Assuming card values <= 100000
        // Expand window from position i
        for (int j = i; j < cardsSize; j++) {
            if (seen[cards[j]]) {
                if (j - i + 1 < minLength) {
                    minLength = j - i + 1;
                }
                break;
            }
            seen[cards[j]] = true;
        }
    }
    
    return minLength == INT_MAX ? -1 : minLength;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for [1,2,3] format
    int cards[1000];
    int size = 0;
    
    char* ptr = strchr(input, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token && size < 1000) {
            cards[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    printf("%d\n", minimumCardPickup(cards, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: outer two for subarray bounds O(n²), inner loop to check duplicates O(n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and minimum length

✓ Linear Space

41.2K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler