Card Flipping Game - Practice Coding Problems

Card Flipping Game - Problem

Card Flipping Game

You're given two arrays representing playing cards on a table. Each card has a number on both sides - one facing up (fronts) and one facing down (backs). Your goal is to find the smallest number that can be completely hidden by flipping some cards.

Rules:
• Initially, all cards show their front numbers
• You can flip any cards to show their back numbers instead
• A number is good if it appears face-down somewhere AND never appears face-up
• Return the smallest good number, or 0 if impossible

Example: If fronts = [1,2,4,4] and backs = [1,3,4,1], you could flip the first card to hide all 1s (making 1 good), or flip cards to make 3 good (since 3 only appears on backs).

Input & Output

example_1.py — Basic Case

$ Input: fronts = [1,2,4,4], backs = [1,3,4,1]

› Output: 2

💡 Note: We can flip the first card to make 1 face down, and 1 doesn't appear on any front after flipping. However, we can also consider other numbers. The number 2 appears only on front of second card, but we need it to appear on some back to be good. Actually, let me recalculate: we need numbers that appear on backs but can be made invisible on fronts. The number 3 appears only on backs[1], and number 1 appears on backs[3]. Both can potentially be good, but 1 is smaller, so answer should be 1. Wait, let me check the constraint again - if we flip card 0, front becomes back[0]=1 and back becomes front[0]=1, so 1 still shows. Actually, since fronts[0]=backs[0]=1, card 0 will always show 1 regardless of flipping. So 1 is impossible. The answer is 2.

example_2.py — No Solution Case

$ Input: fronts = [1], backs = [1]

› Output: 0

💡 Note: The only card has 1 on both sides, so 1 will always be visible regardless of flipping. No number can be made good, so return 0.

example_3.py — Multiple Options

$ Input: fronts = [1,2,3], backs = [3,2,1]

› Output: 0

💡 Note: Card 1 has 2 on both sides, making 2 impossible. Numbers 1 and 3 appear on backs, but both also must appear on fronts after any flipping strategy. Since every number appears on both fronts and backs, and one card always shows the same number on both sides, we cannot hide any number completely. Return 0.

Visualization

Tap to expand

Understanding the Visualization

Identify Cursed Cards

Find cards that show the same number on both sides - these numbers can never be hidden

Find Hidden Treasures

Look for numbers that appear on card backs but aren't cursed

Choose the Smallest

Among all valid candidates, pick the minimum number

Key Takeaway

🎯 Key Insight: Numbers that appear on both sides of the same card are 'cursed' and can never be completely hidden, no matter how you flip the cards!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two linear scans: one to find impossible numbers, one to find minimum valid back number

✓ Linear Growth

Space Complexity

O(n)

Hash set to store impossible numbers, which can be at most n numbers

⚡ Linearithmic Space

Constraints

n == fronts.length == backs.length
1 ≤ n ≤ 1000
1 ≤ fronts[i], backs[i] ≤ 2000
All integers are positive
Each card has exactly two sides with potentially different numbers

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a one-pass hash set approach with the key insight that numbers appearing on both sides of any single card can never be good. First identify these impossible numbers, then find the minimum number from the backs array that isn't impossible. This runs in O(n) time and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O(n²)	O(n)	Check each unique number to see if it can be made good
One-Pass Hash Set (Optimal)	O(n)	O(n)	Identify impossible numbers first, then find minimum among back numbers

Brute Force (Check Every Number) — Algorithm Steps

Collect all unique numbers from fronts and backs arrays
For each unique number, check if it can be made good
A number is good if: it appears on some back AND doesn't appear on both sides of any card
Return the minimum good number found, or 0 if none exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Numbers

Gather all unique numbers from both arrays

Check Each Number

For each number, verify if it can be made good

Find Minimum

Return the smallest valid candidate

Code -

solution.c — C

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

int flipgame(int* fronts, int frontsSize, int* backs, int backsSize) {
    // Since numbers are small, use array for uniqueness check
    int seen[2001] = {0}; // assuming numbers <= 2000
    int candidates[4001];
    int candidateCount = 0;
    
    // Collect all unique numbers
    for (int i = 0; i < frontsSize; i++) {
        seen[fronts[i]] = 1;
        seen[backs[i]] = 1;
    }
    
    // Check each unique number
    for (int num = 1; num <= 2000; num++) {
        if (!seen[num]) continue;
        
        // Check if this number can be made good
        int canBeGood = 0;
        int isImpossible = 0;
        
        // Check each card
        for (int i = 0; i < frontsSize; i++) {
            // If number appears on both sides of same card, impossible
            if (fronts[i] == num && backs[i] == num) {
                isImpossible = 1;
                break;
            }
            // If number appears on back, it can potentially be good
            if (backs[i] == num) {
                canBeGood = 1;
            }
        }
        
        // Add to candidates if possible and appears on some back
        if (!isImpossible && canBeGood) {
            candidates[candidateCount++] = num;
        }
    }
    
    if (candidateCount == 0) return 0;
    
    int minVal = INT_MAX;
    for (int i = 0; i < candidateCount; i++) {
        if (candidates[i] < minVal) {
            minVal = candidates[i];
        }
    }
    return minVal;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each unique number (up to 2n), we scan through all n cards to check validity

⚠ Quadratic Growth

Space Complexity

O(n)

Store all unique numbers in a set, which can be at most 2n numbers

⚡ Linearithmic Space

Constraints

n == fronts.length == backs.length
1 ≤ n ≤ 1000
1 ≤ fronts[i], backs[i] ≤ 2000
All integers are positive
Each card has exactly two sides with potentially different numbers

23.5K Views

Medium Frequency

~18 min Avg. Time

547 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler