Monty Hall Paradox in Java

Question

I was wondering if this code looks neat, and if I should change anything. I was planning to implement Frames (or JFrame) tomorrow on it. Would it be a good idea to use functions?

import java.lang.Math.*;
import java.util.Random;
import java.util.Scanner;

public class Paradox {
public static void main(String[] args){
    System.out.println("\n\nYou have got three doors, there is a price inside each of them. Pick a door: A, B, or C.");
    Door A = new Door();
    Door B = new Door();
    Door C = new Door();
    A.open=0;
    B.open=0;
    C.open=0;

    Random rand = new Random();
    int i = rand.nextInt(3);
    /*System.out.println(i);*/

    if(i==0) {
        A.goatorcar="Car";
        B.goatorcar="Goat";
        C.goatorcar="Goat";
    }
    else if (i==1){
        A.goatorcar="Goat";
        B.goatorcar="Car";
        C.goatorcar="Goat";
    }
    else if (i==2) {
        A.goatorcar="Goat";
        B.goatorcar="Goat";
        C.goatorcar="Car";
    } else { System.out.println("Unexpected error"); }



    int pickedA=0;
    int pickedB=0;
    int pickedC=0;

    Scanner sc = new Scanner(System.in);
    String pickedDoor = sc.nextLine();
    System.out.println("\n");

    if (pickedDoor.equals("A") || pickedDoor.equals("1") || pickedDoor.equals("a")){
        pickedA = 1;
    }
    if (pickedDoor.equals("B") || pickedDoor.equals("2") || pickedDoor.equals("b")){
        pickedB = 1;
    }
    if (pickedDoor.equals("C") || pickedDoor.equals("3") || pickedDoor.equals("c")){
        pickedC = 1;
    }

    if(pickedA==1) {
        if (A.goatorcar.equals("Car")){
            i = rand.nextInt(2);
            if (i==0){ System.out.println("The door B contains a Goat"); B.open=1; }
            else if (i==1){ System.out.println("The door C contains a Goat"); C.open=1; }
        }
        else {
        if (B.goatorcar=="Goat") { System.out.println("The door B contains a Goat"); B.open=1; }
        else if (C.goatorcar=="Goat") { System.out.println("The door C contains a Goat"); C.open=1; }
        }
    }
    else if (pickedB==1) {
        if (B.goatorcar.equals("Car")){
            i = rand.nextInt(2);
            if (i==0){ System.out.println("The door A contains a Goat"); A.open=1; }
            else if (i==1){ System.out.println("The door C contains a Goat"); C.open=1; }
        }
        else {
            if (A.goatorcar=="Goat") { System.out.println("The door A contains a Goat"); A.open=1; }
            else if (C.goatorcar=="Goat") { System.out.println("The door C contains a Goat"); C.open=1; }
        }
    }
    else if (pickedC==1) {
        if (C.goatorcar.equals("Car")){
            i = rand.nextInt(2);
            if (i==0){ System.out.println("The door A contains a Goat"); A.open=1; }
            else if (i==1){ System.out.println("The door B contains a Goat"); B.open=1; }
        }
        else {
            if (A.goatorcar=="Goat") { System.out.println("The door A contains a Goat"); A.open=1; }
            else if (B.goatorcar=="Goat") { System.out.println("The door B contains a Goat"); B.open=1; }
        }
    }
    else { System.out.println("You haven't picked any door"); System.exit(0); }


    System.out.println("\nKnowing where one of the Goats are, do you wish to stay on your current door, or do you want to change?");

    String changeornot = sc.nextLine();
    int change=2;
    System.out.println();

    if (changeornot.equals("change") || changeornot.equals("1") || changeornot.equals("yes")){
        change=1;
    }
    else if (changeornot.equals("stay") || changeornot.equals("0") || changeornot.equals("no")){
        change=0;
    }


    if(change==0){
        System.out.print("Congratulations! You stayed, and won a ");
        if(pickedA==1){
            System.out.println(A.goatorcar);
        }
        if(pickedB==1){
            System.out.println(B.goatorcar);
        }
        if (pickedC==1){
            System.out.println(C.goatorcar);
        }
    }

    else if (change==1){
        System.out.print("Congratulations! You changed, and won a ");
        if (pickedA==1 && B.open==1) {
            System.out.println(C.goatorcar);
        }
        if (pickedA==1 && C.open==1) {
            System.out.println(B.goatorcar);
        }

        if (pickedB==1 && A.open==1) {
            System.out.println(C.goatorcar);
        }
        if (pickedB==1 && C.open==1) {
            System.out.println(A.goatorcar);
        }

        if (pickedC==1 && A.open==1) {
            System.out.println(B.goatorcar);
        }
        if (pickedC==1 && B.open==1) {
            System.out.println(A.goatorcar);
        }   
    }
    else if (change==2){ System.out.println("Error at change"); }


/*System.out.println("Door A: " + A.goatorcar);
System.out.println("Door B: " + B.goatorcar);
System.out.println("Door C: " + C.goatorcar);*/

}
}
class Door {
String goatorcar;
int open;
} 

