黑马程序员技术交流社区

标题: 复习时遇到的一个很有趣的问题 [打印本页]

作者: 孔肖    时间: 2012-9-23 15:42
标题: 复习时遇到的一个很有趣的问题
构造一个矩阵,例如,
当输入阶数为1时,输出1        当输入阶数为2时,输出 1  1     ...    当输入为5时,输出1  1  1  1  1
                                                                                      1  1                                          1  2  2  2  1
                                                                                                                                      1  2  3  2  1
                                                                                                                                      1  2  2  2  1
                                                                                                                                      1  1  1  1  1
有兴趣的朋友可以做做


作者: AngieFans85    时间: 2012-9-23 15:51
1  1  1  1  1
1  2  2  2  1
1  2  3  2  1
1  2  2  2  1
1  1  1  1  1

是不是最终要达到这样的效果?
作者: 孔肖    时间: 2012-9-23 16:05
马镱洵 发表于 2012-9-23 15:51
1  1  1  1  1
1  2  2  2  1
1  2  3  2  1

根据输入的阶数来确定啊,如果输入的是6,里面还可以包含一层
作者: AngieFans85    时间: 2012-9-23 21:13
  1. public class RectangleTest {

  2.         public static void main(String[] args) {
  3.                 printRectangle(6, 6);
  4.         }

  5.         /**
  6.          * 输出一个矩形
  7.          *
  8.          * @param row
  9.          *            行数
  10.          * @param col
  11.          *            列数
  12.          */
  13.         public static void printRectangle(int row, int col) {
  14.                 int midRow = 0;// 中间行
  15.                 int midCol = 0;// 中间列
  16.                 int temp = row % 2;// 计算出行数为奇数还是偶数
  17.                 int temp2 = col % 2;// 计算出列数为奇数还是偶数
  18.                 for (int i = 1; i <= row; i++) {
  19.                         for (int j = 1; j <= col; j++) {
  20.                                 if (i == 1 || i == row) {// 当前行为1或当前行为最后一行时
  21.                                         System.out.print(1 + " ");
  22.                                 } else if (j == 1 || j == col) {// 当前列为1或当前列为最后一列时
  23.                                         System.out.print(1 + " ");
  24.                                 } else if (j != 1 && j != col) {// 当前列不为1且当前列不为列数时
  25.                                         if (temp == 1) {// 如果行数为奇数
  26.                                                 midRow = row / 2 + 1;// 计算出中间行是哪一行
  27.                                                 if (i == midRow) {// 如果当前行等于中间行
  28.                                                         if (temp2 == 1) {// 如果列数为奇数时
  29.                                                                 midCol = col / 2 + 1;// 计算出中间列是哪一列
  30.                                                                 if (j == midCol) {// 如果当前列等于中间列时
  31.                                                                         System.out.print(j + " ");
  32.                                                                         continue;
  33.                                                                 }
  34.                                                         } else {// 如果列数为偶数时
  35.                                                                 midCol = col / 2;// 计算出中间列是哪一列

  36.                                                                 // 如果当前列等于中间列或当前列等于中间列的后一列,
  37.                                                                 // 为什么要这样做呢,因为当列数为偶数时,
  38.                                                                 // 中间列应该有两列吧.
  39.                                                                 if (j == midCol || j == midCol + 1) {
  40.                                                                         System.out.print(i + " ");
  41.                                                                 }
  42.                                                         }
  43.                                                 }
  44.                                                 System.out.print(2 + " ");
  45.                                         } else if (temp == 0) {// 如果行数为偶数时
  46.                                                 midRow = row / 2;// 计算出中间行是哪一行

  47.                                                 // 如果当前行等于中间行或当前行等于中间行的下一行,
  48.                                                 // 为什么要这样做呢,因为当行数为偶数时,
  49.                                                 // 中间行应该有两行吧.
  50.                                                 if (i == midRow || i == midRow + 1) {
  51.                                                         if (temp2 == 1) {// 当列数为奇数时
  52.                                                                 midCol = col / 2 + 1;// 计算出中间列是哪一列
  53.                                                                 if (j == midCol) {// 如果当前列等于中间列时
  54.                                                                         System.out.print(j + " ");
  55.                                                                 }
  56.                                                         } else {// 当列数为偶数时
  57.                                                                 midCol = col / 2;// 计算出中间列是哪一列

  58.                                                                 // 如果当前列等于中间列或当前列等于中间列的下一列时
  59.                                                                 if (j == midCol || j == midCol + 1) {
  60.                                                                         System.out.print(j + " ");
  61.                                                                         continue;
  62.                                                                 }
  63.                                                         }
  64.                                                 }
  65.                                                 System.out.print(2 + " ");
  66.                                         }
  67.                                 }
  68.                         }
  69.                         // 最后当然少不了要换行
  70.                         System.out.println();
  71.                 }
  72.         }

  73. }
复制代码





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2