From Algorithm to Java Program

Hello students, welcome to Kwickprep. Many students jump straight into typing code, and then get stuck halfway. Toppers do it the other way round. They write the algorithm first, turn each step into Java, and then test with sample inputs. Today we will do exactly that for one full problem, in the style of a board practical paper.

An algorithm is a step by step plan to solve a problem. It is a finite list of clear, numbered steps. It is written in plain English, so it does not depend on any language. Each step says what to read, what to calculate, or what to print. And it always ends, with a Stop step.

Here is our problem, a typical practical question. A Niven number, also called a Harshad number, is divisible by the sum of its digits. Take eighteen. One plus eight is nine, and eighteen mod nine is zero, so it is a Niven number. Take nineteen. One plus nine is ten, and the remainder is nine, so it is not. If the input is zero or negative, the program must print Invalid Input.

Now the algorithm. Step one is Start. Step two reads the number n. Step three checks the input first. If n is zero or less, we print Invalid Input and jump to the last step. Step four sets sum to zero, and copies n into t. We copy it, because we will break t into digits, but we still need n at the end.

Step five checks, are the digits over? If t is zero, go to step seven. Step six adds the last digit, which is t mod ten, to sum. Then it removes that digit by dividing t by ten, and goes back to step five. Step seven prints Niven if n mod sum is zero, else Not Niven. Step eight is Stop.

Before writing any Java, we dry run the algorithm with eighteen. First, t is eighteen, the last digit is eight, and sum becomes eight. Then t is one, the digit is one, and sum becomes nine. Now t is zero, so the loop ends with sum nine. Eighteen mod nine is zero, so the plan prints Niven, which is correct.

Now we translate, one step at a time. Read n becomes a Scanner call, nextInt. Check and stop becomes an if, with a return statement that ends main. Steps five and six, which repeat, become a while loop. Step seven becomes an if else, with println.

Here are steps two and three. A Scanner reads input from the keyboard, and needs import java dot util dot Scanner at the top. nextInt reads the number n. If n is zero or less, we print Invalid Input. Then return ends the main method at once, which is our go to Step eight.

Step four declares sum and t. The while loop runs while t is greater than zero, which is step five. Inside, plus equals adds the last digit to sum, and slash equals removes that digit, exactly as step six says. Step seven uses double equals to compare, and prints Niven or Not Niven. Notice the comments. They link each part of the code to its step, and examiners like that.

While you are still building, you can test the core logic with a fixed value, instead of typing input every time. Here n is eighteen. The same digit loop is written as a for loop, and plus equals means add to sum. It prints true, because eighteen is a Niven number. Once this works, put the Scanner back.

Testing means running the program on chosen inputs, and checking every output. First, work out the expected output by hand, before you run. Pick normal values, one that should pass and one that should fail. Pick boundary values, which sit at the edge, like zero and one. Pick invalid values, like a negative number. Then run each one, and compare.

Here is a test table for our program. Eighteen should print Niven. Nineteen should print Not Niven. Pause and predict, what about one? Its digit sum is one, and one mod one is zero, so Niven. Zero must print Invalid Input, and this also saves us from dividing by a zero sum. Minus twelve must print Invalid Input too.

Now let us see how a board practical paper asks this kind of question. You get a problem statement, with sample inputs and outputs. You write an algorithm first, in clear steps. Then you write the Java program, with comments and meaningful variable names. Next, you run it on the given test data and on some of your own. Finally, the output must match the format shown, including messages like Invalid Input.

Four tips will save you marks. Always check invalid input before any calculation, just as we did in step three. Keep a copy of any value you will need later, like copying n into t. Number your steps, and use the same numbers in your comments. And dry run the algorithm on paper, before you type a single line.

Let us revise. First, write the algorithm as numbered steps in plain English. Next, turn each step into Java, one step at a time, and link them with comments. Then test with normal, boundary and invalid inputs, and compare with answers worked out by hand. In the practical, present the algorithm, the documented program, and the test output.