We Keep Coding

Printing a snake pattern using an array

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.

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

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;
}

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);
1 10 11 20
2 9 12 19
3 8 13 18
4 7 14 17
5 6 15 16

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

Power table using while loop formatting and logic error

I am trying to make a table from 1 - 5, which displays there power up to 6 values.
so for example, the 2 column would go from, 1,2,4,8,16,32,64 and would stop there.
I am having trouble getting proper table format. Since the numbers don't align where they should be.
for example:
the problem I am facing right now is this
1 2 3 4 5
1 1 1 1 1 1 1 2 4 8 16 and so and so on
any well would be appreciated, my code is down below.
int powNumb=5;
int powValue=6;
for (int i = 1; i <= powValue; i++) {
System.out.printf("%10d",i);
}
System.out.println();
for (int i = 1; i <= powNumb; i++) {
for (int j = 0; j <=powValue; j++) {
System.out.printf("%10.0f",Math.pow(i, j));
}
}

This should help you
for (int i = 1; i <= powNumb; i++) {
System.out.printf("%10d", i); //Print the number (1st col)
for (int j = 0; j <= powValue; j++) { //This loop prints the powers of the curent number 'i'
System.out.printf("%10.0f", Math.pow(i, j));
}
System.out.println(); //To end the current row
}
This prints
num num^0 num^1 num^2 ... num^powValue
where num is from 1 to powNumb
Output
1 1 1 1 1 1 1 1
2 1 2 4 8 16 32 64
3 1 3 9 27 81 243 729
4 1 4 16 64 256 1024 4096
5 1 5 25 125 625 3125 15625

You mean the same base for every element, so there is no need for inner loop:
for (int i = 1; i <= powNumb; i++) {
System.out.printf("%10.0f", Math.pow(powValue, i));
}
This way the base of power is always powValue.

First, you need a println statement somewhere in your inner for loop to separate the rows.
Second, you need to switch the i and j in your call to Math.pow. Because with how it's currently set up, each row is value i = row number to powers 0 through 6. For example, the first row would be 1^0 1^1 1^2 1^3 1^4 1^5 1^6. Then, the second row would be 2^0 2^1 2^2 2^3 2^4 2^5 2^6 However, you want the first row to be 1^0 2^0 3^0 4^0 5^0, second row 1^1 2^1 3^1 4^1 5^1, etc. So your code should be changed to something like this,
int powNumb=5;
int powValue=6;
for (int i = 1; i <= powNumb; i++) {
System.out.printf("%10d",i);
}
for (int i = 0; i <= powValue; i++) {
System.out.println();
for (int j = 1; j <=powNumb; j++) {
System.out.printf("%10.0f",Math.pow(j, i));
}
}
Output:
1 2 3 4 5
1 1 1 1 1
1 2 3 4 5
1 4 9 16 25
1 8 27 64 125
1 16 81 256 625
1 32 243 1024 3125
1 64 729 4096 15625
Also, I had to switch powNumb and powValue in the for loop conditions.

Magic Square Program Outputs Incorrect Sum Values for Rows, Columns, Diagonals

I coded a Magic Square program with a driver and a class. The only problem I'm having is adding up the rows, columns, and diagonals. I made a int constant called "col" for column, that counts up 1 each time an entire row is summed. Therefore, the multi-dimensional array would first sum [0,0],[0,1],[0,2] to whatever size the square is, and then col would be incremented, changing to [1,0],[1,1],[1,2] etc. However, after my adding method computes one row, goes to print, and comes back for the next row, col is set back to 0. Is there a way I can prevent it from resetting and keep its incrementation? I think that's the final step. Note: I only put the col on the row and column sum methods so far, I just want to get it to work for those first.
Note: Please make sure you name the text file correctly when transferring the text given here
Thank you all in advance.
// ****************************************************************
// MagicSquare.java
//
// Text below is to be filled by student.
//
// ****************************************************************
import java.util.Scanner;
public class MagicSquare
{
int[][] square;
public MagicSquare(int size)
{
square = new int[size][size];
}
int col = 0;
//--------------------------------------
//return the sum of the values in the given row
//--------------------------------------
private int sumMagicRow(int size,int col)
{
int sum = 0;
for (int i=0;i<(size);i++)
{
sum += square[col][i];
}
col++;
return sum;
}
//--------------------------------------
//return the sum of the values in the given column
//--------------------------------------
private int sumMagicCol(int size, int col)
{
int sum = 0;
for (int i=0;i<size;i++)
{
sum += square[col][i];
}
col++;
return sum;
}
//--------------------------------------
//return the sum of the values in the main diagonal
//--------------------------------------
private int sumMagicDiagMain(int size)
{
int sum = 0;
for (int i=0;i<size;i++)
{
sum += square[i][i];
}
return sum;
}
//--------------------------------------
//return the sum of the values in the other ("reverse") diagonal
//--------------------------------------
private int sumMagicDiagRev(int size)
{
int sum = 0;
for (int i=0;i<size;i++)
{
sum += square[i][(size-1)-i];
}
return sum;
}
//--------------------------------------
//return true if the square is magic (all rows, cols, and diags
// have same sum), false otherwise
//--------------------------------------
public boolean isMagicSquare(int size)
{
boolean answer =false;
if(sumMagicCol(size,col)==sumMagicRow(size,col) && sumMagicRow(size,col)==sumMagicDiagMain(size) && sumMagicDiagMain(size)==sumMagicDiagRev(size))
{
answer=true;
}
return answer;
}
//--------------------------------------
//compute and display sums of square including row, column, main diagonal, and other diagonal
//--------------------------------------
public void printMagicSquareSums(int size)
{
for(int i=0;i<size;i++)
{
System.out.println("Sum of row " + i + " is: " + sumMagicRow(size,col));
}
for(int i=0;i<size;i++)
{
System.out.println("Sum of column " + i + " is: " + sumMagicCol(size,col));
}
for(int i=0;i<size;i++)
{
System.out.println("Sum of row " + i + " is: " + sumMagicDiagMain(size));
}
for(int i=0;i<size;i++)
{
System.out.println("Sum of row " + i + " is: " + sumMagicDiagRev(size));
}
}
//--------------------------------------
//read info into the square from the input stream associated with
//the Scanner parameter
//--------------------------------------
public void readSquare(Scanner scan)
{
for (int row = 0; row < square.length; row++)
for (int col = 0; col < square.length; col++)
square[row][col] = scan.nextInt();
}
//--------------------------------------
//print the contents of the square, neatly formatted
//--------------------------------------
public void printSquare(int size)
{
int column=0;
for(int x=0;x<size;x++)
{
for(int i=0;i<size;i++)
{
System.out.printf("%3d ",square[x][i]);
}
System.out.println("");
}
}
}
Driver program:
// ****************************************************************
// MagicSquareTest.java
//
// Text below is to be filled by student.
//
// ****************************************************************
import java.util.Scanner;
import java.io.IOException;
import java.io.File;
public class MagicSquareTest
{
public static void main(String[] args) throws IOException
{
Scanner scan = new Scanner(new File("magicText.txt"));
// make sure that the file magicData is in the current directory
int count = 1; //count which square we're on
int size = scan.nextInt(); //size of next square
int mem = size;
//Expecting -1 at bottom of input file
while (size != -1)
{
//create a new Square of the given size
MagicSquare s = new MagicSquare(size);
size=mem;
//call its read method to read the values of the square
System.out.println("\n***** Square " + count + " *****");
s.readSquare(scan);
//print the square
s.printSquare(size);
//print the square id
//System.out.println(count);
//print the sums
s.printMagicSquareSums(size);
//determine and print whether it is a magic square
System.out.println(s.isMagicSquare(size));
//get size of next square
size = scan.nextInt();
count++;
}
}
}
Text File (that reads into array)
3
8 1 6
3 5 7
4 9 2
7
30 39 48 1 10 19 28
38 47 7 9 18 27 29
46 6 8 17 26 35 37
5 14 16 25 34 36 45
13 15 24 33 42 44 4
21 23 32 41 43 3 12
22 31 40 49 2 11 20
4
48 9 6 39
27 18 21 36
15 30 33 24
12 45 42 3
3
6 2 7
1 5 3
2 9 4
4
3 16 2 13
6 9 7 12
10 5 11 8
15 4 14 1
5
17 24 15 8 1
23 5 16 14 7
4 6 22 13 20
10 12 3 21 19
11 18 9 2 25
7
30 39 48 1 10 28 19
38 47 7 9 18 29 27
46 6 8 17 26 37 35
5 14 16 25 34 45 36
13 15 24 33 42 4 44
21 23 32 41 43 12 3
22 31 40 49 2 20 11
-1

