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.

After you have configured the lock, your output should look something like this:

 Breaking combination...
*** Combination broken ***
Sequence: [44][21][12]
Attempts: 159673
*** END OF PROCESSING. *** 

Problem Solving and Programming Examples

Solution

To solve the problem you have to what you need to solve this problem.
Since you have a constant number like possibilites and dials, they have to be declared final. You have to make a Scanner to get the user's input. Then next step is to use an array to store the combination that the user is going to input. This program isn't errorproof, there are no validation included so you have to assume the user will enter valid input, in this case will only enter numeric input.

 final int NUM_POSSIBILITIES = 59; // you can change this to any size you like
final int NUM_DIALS = 3;

Scanner keyboard = new Scanner(System.in);     //will get the input number
String input; // what we'll be using for input... we'll parse each input string to an int
int[] combo = new int[3]; // 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, we'll 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 a JOptionPane window.
Note: Don't forget to parse your input String to an int! Since the array is of type int, we can't assign String values to it.<br\>

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

 Enter a number from 0 to 59 for the combination: 5
Enter a number from 0 to 59 for the combination: 10
Enter a number from 0 to 59 for the combination: 45 

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 

 Breaking combination...
*** Combination broken ***
Sequence: [5][10][45]
Attempts: 18646
*** END OF PROCESSING. *** 

If combination was not found it means the user enter a digit higher than the possible number.

 if (!found)
{
	System.out.println("*** Could not break combination. ***");
}//end if 

 Enter a number from 0 to 59 for the combination: 30
Enter a number from 0 to 59 for the combination: 89
Enter a number from 0 to 59 for the combination: 29
Breaking combination...
*** Could not break combination. ***
*** END OF PROCESSING. *** 

Code

Solution Code

import javax.swing.*;
import java.util.Scanner;

public class Combination
{
	public static void main(String[] args)
	{
		final int NUM_POSSIBILITIES = 59; // you can change this to any size you like
		final int NUM_DIALS = 3;

                Scanner keyboard = new Scanner(System.in);
		String input; // what we'll be using for input... we'll parse each input string to an int
		int[] combo = new int[3]; // 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

		// read in combination
		for (int i = 0; i < NUM_DIALS; i++)
		{
			// this command allows the user to enter a number
			System.out.print("Enter a number from 0 to " + NUM_POSSIBILITIES +" for the combination: ");
	        input = keyboard.next();

			// now assign it to a spot in our int array
			combo[i] = Integer.parseInt(input);
		}//end for

		System.out.println("Breaking combination...");

		// try to break the combo
		// we'll use a loop for each "dial" on the lock
		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

					// 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
				}//end for
			}//end for
		}//end for

		// if we didn't find the sequence, then the user probably entered
		// a number outside of the specified ranger
		if (!found)
		{
			System.out.println("*** Could not break combination. ***");
		}//end if

		System.out.println("*** END OF PROCESSING. ***");
	}//end main
}//end Combination