Printing a frame within frame

Question

I got this assignment in Java and I don't have a single clue on how to do it. The task is to receive an integer n > 0, and to print n number of frames constructed by * inside each other, while the inner frame will have the letter "X" constructed by 4n+1 *. I can't use arrays or strings.

For example: n=1 will print:

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

n=2 will print:

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

This is what I have so far:

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int size = n * 6 + 1;
int x = 1;
int y = 1;

for (int i = 0; i < n; i = i + 1) {
    for (int i3 = 0; i3 < size; i3 = i3 + 1) {
        System.out.print("*");
    }

    System.out.println("");
    y = y + 1;

    for (int i1 = 0; i1 < size - 2; i1 = i1 + 1) {
        System.out.print("*");
        for (int i2 = 0; i2 < size - 2; i2 = i2 + 1) {
            System.out.print(" ");
        }

        System.out.println("*");
        y = y + 1;
    }

    for (int i4 = 0; i4 < size; i4 = i4 + 1) {
        System.out.print("*");
    }
}

Answer 1

There are many different approaches to this problem. This may not be the best, but it's quite simple and educational IMO.

The main idea is: you don't need to know how to print the entire frame. You only need to know how to print 1/4 of it - then repeat it in reverse X order, then repeat it in reverse Y order. Let's start with drawing X, specifically - one diagonal of it. If the "X" has to have 4n+1 *, it has 4 arms with a stars each and one * in the middle - totaling to 4 * a + 1 stars - so, obviously, 4n+1 == 4a+1, and each arm has to have exactly n *'s. Let's use XY Cartesian coordinate system. Thus, we only have an asterisk if x == y - otherwise we have s space there.

for ( int y = 0; y < n; y++ ) {
  for ( int x = 0; x < n; x++ ) {
    System.out.print( ( x == y ) ? '*' : ' ' );
  }
  System.out.println();
}

Now, let's add a mirror copy to it by iterating in reverse too:

for ( int y = 0; y < n; y++ ) {
  for ( int x = 0; x < n; x++ ) {
    System.out.print( ( x == y ) ? '*' : ' ' );
  }
  for ( int x = n; x >= 0; x-- ) {
    System.out.print( ( x == y ) ? '*' : ' ' );
  }
  System.out.println();
}

Now, let's try to get into valid Cartesian:

int x, y;
for ( y = -n; y <= n; y++ ) {
  for ( x = -n; x < 0; x++ ) {
    System.out.print( ( x == y || x == -y ) ? '*' : ' ' );
  }
  for ( ; x <= n; x++ ) {
    System.out.print( ( x == y || x == -y ) ? '*' : ' ' );
  }
  System.out.println();
}

and, finally, we can figure that it's just

for ( int y = -n; y <= n; y++ ) {
  for ( int x = -n; x <= n; x++ ) {
    System.out.print( hasAsterisk( Math.abs(x), Math.abs(y) ) ? '*' : ' ' );
  }
  System.out.println();
}

with, for example

static boolean hasAsterisk( int x, int y ) {
  return x == y;
}

Extend this code to handle the frames, and you're set. Each "quart part" of the frame is only * for each n, 2n chars total - the cross itself is n in length (see above) plus 1 central asterisk; to sum up, X and Y will range over int [-3n,3n] - call that 3n some m and use it as the range for iteration.

As an additional hint, the formula is different for the inner cross (i.e. abs(x)<n,abs(y)<n), and different for the frames themselves. The formula for the frames can be easily figured out if you notice that it's every second row, in the shape of two asterisk triangles in axis X added to two triangles in axis Y.

return ( x <= n && y <= n ) ? x == y : ( ( x < y ) ? y % 2 == nMod2 : x % 2 == nMod2 );