I find your code very weird and you still have a lot to fix in it in my opinion. But for your specific question:
private int sumMagicRow(int size,int col)
{
int sum = 0;
for (int i=0;i<(size);i++)
{
sum += square[col][i];
}
col++;
return sum;
}
Here you give col to the method and it is different then the field (it's not constant) col in the class. In col++ you increment that sumMagicRow(int size,int col). If you want to increment the class instance value you should use this.col which says use the col which is not defined in that particular scope (method) but on class level.
Unfortunately reading through your code I think it will not solve the problem because sooner or later you will want col to go back to 0 ;) otherwise if you keep adding to it you will leave the bounds of the array. For example if you have square with size 3 and you go read col1, col2, col3 when you go to rows col will be already 3 and you will try to read row 4. It would be better to rethink your algorithm. There are many things to improve.
For example if you have a loop for 1 to N (size of square) isn't one loop enough to check all rows/column/diagonals with some mathematics? I believe it should be ;)

Java Programming for multiplication table of 2 only

Multiplication table for 2 only
This is my code:
public class nest
{
public static void main (String[] args)
{
for (int row=1; row<=5; row++)
{
for (int column=1; column<=10; column++)
{
System.out.print(row*++column +"\t");
}
System.out.println();
}
}
}
This is my target results:
2 4 6 8 10
12 14 16 18 20
22 24 26 28 30
32 34 36 38 40
42 44 46 48 50
But I'm getting this:
2 4 6 8 10
4 8 12 16 20
6 12 18 24 30
8 16 24 32 40
10 20 30 40 50
Help me please I'm still learning Java.

The trick here is in being able to articulate a formula for the value in each cell given a row and column index. Assuming we count both row and column starting from zero, then the formula is:
(2 + 10*row + 2*column)
This formula says that, starting with an initial value of 2, we increase by 10 moving down a row, and we increase by 2 moving to the right of a column. This leads to the following code:
for (int row=0; row < 5; ++row) {
for (int column=0; column < 5; column++) {
System.out.print((2 + 10*row + 2*column) + "\t");
}
System.out.println();
}
Demo

To make it simple you can do something like this:
public class A{
public static void main(String[] args){
int k=2;
for (int row=1; row<=5; row++)
{
for (int column=1; column<=5; column++)
{
System.out.print(k+"\t");
k=k+2;
}
System.out.println();
}
}
}

Similar to the above one. A simple one.
public static void main(String[] args) {
int tableOf = 2;
int currIter = tableOf;
for(int i = 1; i <= 5 ; i++) {
currIter = tableOf * i;
for(int j = 1; j <= 5 ; j++) {
System.out.print((currIter * j) + "\t");
}
System.out.println();
}
}

You can achieve your results by using an extra variable.
public class nest
{
public static void main (String[] args)
{ int table= 0;
for (int row=1; row<=5; row++)
{
for (int column=1; column<=5; column++)
{
table+=2;
System.out.print(table +"\t");
}
System.out.println();
}
}
}
the loops can be used to define rows and columns for printing table . hope it helped you a little.

