Printing a snake pattern using an array

Question

I'm having trouble with an assignment where we are required to print out this array:

1 10 11 20 21
2 9 12 19 22
3 8 13 18 23
4 7 14 17 24
5 6 15 16 25

My code is somewhat correct but it is not printing 10 and 19 where it should be.

My output:

Choose a number for the rows from 0 to 16.
5
Choose a number for the columns from 0 to 16
5
1  0  10  0   19
2  9  11  18  20
3  8  12  17  21
4  7  13  16  22
5  6  14  15  23

My code:

//snake move with the number
import java.util.Scanner;

public class SnakeMove {
    public static void main(String[] args) {
        //create Scanner object
        Scanner inScan = new Scanner(System.in);

        //prompt the user to choose number for the Row from 0 to 16
        System.out.println("Choose a number for the rows from 0 to 16.");

        //take the input from user with nextInt() method
        //use the variable int row
        int row = inScan.nextInt();

        //prompt the user to choose number for the Col from 0 to 16
        System.out.println("Choose a number for the columns from 0 to 16");

        //take the input from user with nextInt()
        //use the variable int col
        int col = inScan.nextInt();
        if (row != col) {
            System.out.println("Run the program again and choose the same number for Row and Col");
            System.exit(0);
        }
        int[][] arr = move(row, col);
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[i][j] + "  ");
            }
            System.out.println();
        }
    }//main method

    static int[][] move(int row, int col) {
        boolean flag = true;
        int count = 1;
        int[][] array = new int[row][col];
        for (int j = 0; j < array[0].length; j++) {
            if (flag) {
                for (int i = 0; i < array.length; i++) {
                    //assign the increment value of count
                    // to specific array cells
                    array[i][j] = count;
                    count++;
                }
                flag = false;
            } else {
                //row decrement going up
                for (int i = array.length - 1; i > 0; i--) {
                    //assign the increment value of count
                    // to specific array cells
                    array[i][j] = count;
                    count++;
                }
                flag = true;
            }
        }//column increment
        return array;
    }//move method
}//end SnakeMove class

Can anyone detect what is causing the error? Any help would be appreciated.

score 1 · Answer 1 · answered Jan 24 '21 at 21:40

I believe this is a good alternative and easy to understand. Do comment if you have a simplified version of the same.

Code:

import java.util.Arrays;
import java.util.Scanner;

public class SnakePatternProblem {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);   // *INPUT*
        int row = scanner.nextInt();
        int col = scanner.nextInt();
        int[][] array = new int[row][col];
        
        // Initializing first row of the array with a generalized expression

        for (int i = 0; i < col; i++) {
            if (i % 2 != 0) array[0][i] = col * (i+1); 
            else array[0][i] = (col * i) + 1;
        }
        
        array[0][0] = 1; // this element is not covered in the above loop.
         
        
       // Nested loop for incrementing and decrementing as per the first row of elements.

        for (int i= 1; i< row; i++){
            for (int j=0; j< col; j++){
                if(j%2==0) array[i][j] = array[i-1][j] + 1;
            else array[i][j] = array[i-1][j] - 1;
            }
        }
        System.out.println(Arrays.deepToString(array));    // *OUTPUT  
    }
}

Explanation:

Consider first row of 5 x 5 matrix named "arr" with snake pattern:

1 10 11 20 21

The element in the odd column is equivalent to ((currentColumn + 1) * Total_No_Of_columns);

Example: arr[0][1] = (1 + 1)* 5 = 10

The element in the even column is equivalent to (currentColumn * Total_No_Of_columns) + 1;

Example: arra[0][2] = (2 * 5) + 1 = 11;

Important Note: element at first row, first column is Zero

 arr[0][0] = 1    -> must be declared

Now, the remaining matrix is incrementing or decrementing loop from the first element in that column.

Elements with even column number gets incremented by 1 in each row from the first element of that column.

 1  -> First element of column-0
 2  -> (1 + 1)
 3  -> (2 + 1).... so on
 4 
 5

Elements with odd column number gets decremented by 1 in each row from the first element of that column. 

 10  -> First element of column - 1
 9   -> (10 - 1)
 8   -> (9 - 1).... so on  
 7      
 6

score 0 · Accepted Answer · edited Feb 01 '21 at 12:59

This will generate the "snaking" pattern you described.

It could be simplified with ternary but this makes it more readable I think

It would be interesting to find a more clever way about it though, if anyone finds a better way pls comment

