数字金字塔在Java的

Question

我试图在java中打印金字塔看起来像这样: -

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

我正在寻找在互联网上解决这个问题的方法,我偶然发现了这个:

class Pyramid {

  public static void main(String[] args) {

    int x = 7;

    for (int i = 1; i <= x; i++) {

        for (int j = 1; j <= x - i; j++)
            System.out.print("   ");

        for (int k = i; k >= 1; k--)
            System.out.print((k >= 10) ?+ k : "  " + k);

        for (int k = 2; k <=i; k++)
            System.out.print((k >= 10) ?+ k : "  " + k);
        System.out.println();
    }  
  }
}

有人可以帮我理解这个吗？这里'我已经想到了: - 外部循环递增到7,同时内部j循环递增到x-i,对于外部循环的第一次迭代是6,然后是5 ......依此类推.所以基本上金字塔的左侧只是一个倒三角形的空白区域.

我无法弄清楚其他两个嵌套循环中发生了什么,以及在print语句中看起来奇怪的if - else部分

Answer 1

由于任务看起来很复杂,实际上很容易.开头可能会很难看.因为您考虑最终结果而不是关于指导结果的路线.

要改变它,我们可以使用旧的编码规则,分而治之.这个apprach告诉我们,找到复杂问题中的类似物,可以将主要问题减少到我们能够执行的简单任务.换句话说,我们在很少的问题上将我们的大问题重新组合起来,这可以很容易地解决,最后我们将小结果与大结果相结合.

所以从你的问题开始吧.

Q1:如何打印数字的字符串？

我们不知道,让我们专注于其他事情.

为了改进我们的观察,我们可以添加一些bacground细节

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

现在是观察的时候了.

根据这一观察,我们可以提出以下想法.

Idead:金字塔是两个triagnles的结构.

结论:写一半金字塔更容易.所以让我们重新解决酸性问题.

Q2:如何编写看起来像三角形的序列号？

这很简单,我们只需要两个循环,第一个循环将负责另一个行的列.

for(int column = 1; column <= 9; column++) {
 for(int row = 1; row <= 9; row++) {
  if(column ## row) { // Observe what will happen if we use == or <= or > or <>
      System.out.print(row);
  } else {
    System.out.print(" ");
  }
 }
 System.out.println(' ');

}

完成第一项任务后,您将能够在屏幕上打印出squ,三角形,数字线.

所以当我们知道如何打印这样的三角形时:

    r

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

我们应该修改更合适的代码,通常在计算机世界中的操作从零开始而不是从一开始.

    r

 c    0 1 2 3 4 5 6 7 8  
    0 _ _ _ _ _ _ _ _ 9 
    1 _ _ _ _ _ _ _ 8 9 
    2 _ _ _ _ _ _ 7 8 9 
    3 _ _ _ _ _ 6 7 8 9 
    4 _ _ _ _ 5 6 7 8 9 
    5 _ _ _ 4 5 6 7 8 9 
    6 _ _ 3 4 5 6 7 8 9 
    7 _ 2 3 4 5 6 7 8 9 
    8 1 2 3 4 5 6 7 8 9 

当你成功的时候我们会停下来思考.

为什么我们必须为每一行重复所有这些操作？如果我们可以放置一些我们不必考虑的值并计算它们,只关注将整个结果写入屏幕.

这个问题的解决方案是数组和称为动态编程的apporach概念.在这种方法中,我们试图记住将用于未来操作的一些软件.

因此,蠕虫只需将数字分配给数组而不是打印它们.

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

在那里你应该想出这样的代码

    int[] array = new int[9];

    for(int column = array.length; column > 0 ; column--) {
        for(int row = 0; row <= array.length; row++) {
            if(column == row) {
                array[row-1] = column;
            }
        }
        System.out.println(Arrays.toString(array));
    }

从代码中可以清楚地看出,我们为每个步骤使用只设置一个值.这将在下面介绍

   9  [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [9] -Step one we put nine
   8  [ ] [ ] [ ] [ ] [ ] [ ] [ ] [8] [ ] -Step two we put eight
   7  [ ] [ ] [ ] [ ] [ ] [ ] [7] [ ] [ ]
   6  [ ] [ ] [ ] [ ] [ ] [6] [ ] [ ] [ ]
   5  [ ] [ ] [ ] [ ] [5] [ ] [ ] [ ] [ ]
   4  [ ] [ ] [ ] [4] [ ] [ ] [ ] [ ] [ ]
   3  [ ] [ ] [3] [ ] [ ] [ ] [ ] [ ] [ ]
   2  [ ] [2] [ ] [ ] [ ] [ ] [ ] [ ] [ ]
   1  [1] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]

经过九个步骤后,我们将用数字填充整个数组.

我们仍然缺少的是屏幕上的结果.为此,我们应该在每一步中打印整个数组.首先,我们应该从左到右打印,然后在结束之后打开.

执行魔术的代码应该是这样的

public static void pyramide(int levels) {

    int[] tab = new int[levels];

    for(int row = tab.length; row > 0; row--) {

        tab[row-1] = row;

        //Print left
        for(int i=0; i < tab.length; i++) {
            if(tab[i] != 0) {
                System.out.print(tab[i]);
            } else {
                System.out.print(' ');
            }
        }
        //Print right
        for(int i= tab.length-2; i >= row - 1; i--) {
            if(tab[i] != 0) {
                System.out.print(tab[i]);
            }
        }

        System.out.println("");

    }

}

Answer 2

让我们一步一步来看看.正如您已经想到的那样,x是表示金字塔高度的变量.

然后,正如您也正确发现的那样,第一个循环创建了当前数字行的缩进

第二个循环现在将写入数字的左半部分,但是如果我把它弄好了,它将以最高数字和减量开始,然后第三个循环将再次增加数字,创建一个略微不同的金字塔而不是你的数字正在寻找.

现在,奇怪的if-else部分,因为你正在调用它们是三元条件运算符,并且它们在此代码中实现的唯一目的是通过省略金字塔包含数字> = 10来修复数字间距领先的数字空白.:)