使用数组打印蛇形图案

huangapple
go评论104阅读模式
英文:

Printing a snake pattern using an array

问题

以下是翻译好的部分：

  1. //蛇形移动带有数字
  2. import java.util.Scanner;
  4. public class SnakeMove {
  5.     public static void main(String[] args) {
  6.         //创建 Scanner 对象
  7.         Scanner inScan = new Scanner(System.in);
  9.         //提示用户从 0 到 16 选择行数
  10.         System.out.println("选择行数，范围从 0 到 16。");
  12.         //使用 nextInt() 方法从用户获取输入
  13.         //使用变量 int row
  14.         int row = inScan.nextInt();
  16.         //提示用户从 0 到 16 选择列数
  17.         System.out.println("选择列数，范围从 0 到 16。");
  19.         //使用 nextInt() 方法从用户获取输入
  20.         //使用变量 int col
  21.         int col = inScan.nextInt();
  22.         if (row != col) {
  23.             System.out.println("再次运行程序，选择相同的行数和列数。");
  24.             System.exit(0);
  25.         }
  26.         int[][] arr = move(row, col);
  27.         for (int i = 0; i < arr.length; i++) {
  28.             for (int j = 0; j < arr.length; j++) {
  29.                 System.out.print(arr[i][j] + "  ");
  30.             }
  31.             System.out.println();
  32.         }
  33.     }//main 方法
  35.     static int[][] move(int row, int col) {
  36.         boolean flag = true;
  37.         int count = 1;
  38.         int[][] array = new int[row][col];
  39.         for (int j = 0; j < array[0].length; j++) {
  40.             if (flag) {
  41.                 for (int i = 0; i < array.length; i++) {
  42.                     //将 count 的增量值赋值给特定的数组单元
  43.                     array[i][j] = count;
  44.                     count++;
  45.                 }
  46.                 flag = false;
  47.             } else {
  48.                 //逐行递减向上移动
  49.                 for (int i = array.length - 1; i > 0; i--) {
  50.                     //将 count 的增量值赋值给特定的数组单元
  51.                     array[i][j] = count;
  52.                     count++;
  53.                 }
  54.                 flag = true;
  55.             }
  56.         }//逐列增加
  57.         return array;
  58.     }//move 方法
  59. }//结束 SnakeMove 类
英文:

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

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

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

My output:

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

My code:

  1. //snake move with the number
  2. import java.util.Scanner;
  4. public class SnakeMove {
  5.     public static void main(String[] args) {
  6.         //create Scanner object
  7.         Scanner inScan = new Scanner(System.in);
  9.         //prompt the user to choose number for the Row from 0 to 16
  10.         System.out.println(&quot;Choose a number for the rows from 0 to 16.&quot;);
  12.         //take the input from user with nextInt() method
  13.         //use the variable int row
  14.         int row = inScan.nextInt();
  16.         //prompt the user to choose number for the Col from 0 to 16
  17.         System.out.println(&quot;Choose a number for the columns from 0 to 16&quot;);
  19.         //take the input from user with nextInt()
  20.         //use the variable int col
  21.         int col = inScan.nextInt();
  22.         if (row != col) {
  23.             System.out.println(&quot;Run the program again and choose the same number for Row and Col&quot;);
  24.             System.exit(0);
  25.         }
  26.         int[][] arr = move(row, col);
  27.         for (int i = 0; i &lt; arr.length; i++) {
  28.             for (int j = 0; j &lt; arr.length; j++) {
  29.                 System.out.print(arr[i][j] + &quot;  &quot;);
  30.             }
  31.             System.out.println();
  32.         }
  33.     }//main method
  35.     static int[][] move(int row, int col) {
  36.         boolean flag = true;
  37.         int count = 1;
  38.         int[][] array = new int[row][col];
  39.         for (int j = 0; j &lt; array[0].length; j++) {
  40.             if (flag) {
  41.                 for (int i = 0; i &lt; array.length; i++) {
  42.                     //assign the increment value of count
  43.                     // to specific array cells
  44.                     array[i][j] = count;
  45.                     count++;
  46.                 }
  47.                 flag = false;
  48.             } else {
  49.                 //row decrement going up
  50.                 for (int i = array.length - 1; i &gt; 0; i--) {
  51.                     //assign the increment value of count
  52.                     // to specific array cells
  53.                     array[i][j] = count;
  54.                     count++;
  55.                 }
  56.                 flag = true;
  57.             }
  58.         }//column increment
  59.         return array;
  60.     }//move method
  61. }//end SnakeMove class

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

