Minimum Consecutive Cards to Pick Up - Practice Coding Problems

Minimum Consecutive Cards to Pick Up - Problem

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

Return the minimum number of consecutive cards you have to pick up to have a pair of matching cards among the picked cards. If it is impossible to have matching cards, return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: The minimum consecutive cards to pick up is [3,4,2,3] which has length 4. Cards at index 0 and 3 match.

Example 2 — No Matching Cards

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

› Output: -1

💡 Note: No matching cards exist, so we cannot find any pair.

Example 3 — Adjacent Matching Cards

$ Input: cards = [1,1]

› Output: 2

💡 Note: The minimum consecutive cards is [1,1] with length 2. Adjacent cards match.

Constraints

1 ≤ cards.length ≤ 10⁵
0 ≤ cards[i] ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array of card values [3,4,2,3,1]

Find Duplicates

Track positions and find matching cards

Calculate Window

Minimum window size is 4

Key Takeaway

🎯 Key Insight: Track the last position of each card value - when we see a duplicate, the window size is current_position - last_position + 1

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to track the last seen position of each card value using a hash map. When we encounter a duplicate, we calculate the window size as current_index - last_position + 1. The optimal approach uses hash map tracking with Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Subarrays	O(n³)	O(1)	Check every possible consecutive subarray for matching pairs
Hash Map - Track Last Positions	O(n)	O(n)	Use hash map to store last seen position of each card value

Brute Force - Check All Subarrays — Algorithm Steps

For each starting index i
Expand window from i until finding duplicate
Track minimum window size

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Index 0

Check subarray [3], then [3,4], then [3,4,2], then [3,4,2,3] - found duplicate!

Try All Positions

Repeat for each starting index

Return Minimum

Track the shortest subarray with duplicates

Code -

solution.c — C

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

int solution(int* cards, int n) {
    int minLength = INT_MAX;
    
    // Try all possible starting positions
    for (int i = 0; i < n; i++) {
        int seen[200001] = {0}; // Assuming card values fit in this range
        // Expand window from position i
        for (int j = i; j < n; j++) {
            if (seen[cards[j] + 100000]) { // Offset for negative numbers
                if (j - i + 1 < minLength) {
                    minLength = j - i + 1;
                }
                break;
            }
            seen[cards[j] + 100000] = 1;
        }
    }
    
    return minLength == INT_MAX ? -1 : minLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int cards[10000];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        cards[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", solution(cards, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Outer loop O(n), inner loop O(n), checking duplicates O(n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

987 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