帕斯卡的三角形二维数组 - 格式化打印输出

Question

我有一个小任务，我必须使用二维数组来生成帕斯卡三角形。这是我的代码，它可以工作。如果我像这样显示三角形，则会有额外的信用机会：

但是，我的间距不是这样格式化的。它只是显示所有排列在左侧的数字。它很难描述，但如果你运行它，你就会明白我的意思。

这是我的代码：

public class Pascal {
    public static final int ROW = 16;
    public static void main(String[] args) {
        int[][] pascal = new int[ROW + 1][];
        pascal[1] = new int[1 + 2];
        pascal[1][1] = 1;
        for (int i = 2; i <= ROW; i++) {
            pascal[i] = new int[i + 2];
            for (int j = 1; j < pascal[i].length - 1; j++) {
                pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
            }
        }
        for (int i = 1; i <= ROW; i++) {
            for (int j = 1; j < pascal[i].length - 1; j++) {
                System.out.print(pascal[i][j] + " ");
            }
            System.out.println();
        }
    }
}

如果有人可以帮助我弄清楚如何在我的程序中添加正确的间距以产生图片中所需的输出，那就太好了。我知道我需要在某处放置System.out.print(" ")。我只是不知道在哪里。

Answer 1

您遇到了间距问题，因为您需要为某些数字添加空格以适应较大数字占用的空间。首先确定您计划打印的最大数字是多少（以编程方式）。然后确定该数字 log(n) 中的位数。然后，您可以使用此数字为位数少于最大数字的数字打印空格，以使您的打印效果更好。

Answer 2

在这里我修改了你的代码，由于我的控制台窗口的限制，它在 ROW 大小到 13 之前打印得非常好：

import java.util.*;

public class Pascal {
    public static final int ROW = 12;
    private static int max = 0;

    public static void main(String[] args) {
        int[][] pascal = new int[ROW + 1][];
        pascal[1] = new int[1 + 2];
        pascal[1][1] = 1;
        for (int i = 2; i <= ROW; i++) {
            pascal[i] = new int[i + 2];
            for (int j = 1; j < pascal[i].length - 1; j++) {
                pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
                String str = Integer.toString(pascal[i][j]);
                int len = str.length();
                if (len > max)
                    max = len;
            }
        }

        for (int i = 1; i <= ROW; i++) {
            for (int k = ROW; k > i; k--)
                System.out.format("%-" + max + "s", " ");
            for (int j = 1; j < pascal[i].length - 1; j++)
                System.out.format("%-" + (max + max) + "s", pascal[i][j]);
            System.out.println();
        }
    }
}

输出：

                                 1     
                              1     1     
                           1     2     1     
                        1     3     3     1     
                     1     4     6     4     1     
                  1     5     10    10    5     1     
               1     6     15    20    15    6     1     
            1     7     21    35    35    21    7     1     
         1     8     28    56    70    56    28    8     1     
      1     9     36    84    126   126   84    36    9     1     
   1     10    45    120   210   252   210   120   45    10    1     
1     11    55    165   330   462   462   330   165   55    11    1     

Answer 3

您可以在二维数组的左上角构建一个 帕斯卡三角形，如下所示：

 1  1  1  1  1  1  1  1  1  1
 1  2  3  4  5  6  7  8  9
 1  3  6 10 15 21 28 36
 1  4 10 20 35 56 84
 1  5 15 35 70 126
 1  6 21 56 126
 1  7 28 84
 1  8 36
 1  9
 1

两个嵌套的流：在行上，然后在列上。第一行第一列的元素都等于一，其他所有元素都是该行第一列的前一个元素之和。

int n = 10;
// an array of 'n' rows
int[][] arr = new int[n][];
// iterate over the rows of the array
IntStream.range(0, n)
        // a row of 'n-i' elements
        .peek(i -> arr[i] = new int[n - i])
        // iterate over the elements of the row
        .forEach(i -> IntStream.range(0, n - i).forEach(j -> {
            if (i == 0 || j == 0)
                // elements of the first row
                // and column are equal to one
                arr[i][j] = 1;
            else
                // all other elements are the sum of the
                // previous element in the row and column
                arr[i][j] = arr[i][j - 1] + arr[i - 1][j];
        }));

// formatted output
Arrays.stream(arr)
        .map(row -> Arrays.stream(row)
                // format as a two-digit number
                .mapToObj(i -> String.format("%2d", i))
                .collect(Collectors.joining(" ")))
        .forEach(System.out::println);

"%2d" - 格式为两位数，当n=10时，

"%4d" - 格式为 四位 数字，n=16，等等。

Answer 4

你也可以参考下面的代码。

public class Pascal {
    public static final int ROW = 16;

    static long factorial(int ROW) {
        long f;
        for (f = 1; ROW > 1; ROW--) {
            f *= ROW;
        }
        return f;
    }

    static long patt(int ROW, int r) {
        return factorial(ROW) / (factorial(ROW - r) * factorial(r));
    }

    public static void main(String args[]) {
        System.out.println();
        int i, j;
        for (i = 0; i <= ROW; i++) {
            for (j = 0; j <= ROW - i; j++) {
                System.out.print(" ");
            }
            for (j = 0; j <= i; j++) {
                System.out.print(" " + patt(i, j));
            }
            System.out.println();
        }
    }
}

输出：

                  1
                 1 1
                1 2 1
               1 3 3 1
              1 4 6 4 1
             1 5 10 10 5 1
            1 6 15 20 15 6 1
           1 7 21 35 35 21 7 1
          1 8 28 56 70 56 28 8 1
         1 9 36 84 126 126 84 36 9 1
        1 10 45 120 210 252 210 120 45 10 1
       1 11 55 165 330 462 462 330 165 55 11 1
      1 12 66 220 495 792 924 792 495 220 66 12 1
     1 13 78 286 715 1287 1716 1716 1287 715 286 78 13 1
    1 14 91 364 1001 2002 3003 3432 3003 2002 1001 364 91 14 1
   1 15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105 15 1
  1 16 120 560 1820 4368 8008 11440 12870 11440 8008 4368 1820 560 120 16 1

Answer 5

对于这个previous answer，你可以使用两个嵌套的增强的for循环在左上角输出一个格式化的三角形。

    1    1    1    1    1    1    1    1    1    1    1    1    1    1
    1    2    3    4    5    6    7    8    9   10   11   12   13
    1    3    6   10   15   21   28   36   45   55   66   78
    1    4   10   20   35   56   84  120  165  220  286
    1    5   15   35   70  126  210  330  495  715
    1    6   21   56  126  252  462  792 1287
    1    7   28   84  210  462  924 1716
    1    8   36  120  330  792 1716
    1    9   45  165  495 1287
    1   10   55  220  715
    1   11   66  286
    1   12   78
    1   13
    1

Try it online!

int n = 14;
// an array of 'n' rows
int[][] arr = new int[n][];
// iterate over the rows of the array
for (int i = 0; i < n; i++) {
    // a row of 'n-i' elements
    arr[i] = new int[n - i];
    // iterate over the elements of the row
    for (int j = 0; j < n - i; j++) {
        if (i == 0 || j == 0) {
            // elements of the first row
            // and column are equal to one
            arr[i][j] = 1;
        } else {
            // all other elements are the sum of the
            // previous element in the row and column
            arr[i][j] = arr[i][j - 1] + arr[i - 1][j];
        }
    }
}

// formatted output
for (int[] row : arr) {
    for (int i : row)
        // format as a four-digit number with one
        // additional whitespace at the beginning
        System.out.printf(" %4d", i);
    System.out.println();
}