Help with program spelling out a number between 1-999.

[Alex Gallo]

This is the code given. The program is supposed to take a number between 1-999 that the user inputs, and spells it out. What's confusing me the most is the implementation of the Random methods the prof put in there.

//Program to spell positive 3-digit numberss
//
import java.util.*;
import javax.swing.*;
public class Assignment4
{
   public static void main(String[] args)
   {
      String input;  //input buffer
      boolean anotherInput = true; //repeat flag
      
      while ( anotherInput )
      {
         //User enters a 3-digit number, or Cancel to quit
         input = JOptionPane.showInputDialog(null, "Enter a Positive Number, 1 ... 999" +
                                                   "\nOR click on \"Cancel\" to quit" );
         if (input == null)   //User hit "Cancel"
            anotherInput = false;
         
         else                 //Number entered
         {
            //Parse input as an integer
            int positive = Integer.parseInt( input );
            
            //Reject integers that are non-positive, or more than 3 digits
            if (positive <= 0 || positive > 999)
               throw new RuntimeException("Invalid input: " + positive);
            
            //Display the spelling (in words) of the input integer  
            String spelling = threeDigitSpelling( positive );
            
            JOptionPane.showMessageDialog(null, positive + "  " + spelling);
         }
      }
   }
      
   //Return the spelling (in words) of any positive number up to 3 digits
   //Parameter number : any positive whole number 1 ... 999
   private static String threeDigitSpelling(int number)
   {
      //Obtain the individual digits of the number   
      int hundreds = decimalDigit(2, number);
      int tens = decimalDigit(1, number);
      int ones = decimalDigit(0, number);
      
      //The spelling that will be returned
      String words = "";
      
      //Intrepret the hundreds digit to extend the spelling

      
      //Interpret the tens digit to extend the spelling. 
      //There are three different cases:
      //    a) tens > 1, b) tens == 1, c) tens == 0
      
      
      //Interpret the ones digit to extend the spelling
      
      
      //Return the spelling
      String[] verse = {"Hickory Dickory Dock!", 
                        "The Mouse Ran Up The Clock!",
                        "The Clock Struck One!", 
                        "The Mouse Ran Down!",
                        "Hickory Dickory Dock!"    };   
      return verse[ (new Random()).nextInt(verse.length) ];
   }
 
   
   //Helper method: Returns the ones-word spelling of a single digit
   // Zero, One, Two, ..., Nine
   //Parameter digit : 0 ... 9, identifies the desired ones-word   
   private static String onesWord(int digit)
   {
      return "" + digit;
   }

   
   //Helper method: Return the teen-word spelling of a single digit
   // Ten, Eleven, Twelve, ..., Nineteen
   //Parameter digit : 0 ... 9, identifies the desired teen-word
   private static String teenWord(int digit)
   {
      return "" + digit;   
   }
 
   
   //Helper method: Return the tens-word spelling of a single digit
   // Zero, Ten, Twenty, ..., Ninety
   //Parameter digit : 0 ... 9, identifies the desired tens-word  
   private static String tensWord(int digit)
   {
      return "" + digit;   
   }

   //Helper method: Return a digit of any positive integer
   //Parameter index  : indexes the desired digit, 0 = least significant
   //Parameter number : the integer whose digit is required
   //Example: decimalDigit(3, 57419) returns 7
   private static int decimalDigit(int index, int number)
   {
      //ALGORITHM:
      //Step 1: Divide number by 10, index times
      //Step 2: Find the remainder of number from Step 1 with 10
      //Step 3: Return the remainder from Step 2
      
      return (new Random()).nextInt(10);
   }   
}
            
            

[Ramesh Pramuditha Rathnayake]

Random is used as an example, as an implementation of those methods. But you have to erase that Random parts and should write your own program to get the relevant output. Try yourself..

[Alejandro Loaiza]

for decimalDigit() i worked up:

