Java – Creating a looping square with java

javaloops

Full Disclosure: Homework.

Explanation: I cant understand my teacher.

Problem:

Write a method called printSquare that takes in two integer
parameters, a min and a max, and prints the numbers in the range from
min to max inclusive in a square pattern. The square pattern is
easier to understand by example than by explanation, so take a look at
the sample method calls and their resulting console output in the
table below. Each line of the square consists of a circular sequence
of increasing integers between min and max. Each line prints a
different permutation of this sequence. The first line begins with
min, the second line begins with min + 1, and so on. When the
sequence in any line reaches max, it wraps around back to min. You
may assume the caller of the method will pass a min and a max
parameter such that min is less than or equal to max

enter image description here

I cannot for the life of me figure out how to make the numbers stop at the 'max' value and start over in the middle of the line.

This is what I have so far, apologies but I have trouble with for loops.

for(int i = 0; i < row; i++)
{
    for(int d = 0; d < row; d++)
    {
        System.out.print(d+1);
    }
    System.out.println(i);
}

I know I used row twice, but its the only way i can get the compiler to form a square shape with the loop. Does anyone even remotely understand what i'm trying to do? :/

Best Answer

This is actually a nice mathematical problem. Assume:

int side = to - from + 1; /// the size/width of the square.

the value at any point in the square (row, col) is:

from + ((row + col) % side)

you should be able to put that in your loops and "smoke it".

Edit based on comment asking for explanation.

The trick is to loop through all the positions in the 'matrix'. Given that the matrix is square, the loops are relatively simple, just two loops (nested) that traverse the system:

    final int side = to - from + 1;
    for (int row = 0; row < side; row++) {
        for(int col = 0; col < side; col++) {
            ... magic goes here....
        }
    }

Now, in this loop, we have the variables row and col which represent the cell in the matrix we are interested in. The value in that cell needs to be proportional to the distance it is from the origin..... let me explain.... If the origin is the top left (which it is), then the distances from the origin are:

0 1 2 3 4
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8

The distance is the sum of the row and the column...... (rows and columns start counting from 0).

The values we put in each matrix are limited to a fixed range. For the above example, with a square of size 5, it could have been specified as printSquare(1,5).

The value in each cell is the from value (1 in this example) plus the distance from the origin... naively, this would look like:

1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
5 6 7 8 9

here the values in the cell have exceeded the limit of 5, and we need to wrap them around... so, the trick is to 'wrap' the distances from the origin..... and the 'modulo' operator is great for that. First, consider the original 'origin distance' matrix:

0 1 2 3 4
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8

if we instead populate this matrix with 'the remainder of the distance when dividing by 5' (the modulo 5, or %5) we get the matrix:

0 1 2 3 4
1 2 3 4 0
2 3 4 0 1
3 4 0 1 2
4 0 1 2 3

Now, if we add this 'modulo' result to the from value (1), we get our final matrix:

1 2 3 4 5
2 3 4 5 1
3 4 5 1 2
4 5 1 2 3
5 1 2 3 4

in a sense, all you need to know is that the value at each cell is:

the from value plus the remainder when you divide the 'distance' by the width.

Here's the code I tested with:

public static final String buildSquare(final int from, final int to) {
    final StringBuilder sb = new StringBuilder(side * side);

    final int side = to - from + 1;

    for (int row = 0; row < side; row++) {
        for(int col = 0; col < side; col++) {
            sb.append( from + ((row + col) % side) );
        }
        sb.append("\n");
    }
    return sb.toString();

}

public static void main(String[] args) {
    System.out.println(buildSquare(1, 5));
    System.out.println(buildSquare(3, 9));
    System.out.println(buildSquare(5, 5));
    System.out.println(buildSquare(0, 9));
    System.out.println(buildSquare(0, 3));
}
Related Topic