Answer 1

A few thoughts:

• Some of your lines are very long. While it may seem convenient that they fit on your screen, code gets more difficult to understand as lines become longer. Many people have good reasons to desire an eighty char line limit. This is my personal preference; and many people will disagree; but i find

  System.out.println(INTRODUCTION);
  

  more amiable than

  System.out.println("\n\nYou have got three doors, there is a price inside each of them. Pick a door: A, B, or C.");
  

  ... mainly because then I don't need to devote much of my screen real estate to a single file. If I am working on multiple files in multiple windows at once, or if I am using a Linux TTY, long lines become a pain if I need to scroll in four directions instead of two. As pointed out by astute readers, this practice is moreover archaic. These days, you can easily get away with lines longer than 80 characters.

• Writing modular code is an essential step towards ensuring your code isn't a hack. A hack is basically code that doesn't give freely to modification. When code is split up into methods, it becomes easier to understand, modify, and debug. For example, if you have instead a doorOption method that determines what door was chosen based on a String, you can simply call that method whenever you want the user to pick a door. The method can do the task of

  if (pickedDoor.toLowerCase().equals("a") || pickedDoor.equals("1"))
  

  in one place. You can also probably get away with enumerating the result of that method; that way you can refer to the results by name: DOOR_ONE DOOR_TWO, et cetera. Writing modular code can be a little daunting; but the rewards are quite desirable. Modular code is code that is divided into modules; each module does a specific task. According to Wikipedia,

  Modular programming is a software design technique that emphasizes separating the functionality of a program into independent, interchangeable modules, such that each contains everything necessary to execute only one aspect of the desired functionality.

• You have a lot of hard-coded strings. According to Google:

  [Hard coding is to] fix (data or parameters) in a program in such a way that they cannot be altered without modifying the program.

  You can probably get away with making those into static final fields. Something like

  static final String INTRODUCTION = "\n\nYou have got three doors, there is a price inside each of them. Pick a door: A, B, or C.";
  

  final means the variable can not be modified after assignment.

• I would look into making your code more maintainable before making a GUI. The process shouldn't be overly involved. I usually try to keep all the GUI methods in a separate class.

Answer 2

One-liners

This is not a huge point, but I noticed you have several one-liners which have multiple commands in them. Even though that's not technically "wrong" it could lead to some confusion for the next person who may have to maintain your code.

For example:

else if (pickedC==1) {
    if (C.goatorcar.equals("Car")){
        i = rand.nextInt(2);
        if (i==0){ System.out.println("The door A contains a Goat"); A.open=1; }
        else if (i==1){ System.out.println("The door B contains a Goat"); B.open=1; }
    }
    else {
        if (A.goatorcar=="Goat") { System.out.println("The door A contains a Goat"); A.open=1; }
        else if (B.goatorcar=="Goat") { System.out.println("The door B contains a Goat"); B.open=1; }
    }
}
else { System.out.println("You haven't picked any door"); System.exit(0); }

Something like this formatting would more easily indicate there's more going on than printing to console.