switch ( index )
{
case 9: number /= 10;
case 8: number /= 10;
case 7: number /= 10;
case 6: number /= 10;
case 5: number /= 10;
case 4: number /= 10;
case 3: number /= 10;
case 2: number /= 10;
case 1: number /= 10;
case 0: return number % 10;
default: return 0;

I also erased the random there. Would this be correct coming from the Algorithm?

[Alejandro Loaiza]

I also worked on onesWord() and I got:

switch ( digit )
{
case 0: return "zero";
case 1: return "one";
case 2: return "two";
case 3: return "three";
case 4: return "four";
case 5: return "five";
case 6: return "six";
case 7: return "seven";
case 8: return "eight";
case 9: return "nine";
default: throw new RuntimeException("Non-Digit " + digit);
}
i erased the random there. would this be correct?

[Alex Gallo]

It seems like it works (no errors), but that verse variable is still being brought up on the return.

Edit:

I removed the entire section of verse, but I dont know what I should set the return to for that part. If I do "words", then it gives me the correct digit in the ones, but that's it. (e.g 123 spells out just three)

Here is the new code: http://pastebin.com/u2KZumjN

[Alex Gallo]

//Program to spell positive 3-digit numberss
//
import java.util.*;
import javax.swing.*;
public class Assignment4
{
   public static void main(String[] args)
   {
      String input;  //input buffer
      boolean anotherInput = true; //repeat flag
     
      while ( anotherInput )
      {
         //User enters a 3-digit number, or Cancel to quit
         input = JOptionPane.showInputDialog(null, "Enter a Positive Number, 1 ... 999" +
                                                   "\nOR click on \"Cancel\" to quit" );
         if (input == null)   //User hit "Cancel"
            anotherInput = false;
         
         else                 //Number entered
         {
            //Parse input as an integer
            int positive = Integer.parseInt( input );
           
            //Reject integers that are non-positive, or more than 3 digits
            if (positive <= 0 || positive > 999)
               throw new RuntimeException("Invalid input: " + positive);
           
            //Display the spelling (in words) of the input integer  
            String spelling = threeDigitSpelling( positive );
           
            JOptionPane.showMessageDialog(null, positive + "  " + spelling);
         }
      }
   }
     
   //Return the spelling (in words) of any positive number up to 3 digits
   //Parameter number : any positive whole number 1 ... 999
   private static String threeDigitSpelling(int number)
   {
      //Obtain the individual digits of the number  
      int hundreds = decimalDigit(2, number);
      int tens = decimalDigit(1, number);
      int ones = decimalDigit(0, number);
     
      //The spelling that will be returned
      String words = "";
     
      //Intrepret the hundreds digit to extend the spelling
   switch (hundreds)
      {
         case 1: words = "one hundred";
         break;
         case 2: words = "two hundred";
         break;
         case 3: words = "three hundred";
         break;
         case 4: words = "four hundred";
         break;
         case 5: words = "five hundred";
         break;
         case 6: words = "six hundred";
             break;
         case 7: words = "seven hundred";
             break;
         case 8: words = "eight hundred";
             break;
         case 9: words = "nine hundred";
             break;
     
   }
      //Interpret the tens digit to extend the spelling.
      //There are three different cases:
      //    a) tens > 1, b) tens == 1, c) tens == 0
      if (tens !=1){
           switch (tens){
               case 2: words = "twenty";
                   break;
               case 3: words = "thirty";
                   break;
               case 4: words = "forty";
                   break;
               case 5: words = "fifty";
                   break;
               case 6: words = "sixty";
                   break;
               case 7: words = "seventy";
                   break;
               case 8: words = "eighty";
                   break;
               case 9: words = "ninety";
                   break;
               case 0: words = "";
                   break;
           }
      }
       else if (tens==1){
           switch (ones){
               case 0: words = "ten";
                   break;
               case 1: words = "eleven";
                   break;
               case 2: words = "twelve";
                   break;
               case 3: words = "thirteen";
                   break;
               case 4: words = "fourteen";
                   break;
               case 5: words = "fifteen";
                   break;
               case 6: words = "sixteen";
                   break;
               case 7: words = "seventeen";
                   break;
               case 8: words = "eighteen";
                   break;
               case 9: words = "nineteen";
                   break;
           }
   }
   
           
         
      //Interpret the ones digit to extend the spelling
      switch (ones)
      {
         case 1: words = "one";
         break;
         case 2: words = "two";
         break;
         case 3: words = "three";
         break;
         case 4: words = "four";
         break;
         case 5: words = "five";
         break;
         case 6: words = "six";
             break;
         case 7: words = "seven";
             break;
         case 8: words = "eight";
             break;
         case 9: words = "nine";
             break;
         case 0: words = "";
             break;
      }
   
      //Return the spelling  
      String[] verse = {"Hickory Dickory Dock!",  
                        "The Mouse Ran Up The Clock!",  
                        "The Clock Struck One!",  
                        "The Mouse Ran Down!",  
                        "Hickory Dickory Dock!"    };    
      return verse[ (new Random()).nextInt(verse.length) ];
 
   
   }
   
   //Helper method: Returns the ones-word spelling of a single digit
   // Zero, One, Two, ..., Nine
   //Parameter digit : 0 ... 9, identifies the desired ones-word  
   private static String onesWord(int digit)
   {switch ( digit )
{
case 0: return "zero";
case 1: return "one";
case 2: return "two";
case 3: return "three";
case 4: return "four";
case 5: return "five";
case 6: return "six";
case 7: return "seven";
case 8: return "eight";
case 9: return "nine";
default: throw new RuntimeException("Non-Digit " + digit);
}
     
   }
 
   
   //Helper method: Return the teen-word spelling of a single digit
   // Ten, Eleven, Twelve, ..., Nineteen
   //Parameter digit : 0 ... 9, identifies the desired teen-word
   private static String teenWord(int digit)
   {
      return "" + digit;  
   }
 
   
   //Helper method: Return the tens-word spelling of a single digit
   // Zero, Ten, Twenty, ..., Ninety
   //Parameter digit : 0 ... 9, identifies the desired tens-word  
   private static String tensWord(int digit)
   {
      return "tens" + digit;  
   }
 
   //Helper method: Return a digit of any positive integer
   //Parameter index  : indexes the desired digit, 0 = least significant
   //Parameter number : the integer whose digit is required
   //Example: decimalDigit(3, 57419) returns 7
   private static int decimalDigit(int index, int number)
   {
           
      //ALGORITHM:
      //Step 1: Divide number by 10, index times
      //Step 2: Find the remainder of number from Step 1 with 10
      //Step 3: Return the remainder from Step 2
      switch ( index )
{
case 2: number /= 10;
case 1: number /= 10;
case 0: return number % 10;
default: return 0;
   
      }
   }
}

[Piet Souris]

I suggest concentrating on getting the method

private static int decimalDigit(int index, int number)  

correct. All other methods depend on the digits that this method returns.

Take for example the number 321.

Now, determine how we would get the first digit, 3. This would be invoked by

decimalDigit(2, 321).

The algorithm to do this is given in the comment, so let's use it:

divide 321 by 10, the number of times to do this being equal to the index.

So here goes:

321 / 10 = 32 (integer division, so the fraction is cut off)
32 / 10 = 3

So, we've done it two times, and we get 3 as a result. And it's correct!

Now, try to figure out how we could get the '2' when we invoke:

decimalDigit(1, 321)

(although I must say that in the given algortihm step 2) is rather unclear to me)

