Iteration into Recursion

Question

Hi ..
can someone help me turn the iteration in the code below into recursion
// Note: phone number must be input in the form #######.
// Only the digits 2 through 9 are recognized.
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Formatter;
import java.util.FormatterClosedException;
import java.util.IllegalFormatException;
public class Phone
   private int phoneNumber[];
   // output letter combinations to file
   public void calculate( int phoneNumber )
      String letters[][] = { { " ", " ", " " },
         { " ", " ", " " }, { "A", "B", "C" }, { "D", "E", "F" },
         { "G", "H", "I" }, { "J", "K", "L" }, { "M", "N", "O" },
         { "P", "R", "S" }, { "T", "U", "V" }, { "W", "X", "Y" } };
      int digits[] = new int[ 7 ];
      for ( int i = 6; i >= 0; i-- )
         digits[ i ] = ( int )( phoneNumber % 10 );
         phoneNumber /= 10;
      } // end for
      Formatter output = null;
      try
         output = new Formatter( "phone.txt" );
      } // end try
      catch ( SecurityException securityException )
         System.err.println(
            "You do not have write access to this file." );
         System.exit( 1 );
      } // end catch
      catch ( FileNotFoundException fileNotFoundException )
         System.err.println( "Error creating file." );
         System.exit( 1 );
      } // end catch
      System.out.println( "Please wait..." );
      try
         int loop1; // loop counter for first digit of phone number
         int loop2; // loop counter for second digit of phone number
         int loop3; // loop counter for third digit of phone number
         int loop4; // loop counter for fourth digit of phone number
         int loop5; // loop counter for fifth digit of phone number
         int loop6; // loop counter for sixth digit of phone number
         int loop7; // loop counter for seventh digit of phone number
         // output all possible combinations
         for ( loop1 = 0; loop1 <= 2; loop1++ )
            for ( loop2 = 0; loop2 <= 2; loop2++ )
               for ( loop3 = 0; loop3 <= 2; loop3++ )
                  for ( loop4 = 0; loop4 <= 2; loop4++ )
                     for ( loop5 = 0; loop5 <= 2; loop5++ )
                        for ( loop6 = 0; loop6 <= 2; loop6++ )
                           for ( loop7 = 0; loop7 <= 2; loop7++ )
                              output.format( "%s%s%s%s%s%s%s\n",
                                 letters[ digits[ 0 ] ][ loop1 ],
                                 letters[ digits[ 1 ] ][ loop2 ],
                                 letters[ digits[ 2 ] ][ loop3 ],
                                 letters[ digits[ 3 ] ][ loop4 ],
                                 letters[ digits[ 4 ] ][ loop5 ],
                                 letters[ digits[ 5 ] ][ loop6 ],
                                 letters[ digits[ 6 ] ][ loop7 ] );
                           } // end for
                        } // end for
                     } // end for
                  } // end for
               } // end for
            } // end for
         } // end for
      } // end try
      catch ( IllegalFormatException illegalFormatException )
         System.err.println( "Error in format of output." );
         System.exit( 1 );
      } // end catch
      catch ( FormatterClosedException formatterClosedException )
         System.err.println(
            "Error sending output; File has been closed." );
         System.exit( 1 );
      } // end catch
      finally
         System.out.println( "Done." );
         if ( output != null )
            output.close(); // close output stream
      } // end finally
   } // end method calculate
} // end class Phone

Answer 1

Heila wrote:
I know a little about recursion .. and what's commen between them is that they have a base case and a caling for thesame method with the update needed. right?Yes, but what's important about that is that it means that to solve the problem over the whole set, you solve the same problem over parts of the set and then combine the results, which means, a) You have to understand how to define the algorithm in terms of itself, and b) you have to understand what the base case is. Do you know those parts for this problem?
As an example, factorial (N!) can be defined as:
N! = N * (N - 1)! if N > 1
N! = 1 if 0 <= N <= 1
Undefiend if N < 0
So we see that the "defining factorial in terms of itself" part is N * (N - 1)!, and that the base case is when N is 0 or 1.
Now, if you're going to define "find all sequences of N values" in terms of itself, how would you do that (without Java)?