else if (pickedC==1) {
    if (C.goatorcar.equals("Car")){
        i = rand.nextInt(2);
        if (i==0){ System.out.println("The door A contains a Goat"); 
            A.open=1; }
        else if (i==1){ System.out.println("The door B contains a Goat"); 
            B.open=1; }
    }
    else {
        if (A.goatorcar=="Goat") { System.out.println("The door A contains a Goat"); 
            A.open=1; }
        else if (B.goatorcar=="Goat") { System.out.println("The door B contains a Goat"); 
            B.open=1; }
    }
}
else { System.out.println("You haven't picked any door"); 
    System.exit(0); }

Ideally though, many could say you should just follow the standard Java indentation throughout, even though it takes more vertical room it makes things perfectly clear, like this:

else if (pickedC==1) {
    if (C.goatorcar.equals("Car")) {
        i = rand.nextInt(2);
        if (i==0) { 
            System.out.println("The door A contains a Goat"); 
            A.open=1; 
        }
        else if (i==1) { 
            System.out.println("The door B contains a Goat"); 
            B.open=1; 
        }
    }
    else {
        if (A.goatorcar=="Goat") { 
            System.out.println("The door A contains a Goat"); 
            A.open=1; 
        }
        else if (B.goatorcar=="Goat") { 
            System.out.println("The door B contains a Goat"); 
            B.open=1; 
        }
    }
}
else { 
    System.out.println("You haven't picked any door"); 
    System.exit(0); 
}

Naming and spacing

Something like this:

if(i==0) {
    A.goatorcar="Car";
    B.goatorcar="Goat";
    C.goatorcar="Goat";
}

For one, the naming for variables like that would be easier to follow if you used camelCase, which is the convention for multi-word variables and methods. So goatorcar becomes more easily readable, goatOrCar.

Also a little bit of breathing room between operators would look better. Like this:

if(i == 0) {
    A.goatOrCar = "Car";
    B.goatOrCar = "Goat";
    C.goatOrCar = "Goat";
}

Answer 3

If would definitly help if you had a function to get the user input : you'd have a better separation of concerns, behavior would be easier to change and the user interface would be slightly more intuitive and user-friendly.

My Java is a bit rusty but something like (following code is not correct, what matters is the idea more than the code itself):

