Problem

In this sample problem, we will design a program that can determine the sequence of a combination lock, and keep track of the number of attempts until the combination is broken.

The program will begin by prompting the user to configure their combination lock. The user will then enter in THREE numbers ranging from 0 to NUM_POSSIBILITIES (in this example, we will assume NUM_POSSIBILITIES to be 59, but you may change this within the source code to a larger or smaller number if you like). We will store each number within an integer array of size 3, since there are three numbers that we need to select in sequence in order to break the lock.

After the lock has been configured, the program will then proceed in attempting to break the lock. After every attempt, the program should increment a counter, num_attempts, until the lock has been broken.

SideSectionTitle

Taken from http://www.flickr.com/photos/daniello/565304023/

An image or By Students section

Solution

Before we start thinking about the solution, we need to declare all of our variables that we'll need in order to arrive at a solution. We'll declare two constants, the first will be the number of possibilities, NUM_POSSIBILITIES, for each dial on the lock. This can be any positive number. The higher the number, the harder the lock will be to break. The second constant will be the number of dials on the lock (we're using 3 dials in this problem) which we'll call NUM_DIALS. We'll also need an array of size 3 called "combo" to represent our combination lock, a boolean value called "found" that we can set to true once we find the correct sequence (so we don't keep trying to break the lock after it's already been broken), and an integer called "num_attempts" that we'll use to count the number of attempts before we actually break our lock.

		final int NUM_POSSIBILITIES = 59; // you can change this to any size you like
		final int NUM_DIALS = 3;
		
		int[] combo = new int[NUM_DIALS]; // the combination lock
		boolean found = false; // so we know when to stop...
				
		int num_attempts = 0; // we'll keep track of the number of attempts

We will then need to read in three numbers from the user, where each number represents the correct number to select in sequence to unlock the combination. For example, if the user enters "25", "12", "55", then the correct sequence to break the combination lock is 25-12-55. Also, Since we'll be using an array of size 3, well assign each number to their correct position in the array (eg. [25,12,55]). We'll accomplish this using a loop that will iterate over three times, and read an integer from the console:

	
		
		Scanner in = new Scanner(System.in); // create a new "scanner" so we can get user input from the console

		// read in combination
		for (int i = 0; i < NUM_DIALS; i++)
		{
			System.out.println("Enter a number from 0 to " + 
				NUM_POSSIBILITIES + " for the combination: " ); 
									
			// this command allows the user to enter a number
			// and assign it to a spot in our int array
			combo[i] = in.nextInt();
		}//end for

To approach the solution, we need to think about how we will simulate each dial on the lock. Since there are three dials, we can use three nested for-loops, each simulating one dial. Each loop will iterate 0 to NUM_POSSIBILITIES, but will stop iterating as soon as we've found the correct lock sequence. We'll need another condition specified in each loop to achieve this. NOTE: Typing "!found" is the same as typing "found == false". We usually read it as "while not found".

		for (int i = 0; i <= NUM_POSSIBILITIES && !found; i++)
		{			
			for (int j = 0; j <= NUM_POSSIBILITIES && !found; j++)
			{				
				for (int k = 0; k <= NUM_POSSIBILITIES && !found; k++)
				{
					num_attempts++; // increment the number of attempts

					// more code here
				
				}//end for
			}//end for
		}//end for

Finally, all we need to do in order to check if our current sequence matches the combination lock's sequence, is compare each loop counter with each of the dials on the lock (remember, our lock is represented by an array of size 3, so we'll be comparing the array and indexes 0 to 2). If our current sequence matches the lock's sequence, then we can print a message to the console saying that we've broken the lock! We can also print how many attempts there were before we found the correct sequence. Also, don't forget to set our boolean value to true so we don't continue to try to break the lock!

					// if we have the right sequence of numbers, then we've broken
					// the lock!
					if (i == combo[0] && j == combo[1] && k == combo[2])
					{
						System.out.println("*** Combination broken ***");
						System.out.println("Sequence: [" + i + "][" + j + "][" + k + "]");
						System.out.println("Attempts: " + num_attempts);
						found = true;
					}//end if

Code

SolutionCode goes here. Please DO NOT put your code in <pre> tags!