我正在尝试用 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 部分。

最佳答案

因为这个任务看起来很复杂，实际上很容易。一开始可能看起来很难。因为你考虑的是最终结果，而不是通往结果的路径。

要改变我们可以使用旧的编码规则，divide and conquer .这种方法教会我们，找到复杂问题的相似之处，可以将主要问题简化为我们能够执行的简单任务。换句话说，我们将大问题分成几个小问题，这些问题可以非常容易地解决，最后我们将小结果组合成一个大问题。

所以不要从你的问题开始。

Q1:如何打印数字金字塔？

因为我们不知道，让我们关注其他事情。

为了改进我们的观察，我们可以添加一些背景细节

  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

现在是观察时间。

根据该观察，我们可以得出以下想法。

想法:金字塔是两个三角形的构造。

结论:写那个金字塔的一半比较容易。因此，让我们改写棘手的问题。

Q2:如何写一个三角形的序号？

这真的很简单，我们只需要两个循环，第一个循环负责列，另一个循环负责行。

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

当您完成第一个任务时，您将能够在屏幕上打印正方形、三角形、数字行。

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

   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 

当您成功时，我们会停下来思考一下。

为什么我们必须对每一行重复所有这些操作？如果我们可以将值放在某个地方，我们就不必再思考和计算它们，而只专注于将整个结果写入屏幕。

这个问题的解决方案是数组和称为 dynamic programing 的方法概念.在这种方法中，我们尝试记住某处将用于 future 操作的东西。

所以作为蠕虫，我们只需将数字分配给数组而不是打印它们。

[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [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("");
    }
}

关于java - Java中的数字金字塔，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12265849/