答案1

得分: 1

  1. 我认为这是一个不错的替代方案，容易理解。如果你有同样问题的简化版本，请评论分享。
  3. ## 代码：##
  5. import java.util.Arrays;
  6. import java.util.Scanner;
  8. public class SnakePatternProblem {
  9.     public static void main(String[] args) {
  10.         Scanner scanner = new Scanner(System.in);   // *输入*
  11.         int row = scanner.nextInt();
  12.         int col = scanner.nextInt();
  13.         int[][] array = new int[row][col];
  15.         // 用通用表达式初始化数组的第一行
  17.         for (int i = 0; i < col; i++) {
  18.             if (i % 2 != 0) array[0][i] = col * (i+1); 
  19.             else array[0][i] = (col * i) + 1;
  20.         }
  22.         array[0][0] = 1; // 此元素不在上述循环中涵盖。
  24.         // 嵌套循环用于根据第一行元素递增和递减。
  26.         for (int i = 1; i < row; i++) {
  27.             for (int j = 0; j < col; j++) {
  28.                 if (j % 2 == 0) array[i][j] = array[i-1][j] + 1;
  29.                 else array[i][j] = array[i-1][j] - 1;
  30.             }
  31.         }
  32.         System.out.println(Arrays.deepToString(array));    // *输出*
  33.     }
  34. }
  37. ----------
  39. ## 解释：##
  41. 考虑一个名为 "arr" 的 *5 x 5* 矩阵的第一行，呈蛇形排列：
  43.     1 10 11 20 21
  45.     奇数列中的元素等于 ((当前列 + 1) * 总列数)；
  47.     例如：arr[0][1] = (1 + 1) * 5 = 10
  50. ----------
  52.     偶数列中的元素等于 (当前列 * 总列数) + 1；
  54.     例如：arra[0][2] = (2 * 5) + 1 = 11;
  57. **重要说明：** 第一行第一列的元素为零
  59.      arr[0][0] = 1    -> 必须声明
  62. 现在，剩下的矩阵是从该列的第一个元素开始的递增或递减循环。
  64.     偶数列号的元素在每一行从该列的第一个元素开始递增1。
  66.      1  -> 第0列的第一个元素
  67.      2  -> (1 + 1)
  68.      3  -> (2 + 1).... 以此类推
  69.      4 
  70.      5
  73. ----------
  75.     奇数列号的元素在每一行从该列的第一个元素开始递减1。
  77.      10  -> 第1列的第一个元素
  78.      9   -> (10 - 1)
  79.      8   -> (9 - 1).... 以此类推
  80.      7      
  81.      6
英文:

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

Code:

  1. import java.util.Arrays;
  2. import java.util.Scanner;
  3. public class SnakePatternProblem {
  4. public static void main(String[] args) {
  5. Scanner scanner = new Scanner(System.in);   // *INPUT*
  6. int row = scanner.nextInt();
  7. int col = scanner.nextInt();
  8. int[][] array = new int[row][col];
  9. // Initializing first row of the array with a generalized expression
  10. for (int i = 0; i &lt; col; i++) {
  11. if (i % 2 != 0) array[0][i] = col * (i+1); 
  12. else array[0][i] = (col * i) + 1;
  13. }
  14. array[0][0] = 1; // this element is not covered in the above loop.
  15. // Nested loop for incrementing and decrementing as per the first row of elements.
  16. for (int i= 1; i&lt; row; i++){
  17. for (int j=0; j&lt; col; j++){
  18. if(j%2==0) array[i][j] = array[i-1][j] + 1;
  19. else array[i][j] = array[i-1][j] - 1;
  20. }
  21. }
  22. System.out.println(Arrays.deepToString(array));    // *OUTPUT  
  23. }
  24. }

