使用Java进行金字塔打印

Question

金字塔示例

笔记：

1. System.our.printf(“%n.mf”, num) 将打印出一个浮点数 num，宽度为 n，小数位数为 m。
2. Java中a^b的计算：Math.pow(a,b)
3. 对于上面的金字塔印刷，您可以将图案分成三部分：左边的空格、左边的数字和右边的数字。 对于每行 i，总共有 2*i-1 个数字。

public static void main(String[] args) {
        int rows = 5, k = 0, count = 0, count1 = 0;

        for(int i = 1; i <= rows; ++i) {
            for(int space = 1; space <= rows - i; ++space) {
                System.out.print("  ");
                ++count;
            }

            while(k != 2 * i - 1) {
                if (count <= rows - 1) {
                    System.out.print((i + k) + " ");
                    ++count;
                }
                else {
                    ++count1;
                    System.out.print((i + k - 2 * count1) + " ");
                }

                ++k;
            }
            count1 = count = k = 0;

            System.out.println();
        }
    }
}

Answer 1

在下面找到答案：

public class Main {

    static int rows = 10;
    public static void main(String[] args) {

        LinkedList<Integer> numbers = new LinkedList<>();
        for(int i = 1 ; i <= rows ; i++){
            if(i ==1 ) numbers.add(1);
            else {
                int totalNumber = i * 2 -1;
                    insertNumbers(totalNumber, numbers);
            }
            printNumbers(numbers, i);
            System.out.println();
            numbers.clear();
        }
    }

    private static void insertNumbers(int totalNumber, LinkedList<Integer> numbers) {
        int numbersOnEachSide = (totalNumber - 1) / 2;
        for (int i = 0; i < numbersOnEachSide ; i++ ) numbers.add((int) Math.pow(2, i));
        numbers.add((int) Math.pow(2,numbersOnEachSide));
        for(int i = 0 ; i < numbersOnEachSide ; i++) numbers.add((int) Math.pow(2, numbersOnEachSide-1-i));
    }

    private static void printNumbers(LinkedList<Integer> numbers, int i) {
        int spaceNorows = rows - i;
        printSpaces(spaceNorows);
        for (Integer number : numbers) {
            System.out.print(number + "\t");
        }
        printSpaces(spaceNorows);
    }

    private static void printSpaces(int spaceNorows) {
        for(int j = 0 ; j< spaceNorows ; j++) System.out.print("\t");
    }

}

输出：

                                    1                                       
                                1   2   1                                   
                            1   2   4   2   1                               
                        1   2   4   8   4   2   1                           
                    1   2   4   8   16  8   4   2   1                       
                1   2   4   8   16  32  16  8   4   2   1                   
            1   2   4   8   16  32  64  32  16  8   4   2   1               
        1   2   4   8   16  32  64  128 64  32  16  8   4   2   1           
    1   2   4   8   16  32  64  128 256 128 64  32  16  8   4   2   1       
1   2   4   8   16  32  64  128 256 512 256 128 64  32  16  8   4   2   1   

ps 请查看https://stackoverflow.com/tour在以后的帖子中提出正确的问题。

编辑：如何在CMD运行代码

要运行上面的应用程序：

1- 将上面的所有代码保存在一个名为 - 例如 - Main.java 的文件中

2-运行CMD在窗户或terminal在Linux和编译Main.java使用javac Main.java 。

3- 编译后的文件将放在与java文件相同的目录中。

4- 使用java Main运行编译后的类。

• 将Main更改为您为文件提供的任何名称

• 由于您在 cmd 中运行代码，它可能无法正确显示 10 行金字塔（由于屏幕分辨率、大小等）。 因此，更改static int rows = 10;的行字段static int rows = 10; 到5以正确查看金字塔。

• 您可以进一步更改固定行号以从用户那里动态获取它。

Answer 2

我决定尝试一下，主要是因为我想展示一些与解决问题有关的概念。

首先，我将金字塔的高度设为变量。 这迫使我考虑不同的金字塔高度将如何影响每条线的每一段的宽度。

接下来，我决定预先计算两个的幂。 重新计算每一行的值是没有意义的。 所以，我写了一个方法来返回一个预先计算好的整数数组。

接下来，我计算了 2 的最大幂会占用多少空间。 我使用NumberFormat类格式化了数字。 NumberFormat类将根据您运行代码的Locale来格式化数字。 我使用String类的format方法给每个数字足够的空间。

接下来，我将每一行划分为一个空白区、一个数字区和一个空白区。 这样，我可以分别处理一行的每个部分。 金字塔线左侧的空白区域与线右侧的空白区域的长度相同，因此我只需为每条线创建一次。

我使用StringBuilder创建金字塔的每一行。 使用StringBuilder比连接String值更快。 我使用StringBuilder段来创建金字塔线的部分。

我没有使用static方法，因为我想展示如何在main方法中实例化类。 一般来说，我尽量避免使用static方法。

这是一次测试运行的结果。 我向你保证，我对这段代码进行了几十次测试。

                                             1                                             
                                        1    2    1                                        
                                   1    2    4    2    1                                   
                              1    2    4    8    4    2    1                              
                         1    2    4    8   16    8    4    2    1                         
                    1    2    4    8   16   32   16    8    4    2    1                    
               1    2    4    8   16   32   64   32   16    8    4    2    1               
          1    2    4    8   16   32   64  128   64   32   16    8    4    2    1          
     1    2    4    8   16   32   64  128  256  128   64   32   16    8    4    2    1     
1    2    4    8   16   32   64  128  256  512  256  128   64   32   16    8    4    2    1

这是代码。

import java.text.NumberFormat;

public class NumberPyramid {
    
    public static void main(String[] args) {
        int power = 10;
        
        NumberPyramid np = new NumberPyramid();
        np.createPyramid(power);
    }
    
    private static final NumberFormat NF = 
            NumberFormat.getNumberInstance();
    
    public void createPyramid(int power) {
        int[] values = createPowersArray(power);
        String maximum = NF.format(values[power - 1]);
        int segmentSize = maximum.length() + 2;
        String format = "%" + segmentSize + "s";
        
        for (int index = 0; index < power; index++) {
            StringBuilder builder = new StringBuilder();
            StringBuilder blankArea = createBlankArea(
                    index, power, segmentSize);
            builder.append(blankArea);
            builder.append(createNumberArea(index, values, format));
            builder.append(blankArea);
            System.out.println(builder.toString());
        }
    }

    private int[] createPowersArray(int power) {
        int[] values = new int[power];
        values[0] = 1;
        
        for (int i =  1; i < power; i++) {
            values[i] = values[i - 1] * 2;
        }
        
        return values;
    }
    
    private StringBuilder createNumberArea(int index, 
            int[] values, String format) {
        StringBuilder builder = new StringBuilder();
        
        for (int j = 0; j <= index; j++) {
            builder.append(String.format(format, 
                    NF.format(values[j])));
        }
        
        for (int j = index - 1; j >= 0; j--) {
            builder.append(String.format(format, 
                    NF.format(values[j])));
        }
        
        return builder;
    }
    
    private StringBuilder createBlankArea(int index, 
            int power, int segmentSize) {
        StringBuilder builder = new StringBuilder();
        
        for (int i = 0; i < power - index - 1; i++) {
            builder.append(createBlankSegment(segmentSize));
        }
        
        return builder;
    }
    
    private StringBuilder createBlankSegment(int length) {
        StringBuilder builder = new StringBuilder(length);
        
        for (int i = 0; i < length; i++) {
            builder.append(" ");
        }
        
        return builder;
    }

}