使用递归打印空心正方形

Question

I've been searching around for this question, and have been receiving answers by using purely for-loops. The code I have so far is as follows:

import java.util.Scanner;

public class HollowSquare {


    public static void main(String args[]) {
        Scanner ma = new Scanner(System.in);
        System.out.print("Enter the number:");
        int max = ma.nextInt();

        for (int i = 1; i <= max; i++) {
            for (int j = 1; j <= max; j++) {

                if ((i == 1) || (i == max)) {
                    System.out.print("*");
                } else {
                    if (j == 1 || j == max) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();
        }
    }
}

While I understand the concept of recursion, I'm unsure of how to implement it in this area, and at this point, I've been looking at various if statements and using global variables (maybe not the best idea, but I'm relatively new to the concept of recursion).

I want to be able to understand recursion better than I do now, and this is one of the problems that I currently do not understand in terms of recursion.

Thank you to anyone and everyone who is able to help!

Answer 1

For the sake of recursion only. I even have one recursive method, repeatMiddleLine , call a different method that is in itself recursive, repeatChar .

public class HollowSquare {

    private static final char squareChar = '*';
    private static final char holeChar = ' ';

    public static void main(String[] args) {
        try (Scanner ma = new Scanner(System.in)) {
            System.out.print("Enter the number:");
            int max = ma.nextInt();
            repeatChar(squareChar, max);
            System.out.println();
            repeatMiddleLine(max - 2, max);
            repeatChar(squareChar, max);
            System.out.println();
        }
    }

    private static void repeatMiddleLine(int lineCount, int lineLength) {
        if (lineCount > 0) {
            System.out.print(squareChar);
            repeatChar(holeChar, lineLength - 2);
            System.out.println(squareChar);
            repeatMiddleLine(lineCount- 1, lineLength);
        }
    }

    private static void repeatChar(char c, int count) {
        if (count > 0) {
            System.out.print(c);
            repeatChar(c, count - 1);
        }
    }

}

When I enter 4, it prints:

****
*  *
*  *
****

Like you I am not doing any input validation. The user may type -30 and I don't know what the output will be, maybe a couple of blank lines. Or 20000000, and a stack overflow is likely. With input 1 it prints 2 lines each containing an asterisk. I believe you for loops behave better in this case. You can repair it if you want.

Answer 2

The basic idea is to write your recursive method so that it tracks which line you're on for half the number of lines, and:

1. writes the appropriate number of stars;
2. calls itself recursively, decrementing the line count;
3. after the recursion writes the appropriate number of stars again (which produces the bottom half of the square).

Step (3) is complicated slightly by checking whether you should skip if you're halfway through and have an odd value for n , in which case you don't want to write the additional line.

Here it is, written in Ruby. I didn't want to just give you the answer, and Ruby is practically pseudocode except you can actually run it.

def print_all_stars(n)
  puts '*' * n    # print n asterisks on a line
end

def print_end_stars(n)
  puts '*' + (' ' * (n - 2)) + '*'   # print an asterisk, n-2 spaces, and an asterisk
end

# The following method takes two arguments, but the 2nd arg
# has a default value if not explicitly specified.  This negates
# the need for end users to kick-start things by calling
# print_square(n, n), which would probably confuse people.

def print_square(n, current_level = n)
  # recursive base case, start backing out if we're halfway through the square
  return if current_level <= n / 2

  # step 1.
  if current_level == n
    print_all_stars(n)
  else
    print_end_stars(n)
  end

  # step 2.
  print_square(n, current_level - 1)    # recursive call!

  # Work done after the recursive call happens in reverse order,
  # as we back out of the call stack.  The following will print
  # the bottom half of the square, mirroring the top half except
  # for the case where n is odd.  In that case, we only want this
  # level of the recursion to print one line, not two. 

  # step 3.
  if current_level == n
    print_all_stars(n)
  elsif current_level > (n + 1) / 2    # here's the odd n check
    print_end_stars(n)
  end
end

print_square(3)

# produces:
#
#  ***
#  * *
#  ***

print_square(4)

# produces:
#
#  ****
#  *  *
#  *  *
#  ****