public static int[][] genArray(int length) {
    int[][] arr = new int[length][length];

    int counter = 0;
    for (int col = 0; col < arr.length; col++) {
        if (col % 2 == 0) {
            for (int row = 0; row < arr.length; row++) {
                arr[row][col] = counter++;
            }
        } else {
            for (int row = arr.length - 1; row >= 0; row--) {
                System.out.println("row: " + row + ", col: " + col);
                    arr[row][col] = counter++;
                }
            }
        }
    }
    return arr;
}

score 0 · Answer 3 · answered Jan 12 '21 at 15:17

You can create such an array as follows:

int m = 5;
int n = 4;
int[][] snakeArr = IntStream.range(0, n)
        .mapToObj(i -> IntStream.range(0, m)
                // even row - straight order,
                // odd row - reverse order
                .map(j -> (i % 2 == 0 ? j : m - j - 1) + i * m + 1)
                .toArray())
        .toArray(int[][]::new);

// output
Arrays.stream(snakeArr)
        .map(row -> Arrays.stream(row)
                .mapToObj(e -> String.format("%2d", e))
                .collect(Collectors.joining(" ")))
        .forEach(System.out::println);

 1  2  3  4  5
10  9  8  7  6
11 12 13 14 15
20 19 18 17 16

Transposing snake array:

int[][] transposedSA = new int[m][n];
IntStream.range(0, m).forEach(i ->
        IntStream.range(0, n).forEach(j ->
                transposedSA[i][j] = snakeArr[j][i]));

// output
Arrays.stream(transposedSA)
        .map(row -> Arrays.stream(row)
                .mapToObj(e -> String.format("%2d", e))
                .collect(Collectors.joining(" ")))
        .forEach(System.out::println);

score 0 · Answer 4 · answered Jan 24 '21 at 19:54

An easy way to do it is to create a 2-D array as shown below and then print its transpose.

1   2   3   4   5
10  9   8   7   6
11  12  13  14  15
20  19  18  17  16
21  22  23  24  25

It is a 2-D array of the dimension, LEN x LEN, where LEN = 5.

The above pattern goes like this:

The pattern starts with a start value of 1.
When the main loop counter is an even number, the counter, which assigns a value to the array, starts with start value and increases by one, LEN times. Finally, it sets start for the next row to start with final_value_of_the_array_value_assignment_counter - 1 + LEN.
When the main loop counter is an odd number, the counter, which assigns a value to the array, starts with start value and decreases by one LEN times. Finally, it sets start for the next row to start with start + 1.

The transpose of the above matrix will look like:

1   10  11  20  21  
2   9   12  19  22  
3   8   13  18  23  
4   7   14  17  24  
5   6   15  16  25

In terms of code, we can write it as:

public class Main {
    public static void main(String[] args) {
        final int LEN = 5;
        int[][] arr = new int[LEN][LEN];
        int start = 1, j, k, col;
        for (int i = 0; i < LEN; i++) {
            if (i % 2 == 0) {
                k = 1;
                for (j = start, col = 0; k <= LEN; j++, k++, col++) {
                    arr[i][col] = j;
                }
                start = j - 1 + LEN;
            } else {
                k = 1;
                for (j = start, col = 0; k <= LEN; j--, k++, col++) {
                    arr[i][col] = j;
                }
                start++;
            }

        }

        // Print the transpose of the matrix
        for (int r = 0; r < LEN; r++) {
            for (int c = 0; c < LEN; c++) {
                System.out.print(arr[c][r] + "\t");
            }
            System.out.println();
        }
    }
}

Output:

1   10  11  20  21  
2   9   12  19  22  
3   8   13  18  23  
4   7   14  17  24  
5   6   15  16  25

Change the value of LEN to 10 and you will get the following pattern:

1   20  21  40  41  60  61  80  81  100 
2   19  22  39  42  59  62  79  82  99  
3   18  23  38  43  58  63  78  83  98  
4   17  24  37  44  57  64  77  84  97  
5   16  25  36  45  56  65  76  85  96  
6   15  26  35  46  55  66  75  86  95  
7   14  27  34  47  54  67  74  87  94  
8   13  28  33  48  53  68  73  88  93  
9   12  29  32  49  52  69  72  89  92  
10  11  30  31  50  51  70  71  90  91

Printing a snake pattern using an array

4 Answers4

Code:

Explanation:

Linked