Explanation:

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

  1. 1 10 11 20 21
  2. The element in the odd column is equivalent to ((currentColumn + 1) * Total_No_Of_columns);
  3. Example: arr[0][1] = (1 + 1)* 5 = 10
  1. The element in the even column is equivalent to (currentColumn * Total_No_Of_columns) + 1;
  2. Example: arra[0][2] = (2 * 5) + 1 = 11;

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

  1.  arr[0][0] = 1    -&gt; must be declared

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

  1. Elements with even column number gets incremented by 1 in each row from the first element of that column.
  2. 1  -&gt; First element of column-0
  3. 2  -&gt; (1 + 1)
  4. 3  -&gt; (2 + 1).... so on
  5. 4 
  6. 5
  1. Elements with odd column number gets decremented by 1 in each row from the first element of that column. 
  2. 10  -&gt; First element of column - 1
  3. 9   -&gt; (10 - 1)
  4. 8   -&gt; (9 - 1).... so on  
  5. 7      
  6. 6

答案2

得分: 0

这将生成你所描述的“蛇形”模式。

虽然可以使用三元运算符简化，但我认为这样更易读。

不过，如果有人找到更好的方法，可以在评论中分享一下。

  1. public static int[][] genArray(int length) {
  2.     int[][] arr = new int[length][length];
  4.     int counter = 0;
  5.     for (int col = 0; col < arr.length; col++) {
  6.         if (col % 2 == 0) {
  7.             for (int row = 0; row < arr.length; row++) {
  8.                 arr[row][col] = counter++;
  9.             }
  10.         } else {
  11.             for (int row = arr.length - 1; row >= 0; row--) {
  12.                 System.out.println("row: " + row + ", col: " + col);
  13.                 arr[row][col] = counter++;
  14.             }
  15.         }
  16.     }
  17.     return arr;
  18. }
英文:

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

  1. public static int[][] genArray(int length) {
  2. int[][] arr = new int[length][length];
  3. int counter = 0;
  4. for (int col = 0; col &lt; arr.length; col++) {
  5. if (col % 2 == 0) {
  6. for (int row = 0; row &lt; arr.length; row++) {
  7. arr[row][col] = counter++;
  8. }
  9. } else {
  10. for (int row = arr.length - 1; row &gt;= 0; row--) {
  11. System.out.println(&quot;row: &quot; + row + &quot;, col: &quot; + col);
  12. arr[row][col] = counter++;
  13. }
  14. }
  15. }
  16. }
  17. return arr;
  18. }

答案3

得分: 0

  1. int m = 5;
  2. int n = 4;
  3. int[][] snakeArr = IntStream.range(0, n)
  4.         .mapToObj(i -> IntStream.range(0, m)
  5.                 // even row - straight order,
  6.                 // odd row - reverse order
  7.                 .map(j -> (i % 2 == 0 ? j : m - j - 1) + i * m + 1)
  8.                 .toArray())
  9.         .toArray(int[][]::new);
  11. // output
  12. Arrays.stream(snakeArr)
  13.         .map(row -> Arrays.stream(row)
  14.                 .mapToObj(e -> String.format("%2d", e))
  15.                 .collect(Collectors.joining(" ")))
  16.         .forEach(System.out::println);
  1.  1  2  3  4  5
  2. 10  9  8  7  6
  3. 11 12 13 14 15
  4. 20 19 18 17 16

