Card Flipping Game in Java

Developers frequently use card-flipping games to demonstrate their programming prowess. The development of a card-flipping game in Java will be discussed in this post. We'll talk about several strategies and offer comprehensive code samples with explanations.

Problem Statement

The ith card has the positive integer fronts[i] written on the front and backs[i] printed on the rear of two 0-indexed integer arrays fronts and backs of length n. Each card is initially laid out on a table with the front number facing up and the back number facing down. Any number of cards (maybe none) may be turned over by you.

An integer is deemed to be good after the cards have been flipped if it appears on a card that is face down and not on any other card.

After flipping the cards, return the smallest good integer that can be calculated. Return 0 if there are no suitable integers.

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

Output: 2

Method 1

The CardFlipping class contains a static method flipgame, which takes two arrays fronts and backs as parameters. This method calculates the minimum number that can be flipped to reveal a card that is different from both its front and back values.

Implementation

Create two sets: both and either. The both sets will store the card values that are the same in both fronts and backs arrays, and the either set will store all unique card values from both arrays.

Iterate through the fronts and backs arrays using a loop. For each index i, perform the following checks:

If the value at fronts[i] is equal to the value at backs[i], it means the card is the same on both sides. Add the value to the both set.
Otherwise, add both fronts[i] and backs[i] values to the either set.
After iterating through all the cards, we have identified the cards that are the same on both sides (both set) and all unique cards from both arrays (either set).
Iterate through the either set and check if each value exists in the both set. If a value does not exist in the both set, it means that flipping that card will reveal a different value. Return this value as the minimum number of flips required.
If all unique cards have the same value on both sides or if the either set is empty, return 0 to indicate that no flips are required.

In the main() method, an example scenario is created with fronts and backs arrays containing card values. The flipgame method is called with these arrays, and the result is printed to the console.

In the provided example scenario, the fronts array has the values {1,2,4,4,7} and the backs array has the values {1,3,4,1,3}. The expected output is 2, which means that flipping at least two cards will reveal different values on both sides.

Overall, the flipgame method efficiently determines the minimum number of flips required to find a card with a different value on its front and back.

Filename: CardFlipping.java

import java.util.*;
import java.io.*;
public class CardFlipping 
{
    public static int flipgame(int[] fronts, int[] backs) {
        Set<Integer> both = new HashSet<>();
        Set<Integer> either = new TreeSet<>();
        for (int i = 0; i < fronts.length; i++) {
            if(fronts[i] == backs[i]) both.add(fronts[i]);
            else{
                either.add(fronts[i]);
                either.add(backs[i]);
            }
        }
        for (Integer integer : either) {
            if(!both.contains(integer)) return integer;
        }
        return 0;
    }
    public static void main(String[] args) {
        int fronts[] = {1,2,4,4,7};
        int backs[] = {1,3,4,1,3};
       int ans=flipgame(fronts,backs);
       System.out.println(ans);
            }
    }

Output:

Method 2

K cannot be the solution if a card has the value K inscribed on both the front and the back since the answer will remain the same no matter how many times the card is turned over.
No matter how often the number K appears in the front array, simply flip all the cards over to ensure there is no longer a card with K written on the front. From there, we can simply choose any card (minimum) that has K written on its back, and it will be the answer.
The issue now boils down to locating all the numbers K1, K2,..., Kn so that they are not repeated on any card, and then determining the minimum among all the numbers written on the backs of K1, K2,..., Kn.
Print 0 if the outcome is not achievable.

CardFlipping.java

import java.util.*;
import java.io.*;
public class CardFlipping
{
    public static int flipgame(int[] fronts, int[] backs) {
    //Card flips do not affect the result.
    //if(back !== front) set contains
    //else math min check
    int result = Integer.MAX_VALUE;
    HashSet<Integer> set = new HashSet<Integer>();
    for(int i = 0; i < fronts.length; i++) {
        if(fronts[i] == backs[i]) set.add(fronts[i]);
    }
    for(int i = 0; i < fronts.length; i++) {
        if(set.contains(fronts[i]) == false) {
            result = Math.min(result, fronts[i]);
        }
        if(set.contains(backs[i]) == false) {
            result = Math.min(result, backs[i]);
        }
    }
return result == Integer.MAX_VALUE ? 0 : result;
}
    public static void main(String[] args) {
        int fronts[] = {1,2,4,4,7};
        int backs[] = {1,3,4,1,3};
       int ans=flipgame(fronts,backs);
       System.out.println(ans);
            }
    }

Output:

Next TopicCreate Generic Method in Java

← prev next →