public static boolean getBooleanFromUser(String prompt, String retry, List<String> yesOptions, List<String> noOptions)
{
    System.out.println(prompt);
    while (true)
    {
        String userInput = sc.nextLine();
        System.out.println();
        if (yesOptions.contains(userInput))
            return true;
        if (noOptions.contains(userInput))
            return false;
        System.out.println(retry);
}

public static boolean userStaysOrNot()
{
    return getBooleanFromUser("\nKnowing where one of the Goats are, do you wish to stay on your current door, or do you want to change?", "Invalid input, please retry", ["change", "1", "yes"], ["stay", "0", "false"]);
}

Answer 4

I would use a boolean value to represent if the door has a car behind it or not. I would modify:

class Door {
String goatorcar;
int open;
} 

to

class Door {
    boolean hasCar;
    int open;
} 

Then, you can change all of

if(i==0) {
    A.goatorcar="Car";
    B.goatorcar="Goat";
    C.goatorcar="Goat";
}
else if (i==1){
    A.goatorcar="Goat";
    B.goatorcar="Car";
    C.goatorcar="Goat";
}
else if (i==2) {
    A.goatorcar="Goat";
    B.goatorcar="Goat";
    C.goatorcar="Car";
} else { System.out.println("Unexpected error"); }

to simply

A.hasCar = i == 0;
B.hasCar = i == 1;
C.hasCar = i == 2;

Much simpler!

Now, whenever you do A.goatcar.equals("Car"), you can change that to A.hasCar. Similarly, A.goatcar.equals("Goat") can become !A.hasCar. There are many more changes you could maker but this is an important one.

Answer 5

There are a lot of good suggestions in the other answers for improving the coding style of this program. If the goal is to simulate the set of a game show with a one-to-one correspondence between objects on the set and Objects in your source code, you should follow that advice as well as you can.

If the goal is simply to simulate the events that occur while playing the game, however (which appears to be the goal, since those are the only things that are output by the program), then there is a much simpler model of the game that will work just as well. This model is built around two variables describing the set of the game show:

• doorWithCar This variable has value 1, 2, or 3, indicating whether the car is behind the first, second, or third door.
• doorOpened This variable initially has value 0, when all the doors are closed; when Monty opens a door, this variable is assigned the number of the door Monty opened.

In addition, you can use two variables to represent the player's decisions:

• initialChoiceDoor The number of the door first chosen by the player.
• finalChoiceDoor The number of the door chosen by the player after Monty has opened one of the other doors.

Everything you need to know about the state of things at each stage of the game (up to the moment when Monty reveals what the player has won) can be represented by these four variables.

You'll still need code to handle input and output, for example a mapping from the values of the four variables above to the names of the doors (if you want to print names different from the values used for the internal state of the program), and an input function that takes a response from the user and determines what it means (door 1, 2, or 3; switch or stay). You might also want functions for things such as which door Monty opens (this function's input would be doorWithCar and initialChoiceDoor) or which door the player finally chooses (this function's input could be initialChoiceDoor, doorOpened, and a boolean value indicating whether the player chose to "switch").

You might end up with code where the main class looks something like this:

public class Paradox {
    public static void main(String[] args) {
        playGame();
    }

    void playGame() {
        Random randomVar   = new Random();
        int    doorWithCar = randomVar.nextInt(3);

        System.out.println("\n\nPick a door: A, B, or C.");
        Scanner sc = new Scanner(System.in);
        int initialChoiceDoor = doorSelectedByString(sc.nextLine());

        int doorOpened = chooseDoorToOpen(initialChoiceDoor, doorWithCar);

        System.out.println("The door " + nameOfDoor(doorOpened) + " contains a Goat");
        System.out.println("\nDo you want to change?");

        bool isChange = isChangeString(sc.nextLine());
        int  finalChoiceDoor = isChange ? neitherOfTheseDoors(initialChoiceDoor, doorOpened) :
                                          initialChoiceDoor ;

        String tactic = isChange ? "changed" : "stayed":
        String prize  = (finalChoiceDoor == doorWithCar) ? "Car" : "Goat";
        System.out.print("Congratulations! You " + tactic + ", and won a " + prize);
    }

    /* other functions here ... */
}

To handle bad input, you could have the functions doorSelectedByString and isChangeString print an error message and exit if the input does not make a valid choice; if you want to be able to re-use this class in a larger program, you could have these functions throw exceptions instead of exiting,and handle the exceptions in the main() function.

Admittedly, there is precious little in the way of object-oriented programming in this example. But the point is that this is such a simple exercise, it does not need a lot of objects. If you must create a bunch of objects just to handle such a simple problem, what do you do when you have to solve a problem that is fundamentally much more complicated? Keeping things as simple as possible means the code for large, complicated problems is easier to understand.

Answer 6

Here's a (partial) alternate version.

1. Instead of a Door class, a Door enum is used. It'd be trivial to use the int type instead, maybe save a little memory. But, it's convenient to have all the legal door values enumerated. State is stored directly in the game object, which is convenient (and works) because the game is so simple.
2. Implementations specify how the input happens, eg InteractiveGame, RandomGame, AlwaysSwitchGame, etc
3. Now you can test the game logic without simulating standard input.
4. The game algorithm is encapsulated in a short easy to read method.
5. Implementations specify the random source.
6. Consecutive games (whether real or test) can re-use a Random object instead of re-seeding every game.
7. Tests can make the random seed a fixture. Now tests are deterministic.

8. Each game has its own state. Your main method might run a few games, then display statistics. You can have a separate method that takes a Game and displays the result, eg

   Door A has the car. You picked door B. Door C was opened. You stuck with your pick and lost!

9. Each Game object is immutable. The game is run on construction. It leaves you with the outcome. You can safely process games in a multi-threaded environment.

.

public enum Door {
    A, B, C;
}

public abstract class Game {

    protected final Random rnd;
    public final Door hasCar;
    public final Door choice1;
    public final Door opened;
    public final Door choice2;

    protected abstract Door userPicks();
    protected abstract boolean userSwitches();

    public Game(Random rnd) {
        this.rnd = rnd;
        hasCar = Door.values()[rnd.nextInt(Door.values().length)];
        choice1 = userPicks();
        opened = hostOpens();
        choice2 = userSwitches() ? userPicks() : choice1;
    }

    private Door hostOpens() {
        List<Door> could = new ArrayList<>();
        for (Door d : Door.values()) {
            if (d != hasCar && d != choice1) {
                could.add(d);
            }
        }
        return could.get(rnd.nextInt(could.size()));
    }
}

Answer 7

Use some kind of data container like an array or a set to put the doors in. And yes, some methods might help as well.

Look at this version

import java.lang.Math.*;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.Scanner;

public class Paradox {
  private static Random rand = new Random();
  private static int cars = 0;

  private static String pickRandom(Set<String> set) {
    return (String)set.toArray()[rand.nextInt(set.size())];
  }

  public static void run(boolean automatic, String changeornot) {
    Set<String> closedDoors = new HashSet<>(Arrays.asList("A", "B", "C"));
    String doorWithCar = pickRandom(closedDoors);
    Set<String> doorsWithGoat = new HashSet<>(closedDoors);
    doorsWithGoat.remove(doorWithCar);

    Scanner sc = new Scanner(System.in);

    System.out.println("\n\nYou have got three doors, there is a price inside each of them. Pick a door: A, B, or C.");
    String pickedDoor = "";
    if(automatic) {
      pickedDoor = pickRandom(closedDoors);
    } else {
      while(true) {
        pickedDoor = sc.nextLine().toUpperCase();
        System.out.println("\n");
        try {
          pickedDoor = "" + (char)(Integer.parseInt(pickedDoor) - 1 + 'A');
        } catch(NumberFormatException e) {
        }
        if(closedDoors.contains(pickedDoor)) break;
        System.out.println("The door you chose is not available. Try again.");
      }
    }
    System.out.println("you picked door " + pickedDoor);
    Set<String> possibleChoices = new HashSet<>(doorsWithGoat);
    possibleChoices.remove(pickedDoor);

    String openDoor = pickRandom(possibleChoices);
    closedDoors.remove(openDoor);

    System.out.println("The door " + openDoor + " contains a Goat");

    System.out.println("\nKnowing where one of the Goats are, do you wish to stay on your current door, or do you want to change?");
    if(!automatic) {
      while(true) {
        changeornot = sc.nextLine().toLowerCase();
        System.out.println();

        if (changeornot.equals("1") || changeornot.equals("yes")) {
            changeornot = "change";
        }
        else if (changeornot.equals("0") || changeornot.equals("no")) {
            changeornot = "stay";
        }
        if(changeornot.equals("change") || changeornot.equals("stay")) break;
        System.out.println("choose either change or stay");
      }
    }
    if(changeornot.equals("change")) {
      closedDoors.remove(pickedDoor);
      pickedDoor = (String)closedDoors.toArray()[0];
    }
    String price = "goat";
    if(pickedDoor.equals(doorWithCar)) price = "car";
    System.out.print("Congratulations! You chose to " + changeornot + ", and won a " + price + ".");
    System.out.println();
    if(price.equals("car")) cars++;

    System.out.println("---------------------------------------");
  }

  public static void main(String[] args) {
    String choice = "stay";
    for(int i = 0; i < 1000; i++) run(true, choice);
    System.out.println("You chose to " + choice + " and won a total of " + cars + " cars.");
  }
}

edit: There was a lot of repetition in your code. That can be fixed by using variables so you can write e.g. System.out.println("The door " + openDoor + " contains a Goat"); instead of having several println statements that do the same job. Also using collection classes like Set or List can simplify things because you can then again use a variable to state which element in that collection you want to access instead of having to decide that when you write the code and you can also easily add or remove items from a collection allowing you to manage arbitrary amounts of data.