'Java Recursion printing asterisks from one method call

I have an assignment introducing Recursion in Java and I am running into a roadblock. The assignment requires a recursion method to output a number of lines of a number of asterisks depending on the integer value passed to it. For example, if 4 is passed in as variable n, the output would have a first line of one asterisk, next line 2 asterisks, next 3 asterisks, next 4, then 4, 3, 2, & 1 going down.

I have been able to complete the first half of the output (not sure if it is optimal though), but have no clue how to get the method to reverse back down. This is all to be done in one method call with a variable (n) passed to the method.

Here is the method I have so far:

    public static void myMethod(int n)
    {       
    if (n <= 1) {
            System.out.print("*");          
    } else {
        myMethod(n - 1);
        for (int i = 0; i < n; i++) {
            System.out.print("*");
        }
    }

    System.out.print("\n"); // new line
    }

It is called from main with this:

    myMethod(n);

So what I have is a for loop that will print an asterisk on the same line 'n' times. After the for loop it proceeds to the next line and cycles, changing n. But I have no idea how to get it to reverse.

My method prints from the method. My instructor showed me a sample version passing 2 variables (n) and a null string.

    public static String myMethod(int n, String displayStr) {       
        String currentStr = "";

    for (int i = 0; i < n; i++)
        currentStr += "*";
        currentStr += "\n";

        if (displayStr == null){
            return myMethod((n - 1), currentStr);   
        } // end base case

        else if (n > 0){
            return myMethod((n - 1), (currentStr + displayStr + currentStr));
        }

        else {
            return displayStr;
        }
    } // end recursion method myMethod

His version prints from main using the following code line:

    System.out.println(myMethod(n, null));

I have tried his version and it prints the triangle on it's side but the largest line only prints once instead of twice. I have spent all day trying to alter his to add in a duplicate line in the middle and am starting to think it isn't possible.

Any help would be GREATLY appreciated. I am at a complete standstill with this.

javarecursion


Solution 1:[1]

Change the method signature to public static void myMethod(int n, boolean reversed) where reversed is initialized to false but flips to true when you print n asterisks. Inside the method, reverse your logic if reversed is true.

Solution 2:[2]

You basically just need to print out the current row, then do the recursive call, then print the row again. That way, you get the stack buildup on the way up, and then again on the way down.

Here is an example that uses 2 parameters, one being the max length and the other being the iterator for the recursion.

// bootstrap method to start the recursion
public static void myMethod(int length)
{
    myMethod(length, length);
}

public static void myMethod(int length, int i)
{
    if (i > 0)
    {
        int rowLength = length - i + 1;

        printRow(rowLength, '*');

        myMethod(length, i - 1);

        printRow(rowLength, '*');
    }
}

public static void printRow(int length, char symbol)
{
    for (int i = 0; i < length; i++)
        System.out.print(symbol);
    System.out.println();
}

Solution 3:[3]

Because the output counts up (not *down to zero), you must pass in the number of asterisks to print and the maximum number, so the terminating condition can be established.

Further, the pseudo code for your method is:

  • if n > max return (terminating condition)
  • print n asterisks
  • recursively call with n + 1
  • print n asterisks

A great deal of code simplification can be achieved if you pass in not the current length to print, but the String of asterisks, so your (private) recursive method could be simply:

private static void myMethod(int n, String s) {
    if (s.length() < n) return;
    System.out.println(s);
    myMethod(n, s + "*");
    System.out.println(s);
}

And your public method, which sets up the initial conditions, is then:

public static void myMethod(int n) {
    myMethod(n, "*");
}

IMHO an elegant implementation with good code density.

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1 Zim-Zam O'Pootertoot
Solution 2
Solution 3

Related Questions