Нужна помощь в табуляции треугольника Паскаля

#java

Всем привет!
Я только недавно начал учить Java и решил сделать для себя небольшой квест, который
поможет мне освоить особенности этого языка. Я переделываю свои лабораторные с C++.
Случилась у меня одна загвоздка: я не могу красиво построить треугольник Паскаля. Идея
состоит в том, чтобы в цикле при заполнении треугольника писать стринговую переменную
из пробелов и в каждой новой строке выводить ее значение, но на один пробел меньше.
Код прилагаю.
Большое вам спасибо :)

public class Paskal {
    public static final int LINES = 10; 

    public static void main(String[] args) {
        String MySpace = "                     ";
        int[][] p = new int [LINES][];
        p[0] = new int[1];
         System.out.print(MySpace);
         System. out. println (p[0][0] = 1);

        p[1] = new int[2];

        p[1][0] = p[1][1] = 1;
        System.out.print(MySpace + "" );
        System.out.println(p[1][0] + " " + p[1][1]);

        for (int i = 2; i < LINES; i++){
            p[i] = new int[i+1];
            System.out.print(MySpace);
            System.out.print((p[i][0] = 1) + " ");

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

            System.out.println(p[i][i] = 1);
        }
    }
}

    

Ответы

Ответ 1

Можно воспользоваться форматированным выводом (System.out.printf, String.format,
java.util.Formatter и компания), тогда каждое число будет занимать фиксированное количество
символов, и отступ можно будет просто посчитать. Если еще вынести вывод всей строки
в отдельный метод (и заодно отделить вычисления от вывода), то даже не очень страшно
выглядит:

static final int LINES = 10;

// шаблон для форматирования числа: число занимает до пяти символов, недостающие
// дополняются проблелами слева, затем один пробел
// Полный синтаксис:
// https://docs.oracle.com/javase/8/docs/api/java/util/Formatter.html#syntax
// аналогично printf в С
static final String NUMBER_FORMAT = "%5d ";
// Длина одного форматированного числа (5 знаков под число и пробел)
static final int NUMBER_STRING_LENGTH = 6;

// максимальное количество чисел в строке совпадает с количеством строк
//  длина этой строки в символах = число строк * длина одного числа
static final int MAX_LINE_LENGTH = LINES * NUMBER_STRING_LENGTH;

// запас пробелов
static final String SPACES = "                                                  
            ";
static void printArray( int[] array ) {
    // мы знаем количество чисел в строке (array.length),
    //   длину каждого числа в символах и длину самой длинной строки
    //   чтобы отцентрировать нашу строку, нужно отступить на половину
    //   разницы между нашей строкой и самой длинной
    //   SPACES.substring создает строку с нужным количеством пробелов
    System.out.print( SPACES.substring( 0, (MAX_LINE_LENGTH - NUMBER_STRING_LENGTH
* array.length)/2 ) );

    for ( int i = 0; i < array.length; i++ ) 
        System.out.printf( NUMBER_FORMAT, array[i] );

    System.out.println(); 
}

public static void main(String[] args) {
    int[][] p = new int[LINES][];
    p[0] = new int[] {1};
    printArray( p[0] );

    for (int i = 1; i < LINES; i++) {
        p[i] = new int[i + 1];

        p[i][0] = 1;

        for (int j = 1; j < i; j++)
            p[i][j] = p[i - 1][j - 1] + p[i - 1][j];

        p[i][i] = 1;

        printArray( p[i] );
    }
}


Вывод:

                           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


Ответ 2

Немного поковырялся и получилось так:

public static final int LINES = 10;
public static String MySpace  = "                      ";

public static void main(String[] args) {
    int[][] p = new int [LINES] [];
    p[0] = new int[1];

    printspace();

    System.out.println( p[0][0] = 1 );

    p[1] = new int[2];
    p[1][0] = p[1][1] = 1;

    printspace();

    System.out.println(p[1][0] + " " + p[1][1]);
    for (int i = 2; i < LINES; i++){
        p[i] = new int[i+1];
        printspace();
        System.out.print((p[i][0] = 1) + " ");
        for (int j = 1; j < i; j++) {
            System.out.print( (p[i][j] = p[i - 1][j - 1] + p[i - 1][j]) + " " );
        }
        System.out. println (p [ i] [i]  =  1);
    }
}

private static void printspace() {
    System.out.print(MySpace);
    MySpace = MySpace.substring( 0, MySpace.length() - 1 );
}


Общий смысл, что после каждого выводы строка MySpace уменьшать её на один символ.
Вывод у программы такой(не очень красиво, но почти то, что вам надо):

                  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


Ответ 3

Вам стоит уменьшать строку с проблемаи каждый раз на 1 символ:

MySpace = MySpace.substring(0, MySpace.length()-1);


В результате получите такой код:

    public static void main(String[] args) {
        String MySpace  = "                     ";
        int[][] p = new int [LINES] [];
        p[0] = new int[1];
        System.out.print(MySpace);
        MySpace = MySpace.substring(0, MySpace.length()-1);
        System. out. println (p[0][0] = 1);

        p[1] = new int[2];

        p[1][0] = p[1][1] = 1;
        System.out.print(MySpace + "" );
        MySpace = MySpace.substring(0, MySpace.length()-1);
        System.out.println(p[1][0] + " " + p[1][1]);

        for (int i = 2; i < LINES; i++){
            p[i] = new int[i+1];
            System.out.print(MySpace);
            MySpace = MySpace.substring(0, MySpace.length()-1);
            System.out.print((p[i][0] = 1) + " ");
            for (int j = 1; j < i; j++)
                System.out. print ( (p[i] [j] =p[i-1][j-1] + p[i-1][j]) + " ");
            System.out. println (p [ i] [i]  =  1);

        }
    }


Вывод будет примерно такой (из-за наличия двухзначных и трехзначных чисел правая
сторона поедет):

                 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