You could also try (assuming you're using Java 8+), a formula based on breaking lines every five elements using a lambda and a ternary we can do so in a single statement. Generate a range of 1 to 25, multiply each value in the range by 2, and then print it (and if it isn't a multiple of 5 a tab, otherwise a newline). Like,
IntStream.rangeClosed(1, 25).map(i -> i * 2)
.forEachOrdered(i -> System.out.print(i + ((i % 5 != 0) ? "\t" : "\n")));

Your java code is great! It appears that you're just having a little bit of math logic problems.
Lets take a look at the following:
1 2 3 4 5
1
2
3
4
5
These are your rows and columns as you itterate through them in your loops.
2 4 6 8 10
Should be your first line which it is!
12 14 16 18 20
Should be your second line. Well lets take a look at your equation.
row*++column
++column means column + 1 = 2
1 * 2 is 2
we want 12
If we keep the range of the loops within 5 its much simpler.
public class nest
{
public static void main (String[] args)
{
for (int row=1; row<=5; row++)
{
for (int column=1; column<=5; column++)
{
System.out.print(logic math stuff +"\t");
}
System.out.println();
}
}
}
Looking at the expected output the numbers are just 1 - 25 * 2
Lets try to print 1 - 25 first.
Column itterates 1 - 5 so the first row is just column.
System.out.print(column + "\t");
1 2 3 4 5
Easy enough. So now on the second row we need 6 7 8 9 10.
Column is still 1 - 5 but row is now 2
The first number is supposed to be 6 so how do we get there?
row = 2
column = 1
Our column width is 5 so every itteration of row we have to add 5 * (row-1).
System.out.print((column + 5 * (row-1)) + "\t");
This prints 1 - 25 in 5 rows
Now double it!
System.out.print((column + 5 * (row-1)) * 2 + "\t");

Array Printf issue

I'm working on simple program that is supposed to list the numeric values in an array; a certain way. This is how I would like to have the output look like:
Printing Array:
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22
It has to be lined as seen above and line must only contain 10 numbers.
I seem to have everything formatted correctly but my output doesn't look like that.
Here is what I am getting:
Printing Array:
1
2 3 4 5 6 7 8 9 10 11
12 13 14 15 16 17 18 19 20 21
22
I'm not sure exactly what I'm doing wrong but here's my code:
//disregard the name 'Juice', I like to give my programs weird names
public class Juice
{
public static void main(String[] args)
{
//sets up the array
int[] numbers = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22};
//title
System.out.println("Printing Array: ");
//counting the elements
for (int i = 0; i < numbers.length; i++)
{
//prints each element value with 4 spaces in between
System.out.printf("%4d", numbers[i]);
//once line reaches ten values; print new line
if (i % 10 == 0)
{
System.out.printf("\n");
}
}
}
}

if ((i+1) % 10 == 0)
{
System.out.printf("\n");
}

Your code does what you asked it to.
On first loop, i=0, but i % 10 == 0 is also true, so it prints new line.
You can use many different approaches to fix this, but probably easiest one will be to replace this condition to (i+1) % 10 == 0 or to i % 10 == 9.

you almost did it
public class Juice
{
public static void main(String[] args)
{
//sets up the array
int[] numbers = {1,2,3,4,5,6,7,8,9,10,12,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32};
//title
System.out.println("Printing Array: ");
//counting the elements
for (int i = 0; i < numbers.length; i++)
{
//prints each element value with 4 spaces in between
System.out.printf("%4d", numbers[i]);
//once line reaches ten values; print new line
if (i % 10 == 9)
{
System.out.printf("\n");
}
}
}
}
i've modified a conditions to if (i % 10 == 9)
OUTPUT
Printing Array:
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32

Alternatively to avoid the confusion between the index to the array element and the element count switch to using a foreach loop.
//counting the elements
int i = 1;
for (int number : numbers) {
//prints each element value with 4 spaces in between
System.out.printf("%4d", number);
//once line reaches ten values; print new line
if (i % 10 == 0) {
System.out.println();
}
i++;
}