Card Flipping Game - Practice Coding Problems

Card Flipping Game - Problem

You are given two 0-indexed integer arrays fronts and backs of length n, where the i^th card has the positive integer fronts[i] printed on the front and backs[i] printed on the back.

Initially, each card is placed on a table such that the front number is facing up and the other is facing down. You may flip over any number of cards (possibly zero).

After flipping the cards, an integer is considered good if it is facing down on some card and not facing up on any card.

Return the minimum possible good integer after flipping the cards. If there are no good integers, return 0.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Numbers 1 and 4 appear on both sides of some cards, so they can't be good. Number 2 only appears on the front of card 1, so we can flip all other cards to hide number 2 completely, making it good.

Example 2 — No Good Numbers

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

› Output: 0

💡 Note: The only number is 1, which appears on both sides of the same card. It's impossible to make any number good, so return 0.

Example 3 — Multiple Options

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

› Output: 0

💡 Note: Every number (1,2,3) appears on both sides of at least one card. Number 2 appears on both sides of card 1, and numbers 1,3 appear on both cards but opposite sides. No number can be completely hidden.

Constraints

n == fronts.length == backs.length
1 ≤ n ≤ 1000
1 ≤ fronts[i], backs[i] ≤ 2000

Visualization

Tap to expand

Understanding the Visualization

Initial State

All cards show front numbers, backs are hidden

Identify Constraints

Numbers on both sides of same card can't be good

Find Solution

Minimum number that can be completely hidden

Key Takeaway

🎯 Key Insight: A number is good only if it never appears on both sides of the same card

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that a number can only be good if it doesn't appear on both sides of any single card. We identify impossible numbers (same on both sides) and find the minimum from the remaining candidates. Best approach uses hash sets for O(n) time complexity. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Numbers	O(n²)	O(n)	Check every unique number to see if it can be made good
Hash Set Optimization	O(n)	O(n)	Use sets to efficiently track same-card numbers and candidates

Brute Force - Check All Numbers — Algorithm Steps

Collect all unique numbers from fronts and backs
For each number, check if it appears on both sides of any card
If not, it's a candidate - find the minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Numbers

Gather all unique numbers from both arrays

Check Each Number

For each number, verify it doesn't appear on both sides of any card

Find Minimum

Return the smallest valid number

Code -

solution.c — C

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

int solution(int* fronts, int frontsSize, int* backs, int backsSize) {
    int allNumbers[2001] = {0}; // assuming numbers are <= 2000
    
    for (int i = 0; i < frontsSize; i++) {
        allNumbers[fronts[i]] = 1;
        allNumbers[backs[i]] = 1;
    }
    
    int minGood = INT_MAX;
    
    for (int num = 1; num <= 2000; num++) {
        if (!allNumbers[num]) continue;
        
        int canBeGood = 1;
        for (int i = 0; i < frontsSize; i++) {
            if (fronts[i] == num && backs[i] == num) {
                canBeGood = 0;
                break;
            }
        }
        
        if (canBeGood && num < minGood) {
            minGood = num;
        }
    }
    
    return minGood == INT_MAX ? 0 : minGood;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int fronts[1000], backs[1000];
    int frontsSize = 0, backsSize = 0;
    
    // Parse fronts array
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        fronts[frontsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    // Parse backs array
    token = strtok(line + 1, ",]");
    while (token != NULL) {
        backs[backsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(fronts, frontsSize, backs, backsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Set to store all unique numbers

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

867 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 Numbers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler