Problem

As you may know, computers work on the binary system. In this system, numbers are written using only 0s and 1s. In this question, you’ll write a program to convert binary numbers to normal (decimal) numbers.

How are all numbers represented in 0s and 1s?

• Instead of having digits 0,1,...,9, in binary, we only have digits 0 and 1.
• So zero is 0, and the next number is represented by 1, but after that, we have no digit 2, so we have to represent the next number in the same way we do after we go past 9 in the decimal system: by 10.
• We continue in this way: 3 in binary is 11.
• Now what about 4? We can’t write 4 as 12 (because we only have 1 and 0 to work with, not 2). So we put a zero in the last position, and carry the 1. This would give 20, but again, we don’t have a digit 2, so we again carry the 1 and get 100 as the binary representation of 4.

Here are the first few numbers written in both decimal (normal) notation and binary:

Suppose we have a binary number (a sequence of zeroes and ones) and we want to convert it to a decimal number. To do this, we multiply the digit (0 or 1) in each position of the number by an increasing power of two the further we move left. So the value of the binary number 1011001 is

1 * 2^6 + 0 * 2^5 + 1 * 2^4 + 1 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0 = 89

Program Specifications

• Write a program that requests input as a binary integer and prints out its value as a decimal number.
• Get input using Scanner.
• Use integer division and remainder to extract digits from the input binary number.
• Assume the user only inputs numbers with digits 0 and 1, so no error checking is needed.
• Use a loop so the user can continue to input binary numbers until they input -1 , then exit.
• Here is a sample run of the program with output:

Enter a binary number:1001010
1001010 in decimal is 74.
Enter a binary number:1001111
1001111 in decimal is 79.
Enter a binary number:10000111
10000111 in decimal is 135.
Enter a binary number:-1
Programmed by [your name here].
End of processing.

Output

Use System.out.println() for output. Follow the format of the output shown above.

Note for further development: You may notice that your program fails for large numbers. That's because of integer overflow. If you would like to get your program to work for larger binary numbers, replace int with long in your program (including using the Scanner method nextLong()).

Numbers

Solution

The greatest way to start a problem is to divide it into smaller problems. Clearly, the main problem to solve is converting binary numbers to decimal numbers. Think of input using the scanner class and looping for more input as the other two sub-problems. You can divide a problem any way you see fit; I've decided to break this problem into three parts:

• converting binary numbers to decimal numbers
• input using the scanner class
• looping for more input

The first part of the solution shows how to convert from binary numbers to decimal numbers going from pseudocode to working Java code. The second part shows how to use the scanner class to obtain input from the terminal. The third part shows how to add a loop to your code in order to keep prompting the user for input. Let's start by solving the main problem.

Convert from Binary Numbers to Decimal Numbers

On our road to a solution, we will take a detour and forget about writing Java code. Instead we will use something simpler. We can draw diagrams, write equations, and write pseudocode. We can always write Java code once we understand how to solve the problem. However, let’s go completely off track, and make sure we understand what binary numbers and decimal numbers are.

Numbers are not all the same. Human beings have used many different number systems throughout the ages. People today are used to decimal numbers, but this wasn’t always so. Decimal numbers are base 10, and some people may say it makes sense because we usually count with 10 fingers. However, we have 12 months in a year rather than 10, and 7 days in a week not 10. Decimal numbers are the numbers you are used to. We use 1,2,3,4,5,6,7,8,9, to represent values and 0 as a place-holder and to represent no amount. Before we can understand the binary system, let’s understand how the decimal system works.

You know intuitively that 123 is one-hundred and twenty-three, and you have a good idea of what that means. However, to understand decimal in depth, you’ll want to be able to explain it mathematically.

123 = 3 + 2* 10 + 1 * 100
This is better represented as:
123 = 3 * 10^0 + 2* 10^1 + 1 * 10^2

Now that we have explained how decimal numbers work, it is time to explain binary numbers. Binary numbers work exactly as decimal works except instead of 10, we use 2. And we only use the digits 0 and 1.

The binary number 100 means:
100 = 0 + 0* 2 + 1 * 4
This is better represented as:
100 = 0 * 2^0 + 0* 2^1 + 1 * 2^2

However, the best way to be sure we know how to convert the binary numbers to decimal numbers is to do it. Let's check that we understand by converting some numbers from binary to decimal on paper. By solving the problem on paper, we can more easily see the steps. Convert the following numbers from binary to decimal on paper: 101, 1000, 1101, 10101. When you are done, check for the solution at the end of this case study (in Solutions to Exercises). The solution to the first number follows:

 100 
 Convert to decimal.
 Start at rightmost digit.
 0 * 2^0 = 0
 0 * 2^1 = 0
 1 * 2^2 = 4
 answer: 0 + 0 + 4 = 4. 100 in binary is 4 in decimal.

The next step is to describe the steps you used. This will be your pseudocode. Do not focus on writing Java-like pseudocode, start by writing it out in English. I started with the following pseudocode:

1. Take the rightmost digit, 
      if it is a 1, multiply it by 2 to the power of the current exponent and add it to the sum.
2. Do the same with digits to the left of the rightmost digit.

More thinking shows we need to tell what sum, and what exponent to start at. Let's also add variables for clarity.

currPower = 0
sum = 0

Take the rightmost digit currDigit. 
if currDigit == 1
   sum = sum + currDigit * 2 ^ currPower
Do the same with digits to the left of the rightmost digit.

In the problem specification, you may have read: "Use integer division and remainder to extract digits from the input binary number." This command is a very vague description of how to process the input number. Let's look at how to do this in more detail.

Use Modulus

In Java, you can use some basic arithmetic operators, you can multiply, divide, add, subtract, and obtain the remainder.

Perhaps you expect me to teach about the extract-rightmost-digit operator. Unfortunately, it does not exist. We need to use the basic arithmetic operators to do our bidding. Fortunately, there's a solution for that.

The rightmost digit of a number is the exact same thing as the remainder of a number divided by 10. For example, the remainder of 26 divided by 10 is 6. In Java, we would write 26 % 10 to do the same operation.

Use Integer Division

In order to go through the number digit-by-digit, from right to left, you will want to ignore the rightmost digit. How do we do this?

Recall that Java allows for integer division. This means the division of two integers ignores any fractions. So 3/2 evaluates to 1 in Java although it equals 1.5 in regular math.

To chop off the rightmost digit, we simply divide by 10. In Java, we would write 26 /10 and the result would be 2, not 2.6.

You can continue improving the pseudocode slightly until you have replaced much of the English instructions with Java-like code. Here is an example of my result.

currPower = 0
sum = 0

while (binaryNum!= 0)
{
    currDigit = binaryNum % 10  //right most digit 
    sum = sum + currDigit * 2 ^ currPower
    binaryNum = binaryNum / 10 //do the same with the digits to the left of the rightmost digit
}
//This code has syntax errors

Now that you have some code, let's make sure that it is sound. Let's compile it.

Create a Java file.

Define the class in a Java file. Name the file the same name as the class name plus the ".java" extension. Define the main method.

The following code shows the result of these steps.

public class BinaryNum
{
  public static void main(String[] args)
  {
  }
}

Take the code for converting numbers, and paste it into the main method. Then compile it and fix any errors. You may need to add semicolons, and declare variables.

You will need to add an output statement so you can see the results. As for input, just set the binaryNum variable in the code for now (this is called hardcoded input).

public class BinaryNum
{
 public static void main(String[] args)
 {
   int binaryNum = 101;  //hardcoded input
   int currPower = 0;
   int sum = 0;

   while (binaryNum!= 0)
   {
     currDigit= binaryNum % 10  //right most digit 
     if (currDigit == 1)
     {
       sum = sum + currDigit* 2 ^ currPower;
     }
     binaryNum = binaryNum / 10; //do the same with the digits to the left of the rightmost digit
   }
   System.out.println(binaryNum + "in decimal is " + sum);
 }
}

You are likely to discover small syntactical errors when you try to compile your code. After successfully compiling, you might find that the program gives incorrect output. Then, you will need to accept that your code is incorrect, and try to determine the problem. However, it can be difficult to see the mistake if the same type of thinking that produced the error is used to see the error. You need to think like the machine to see the error. Go through your code line by line, and determine what went wrong.

After fixing my code I had the following main method:

public static void main(String[] args)
{
  int binaryNum = 101;  //hardcoded input
  int currPower = 0;
  int sum = 0;
  int currDigit;
  int copyOfBinNum = binaryNum;

  while (copyOfBinNum!= 0)
  {
    currDigit = copyOfBinNum % 10;  //right most digit
    sum = (int) (sum + currDigit * Math.pow(2, currPower));
    copyOfBinNum = copyOfBinNum / 10; 
    currPower = currPower + 1;
  }
  System.out.println(binaryNum + " in decimal is " + sum);
}

Now test your code with different values of binaryNum. Be sure to recompile after changing your code and before testing it. Once you are satisfied, that your code correctly converts binary numbers to decimal numbers move to the next step.

Handle Input

To handle input, we are going to use the scanner class. To use the scanner class we have to import it first. Classes often provide useful methods. By importing a class, we gain access to these methods. For a more detailed instructions on how to use the scanner class read Input_using_Scanner .

Import the scanner class. Do this by including the following line at the top of the Java file, before the class definition. The line tells the compiler where to find the scanner class.

import java.util.Scanner;

Declare and instantiate the scanner class. Because we want to read from the terminal as opposed to a file, instantiate the scanner class with System.in as a parameter. System.in represents the terminal. You can give the scanner class any name that is a valid identifier; you don’t have to use “aScanner”.

Scanner aScanner = new Scanner(System.in);

Now that we have an instance of the scanner in the code we need to decide how to use it. Before we can choose which method to use, we need to decide how we want to store our input. Storing the numbers as a string would prevent us from being able to use remainder and integer division to convert the number to binary. We must store the number as an integer.

However, there are two types of primitive integer types: int and long. A long is a primitive type for storing integers with twice as much storage space (from -2^64 to (2^64)-1), where as an int goes from -2^32 to (2^32)-1). Longs store larger integer values than int. For this example, you should store the inputted number as a long. By storing the number as a long we are less likely to encounter the problem of overflow. Overflow is exactly like it sounds, the number is too big for the variable to store.

You will have to declare the variable that stores the input as a long instead of an int, thus:

long binaryNumber

Once you have chosen what type of variable to store the input in, choosing the appropriate input method is trivial. If you decided to store the input as a long, use the nextLong() method in order to read in a long from the terminal. If you decided to store the input as an int, use the nextInt() method. The following line shows how to store the input in your input variable using the Scanner class.

binaryNumber = aScanner.nextLong();

Finally, we need to replace the hardcoded input with actual input. The only reason we used hardcoded input is to allow us to test our program before we implement input. In this case, hardcoded input is a form of scaffolding, a part of the code you use when developing, but that is not part of the final product. So get rid of the hardcoded input.

Replace the following line:

int binaryNumber = 101;  //hardcoded input

with

binaryNumber = aScanner.nextLong();

Add a Loop

From the program specification, we know that we need a loop.

Determine the kind of loop. The two types of loops are for-loops and while-loops. Use a for-loop if you can determine in advance, how many times the loop will run. For example, if you need to print out each element in an array then use a for-loop. In this case, we do not know how many times the user will input binary numbers. Therefore, use a while-loop.

Specify the termination condition of the loop. From the program specification, we know we need to stop when the user inputs -1. Expressed using the word while, we need to continue prompting for input while the input is not -1.

while(binaryNumber != -1)
{
  //place code to repeat here
}

Solution to Exercises

101 = 5, 1000 = 8, 1101 = 13, 10101 = 21.

Code

Solution Code

import java.util.Scanner;

/**
 * PURPOSE: calculates the decimal version of a binary number.
 */
public class BinaryNum{


	public static void main(String[] args) {
		Scanner kbd = new Scanner(System.in);

		long binaryNumber, copyOfBinNum;	// input from the user.
		int decimalNumber; 		 	// output value.
		final int BASE = 2;			// binary base.
		int currDigit, currPower;		// values used in loops.

		// get input from the user.
		System.out.print("Enter a binary number:");
		binaryNumber = kbd.nextLong();

		// keep looping until -1 is encountered.
		while (binaryNumber != -1) {

			// reset values to 0, use copyOfBinNum for calculations.
			decimalNumber = 0;
			currPower = 0;
			copyOfBinNum = binaryNumber;

			// keep looping until all digits of copyOfBinNum are removed.
			while (copyOfBinNum > 0) {

				// get last digit and strip it off copyOfBinNum
				currDigit = (int) copyOfBinNum % 10;
				copyOfBinNum /= 10;

				// add to the running total if the digit is one
				if (currDigit == 1) {
					decimalNumber += Math.pow(BASE,currPower);
				}

				// increment the power of two for next loop.
				currPower++;
			}

			// output the right decimal value.
			System.out.println(binaryNumber + " in decimal is " + decimalNumber + ".");

			// get ready for next iteration of the loop.
			System.out.print("Enter a binary number:");
			binaryNumber=kbd.nextLong();
		}
		System.out.println("Programmed by [your name here].");
		System.out.println("End of processing.");


	}

}