Card Flipping Game

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: 1

💡 Note: Number 2 appears on both sides of card 1 (front=2, back=2), so it can't be good. Numbers 1 and 3 appear on different cards and can be made good. The minimum good number is 1.

Constraints

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

Visualization

Tap to expand

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

✓ Math

⏱️ Time: N/A Space: N/A

Brute Force - Check All Numbers

⏱️ Time: O(n²) Space: O(n)

Collect all unique numbers from both arrays, then for each number check if it can be completely hidden by flipping appropriate cards. A number can be good only if it never appears on both sides of the same card.

Hash Set Optimization

⏱️ Time: O(n) Space: O(n)

First pass identifies numbers that appear on both sides of the same card (impossible to make good). Second pass finds the minimum number that can be made good by checking if it's not in the impossible set.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* fronts, int* backs, int n) {
    // Get all unique numbers
    int all_numbers[2000]; // Sufficient for reasonable input sizes
    int unique_count = 0;
    
    // Add all numbers from both arrays
    for (int i = 0; i < n; i++) {
        // Check if fronts[i] is already in all_numbers
        bool found = false;
        for (int j = 0; j < unique_count; j++) {
            if (all_numbers[j] == fronts[i]) {
                found = true;
                break;
            }
        }
        if (!found) {
            all_numbers[unique_count++] = fronts[i];
        }
        
        // Check if backs[i] is already in all_numbers
        found = false;
        for (int j = 0; j < unique_count; j++) {
            if (all_numbers[j] == backs[i]) {
                found = true;
                break;
            }
        }
        if (!found) {
            all_numbers[unique_count++] = backs[i];
        }
    }
    
    int min_good = INT_MAX;
    
    // Check each number to see if it can be good
    for (int i = 0; i < unique_count; i++) {
        int num = all_numbers[i];
        bool can_be_good = true;
        
        // Check if this number appears on both sides of any card
        for (int j = 0; j < n; j++) {
            if (fronts[j] == num && backs[j] == num) {
                can_be_good = false;
                break;
            }
        }
        
        if (can_be_good && num < min_good) {
            min_good = num;
        }
    }
    
    return min_good == INT_MAX ? 0 : min_good;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endptr;
        arr[(*size)++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
}

int main() {
    char line1[10000], line2[10000];
    
    // Read both input lines
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int fronts[1000], backs[1000];
    int fronts_size, backs_size;
    
    parseArray(line1, fronts, &fronts_size);
    parseArray(line2, backs, &backs_size);
    
    int result = solution(fronts, backs, fronts_size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear 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