Transposing snake array:

  1. int[][] transposedSA = new int[m][n];
  2. IntStream.range(0, m).forEach(i ->
  3.         IntStream.range(0, n).forEach(j ->
  4.                 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

  2. <details>
  3. <summary>英文:</summary>
  4. You can create such an array as follows:
  5. ```java
  6. int m = 5;
  7. int n = 4;
  8. int[][] snakeArr = IntStream.range(0, n)
  9. .mapToObj(i -&gt; IntStream.range(0, m)
  10. // even row - straight order,
  11. // odd row - reverse order
  12. .map(j -&gt; (i % 2 == 0 ? j : m - j - 1) + i * m + 1)
  13. .toArray())
  14. .toArray(int[][]::new);
  1. // output
  2. Arrays.stream(snakeArr)
  3.         .map(row -&gt; Arrays.stream(row)
  4.                 .mapToObj(e -&gt; String.format(&quot;%2d&quot;, e))
  5.                 .collect(Collectors.joining(&quot; &quot;)))
  6.         .forEach(System.out::println);
  1.  1  2  3  4  5
  2. 10  9  8  7  6
  3. 11 12 13 14 15
  4. 20 19 18 17 16

Transposing snake array:

  1. int[][] transposedSA = new int[m][n];
  2. IntStream.range(0, m).forEach(i -&gt;
  3.         IntStream.range(0, n).forEach(j -&gt;
  4.                 transposedSA[i][j] = snakeArr[j][i]));
  1. // output
  2. Arrays.stream(transposedSA)
  3.         .map(row -&gt; Arrays.stream(row)
  4.                 .mapToObj(e -&gt; String.format(&quot;%2d&quot;, e))
  5.                 .collect(Collectors.joining(&quot; &quot;)))
  6.         .forEach(System.out::println);
  1.  1 10 11 20
  2. 2  9 12 19
  3. 3  8 13 18
  4. 4  7 14 17
  5. 5  6 15 16

答案4

得分: 0

以下是翻译好的内容：

一种简单的方法是创建一个如下所示的二维数组，然后打印其转置。

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

这是一个维度为 LEN x LEN 的二维数组，其中 LEN = 5。

上述模式如下：

  1. 模式以 start 值为 1 开始。
  2. 当主循环计数器为偶数时，将分配值给数组的计数器从 start 值开始，逐次增加 LEN 次。最后，它将设置下一行的 start 以 final_value_of_the_array_value_assignment_counter - 1 + LEN 开始。
  3. 当主循环计数器为奇数时，将分配值给数组的计数器从 start 值开始，逐次减少 LEN 次。最后，它将设置下一行的 start 以 start + 1 开始。

上述矩阵的转置如下：

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

代码方面，我们可以写成：

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         final int LEN = 5;
  4.         int[][] arr = new int[LEN][LEN];
  5.         int start = 1, j, k, col;
  6.         for (int i = 0; i < LEN; i++) {
  7.             if (i % 2 == 0) {
  8.                 k = 1;
  9.                 for (j = start, col = 0; k <= LEN; j++, k++, col++) {
  10.                     arr[i][col] = j;
  11.                 }
  12.                 start = j - 1 + LEN;
  13.             } else {
  14.                 k = 1;
  15.                 for (j = start, col = 0; k <= LEN; j--, k++, col++) {
  16.                     arr[i][col] = j;
  17.                 }
  18.                 start++;
  19.             }
  20.         }
  22.         // 打印矩阵的转置
  23.         for (int r = 0; r < LEN; r++) {
  24.             for (int c = 0; c < LEN; c++) {
  25.                 System.out.print(arr[c][r] + "\t");
  26.             }
  27.             System.out.println();
  28.         }
  29.     }
  30. }

输出：

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

将 LEN 的值更改为 10，您将得到以下模式：

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

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

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

  1. The pattern starts with a start value of 1.
  2. 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.
  3. 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. 1	10	11	20	21	
  2. 2	9	12	19	22	
  3. 3	8	13	18	23	
  4. 4	7	14	17	24	
  5. 5	6	15	16	25

In terms of code, we can write it as:

  1. public class Main {
  2. public static void main(String[] args) {
  3. final int LEN = 5;
  4. int[][] arr = new int[LEN][LEN];
  5. int start = 1, j, k, col;
  6. for (int i = 0; i &lt; LEN; i++) {
  7. if (i % 2 == 0) {
  8. k = 1;
  9. for (j = start, col = 0; k &lt;= LEN; j++, k++, col++) {
  10. arr[i][col] = j;
  11. }
  12. start = j - 1 + LEN;
  13. } else {
  14. k = 1;
  15. for (j = start, col = 0; k &lt;= LEN; j--, k++, col++) {
  16. arr[i][col] = j;
  17. }
  18. start++;
  19. }
  20. }
  21. // Print the transpose of the matrix
  22. for (int r = 0; r &lt; LEN; r++) {
  23. for (int c = 0; c &lt; LEN; c++) {
  24. System.out.print(arr[c][r] + &quot;\t&quot;);
  25. }
  26. System.out.println();
  27. }
  28. }
  29. }

Output:

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

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

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

huangapple
  • 本文由 发表于 2020年4月11日 09:02:42
  • 转载请务必保留本文链接：https://go.coder-hub.com/61150845.html
  • arrays
  • java
  • multidimensional-array
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定