[Tony Docherty]

The reason you need step 2 is if you want say the second digit from your example you would have:

decimalDigit(1, 321);

321 / 10 = 32 (integer division, so the fraction is cut off)

We've done it one time so now we get the remainder when divided by 10

32 % 10 = 2

and that's the number we return.

[Alejandro Loaiza]

can someone explain:
private static int decimalDigit(int index, int number)
{

//ALGORITHM:
//Step 1: Divide number by 10, index times
//Step 2: Find the remainder of number from Step 1 with 10
//Step 3: Return the remainder from Step 2
switch ( index )
{
case 2: number /= 10;
case 1: number /= 10;
case 0: return number % 10;
default: return 0;

[Tony Docherty]

can someone explain:

No, it's not correct.
See my earlier post (which carries on from Piet's post) explaining what to do.

[Ramesh Pramuditha Rathnayake]

I think the methods teenWord(int), tenWord(int), ... are there for return the String that gives the spelling to an input number. But you have done all of them in threeDigitSpelling method.
And in each case you have to write word+=reading but not word=reading. That is one mistake.
In early post, I told you to erase all the Random codings. But you have left one in threeDigitSpelling method. You have to remove that and you should return word in that method as it has the spelling of the number.
The array verse is also an demonstration only. It is not necessary to the software.

[Alejandro Loaiza]

would applying switches to teenWord() and tensWord() still be beneficial?

[Ramesh Pramuditha Rathnayake]

No..
Now there is no need of those methods.

[Winston Gutkowski]

Alejandro Loaiza wrote:would applying switches to teenWord() and tensWord() still be beneficial?

No, and you're concentrating too much on code. So: StopCoding (←click).

My advice: Take several two- and three-digit numbers at random, write them out, and really look at them hard. What do they have in common? What don't they?

You're some way towards a solution, but you're not there yet; and some of what you have is using "brute force" rather than rational logic. There's nothing wrong with that as a 'first cut'; but I suspect you'll work out that there are ways to reduce the number of strings you actually need to do the job.

This is NOT a simple problem, so you really need to think before you code.

HIH

Winston