# Programs for printing pyramid patterns in Java

Last Updated : 03 May, 2023

Simple pyramid pattern

## Java

 `import` `java.io.*;`   `// Java code to demonstrate star patterns` `public` `class` `GeeksForGeeks` `{` `    ``// Function to demonstrate printing pattern` `    ``public` `static` `void` `printStars(``int` `n)` `    ``{` `        ``int` `i, j;`   `        ``// outer loop to handle number of rows` `        ``//  n in this case` `        ``for``(i=``0``; i

Output

```*
* *
* * *
* * * *
* * * * * ```

Time Complexity: O(n^2)
Space Complexity: O(1)

## Java

 `// java program to print simple pyramid pattern using while` `// loop`   `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `r = ``1``, c = ``0``, n = ``5``;` `        ``// the while loop check the conditions until the` `        ``// condition is false. if it is true then enter in` `        ``// to loop and execute the statements` `        ``while` `(r <= n) {` `            ``while` `(c <= r - ``1``) {` `                ``// printing the required pattern` `                ``System.out.print(``"* "``);` `                ``c++;` `            ``}` `            ``r++;` `            ``c = ``0``;` `            ``// new line after each row` `            ``System.out.println();` `        ``}` `    ``}` `}`   `// this code is contributed by gangarajula laxmi`

Output

```*
* *
* * *
* * * *
* * * * * ```

Time Complexity: O(N^2),The outer while loop iterates N times, while the inner while loop iterates N-1 times. Hence, the total time complexity of the program will be O(N2).
Space Complexity: O(1),No extra space is required.

## Java

 `// Java code to demonstrate star pattern` `// using Recursion` `import` `java.io.*;`   `class` `GFG {`   `    ``// function to print a row` `    ``static` `void` `printRow(``int` `num)` `    ``{` `        ``// base case` `        ``if` `(num == ``0``)` `            ``return``;` `        ``System.out.print(``"* "``);`   `        ``// recursively calling printRow()` `        ``printRow(num - ``1``);` `    ``}`   `    ``// function to print the pattern` `    ``static` `void` `pattern(``int` `n, ``int` `i)` `    ``{` `        ``// base case` `        ``if` `(n == ``0``)` `            ``return``;` `        ``printRow(i);` `        ``System.out.println();`   `        ``// recursively calling pattern()` `        ``pattern(n - ``1``, i + ``1``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `n = ``5``;` `        ``pattern(n, ``1``);` `    ``}` `}` `// this code is contributed by Shivesh Kumar Dwivedi`

Output

```*
* *
* * *
* * * *
* * * * * ```

Time Complexity: O(N^2)

Auxiliary Space: O(N^2)

After 180 degree rotation

## Java

 `import` `java.io.*;`   `// Java code to demonstrate star pattern` `public` `class` `GeeksForGeeks` `{` `    ``// Function to demonstrate printing pattern` `    ``public` `static` `void` `printStars(``int` `n)` `    ``{` `        ``int` `i, j;`   `        ``// outer loop to handle number of rows` `        ``//  n in this case` `        ``for``(i=``0``; i=``0``; j--)` `            ``{` `                ``// printing spaces` `                ``System.out.print(``" "``);` `            ``}` `           `  `            ``//  inner loop to handle number of columns` `            ``//  values changing acc. to outer loop` `            ``for``(j=``0``; j<=i; j++)` `            ``{` `                ``// printing stars` `                ``System.out.print(``"* "``);` `            ``}` `            `  `            ``// ending line after each row` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Driver Function` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `n = ``5``;` `        ``printStars(n);` `    ``}` `}`

Output

```           *
* *
* * *
* * * *
* * * * * ```

The time complexity of the program is O(n^2) because there are two nested loops, each running n times.

The space complexity is O(1).

## Java

 `// Java code to demonstrate star pattern` `//using Recursion` `import` `java.util.*;` ` `  `public` `class` `GeeksForGeeks` `{` ` `  `    ``// function to print spaces` `    ``static` `void` `printSpace(``int` `space)` `    ``{` `        ``// base case` `        ``if` `(space == ``0``)` `        ``{` `            ``return``;` `        ``}` `        ``System.out.print(``" "` `+ ``" "``);` ` `  `        ``// recursively calling printSpace()` `        ``printSpace(space - ``1``);` `    ``}` ` `  `    ``// function to print stars` `    ``static` `void` `printStars(``int` `star)` `    ``{` `        ``// base case` `        ``if` `(star == ``0``)` `        ``{` `            ``return``;` `        ``}` `        ``System.out.print(``"* "``);` ` `  `        ``// recursively calling printStars()` `        ``printStars(star - ``1``);` `    ``}` ` `  `    ``// function to print the pattern` `    ``static` `void` `pattern(``int` `n, ``int` `num)` `    ``{` `        ``// base case` `        ``if` `(n == ``0``)` `        ``{` `            ``return``;` `        ``}` `        ``printSpace(n - ``1``);` `        ``printStars(num - n + ``1``);` `        ``System.out.println();` ` `  `        ``// recursively calling pattern()` `        ``pattern(n - ``1``, num);` `    ``}` ` `  `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `n = ``5``;` `        ``pattern(n, n);` `    ``}` `}` `//this code is contributed by Shivesh Kumar Dwivedi`

Output

```        *
* *
* * *
* * * *
* * * * * ```

Printing Triangle

## Java

 `import` `java.io.*;`   `// Java code to demonstrate star pattern` `public` `class` `GeeksForGeeks` `{` `    ``// Function to demonstrate printing pattern` `    ``public` `static` `void` `printTriangle(``int` `n)` `    ``{` `        ``// outer loop to handle number of rows` `        ``//  n in this case` `        ``for` `(``int` `i=``0``; i``1``; j--)` `            ``{` `                ``// printing spaces` `                ``System.out.print(``" "``);` `            ``}` ` `  `            ``//  inner loop to handle number of columns` `            ``//  values changing acc. to outer loop` `            ``for` `(``int` `j=``0``; j<=i; j++ )` `            ``{` `                ``// printing stars` `                ``System.out.print(``"* "``);` `            ``}` ` `  `            ``// ending line after each row` `            ``System.out.println();` `        ``}` `    ``}` `    `  `    ``// Driver Function` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `n = ``5``;` `        ``printTriangle(n);` `    ``}` `}`

Output

```    *
* *
* * *
* * * *
* * * * * ```

## Java

 `// Java code to demonstrate star pattern` `// using recursion` `import` `java.util.*;`   `public` `class` `GeeksForGeeks {`   `    ``// function to print spaces` `    ``static` `void` `printSpace(``int` `space)` `    ``{` `        ``// base case` `        ``if` `(space == ``0``)` `            ``return``;` `        ``System.out.print(``" "``);`   `        ``// recursively calling printSpace()` `        ``printSpace(space - ``1``);` `    ``}`   `    ``// function to print asterisks` `    ``static` `void` `printStar(``int` `asterisk)` `    ``{` `        ``// base case` `        ``if` `(asterisk == ``0``)` `            ``return``;` `        ``System.out.print(``"* "``);`   `        ``// recursively calling printStar()` `        ``printStar(asterisk - ``1``);` `    ``}`   `    ``// function to print the pattern` `    ``static` `void` `pattern(``int` `n, ``int` `num)` `    ``{` `        ``// base case` `        ``if` `(n == ``0``)` `            ``return``;` `        ``printSpace(n - ``1``);` `        ``printStar(num - n + ``1``);` `        ``System.out.println(``""``);`   `        ``// recursively calling pattern()` `        ``pattern(n - ``1``, num);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``5``;` `        ``pattern(n, n);` `    ``}` `}` `// this code is contributed by Shivesh Kumar Dwivedi`

Output

```    *
* *
* * *
* * * *
* * * * * ```

Print Reverse Of Pyramid

## Java

 `//MainFunction` `public` `class` `ReversePyramid` `{` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `rows = ``6``; ``// Number of Rows we want to print` `         `  `        `  `         `  `        ``//Printing the pattern` `        ``for` `(``int` `i = ``1``; i <= rows; i++) ` `        ``{` `          ``for` `(``int` `j = ``1``; j < i; j++) ` `            ``{` `                ``System.out.print(``" "``);` `            ``} ` `          ``for` `(``int` `j = i; j <= rows; j++) ` `            ``{ ` `                ``System.out.print(j+``" "``); ` `            ``}   ` `            ``System.out.println(); ` `        ``} ` `       `    `       `  `        ``}` `    `  `    ``}`

Output

```1 2 3 4 5 6
2 3 4 5 6
3 4 5 6
4 5 6
5 6
6 ```

Pattern of Number with Mirror Image

## Java

 `//MainFunction` `public` `class` `ReversePattern` `{` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `rows = ``7``; ``// Number of Rows we want to print` `         `  `        `  `         `  `        ``//Printing the pattern` `        ``for` `(``int` `i = ``1``; i <= rows; i++) ` `        ``{` `          ``for` `(``int` `j = ``1``; j < i; j++) ` `            ``{` `                ``System.out.print(``" "``);` `            ``} ` `          ``for` `(``int` `j = i; j <= rows; j++) ` `            ``{ ` `                ``System.out.print(j+``" "``); ` `            ``}   ` `            ``System.out.println(); ` `        ``} ` `       `    `       ``//Printing the reverse pattern` `        ``for` `(``int` `i = rows-``1``; i >= ``1``; i--) ` `        ``{` `          ``for` `(``int` `j = ``1``; j < i; j++) ` `            ``{` `                ``System.out.print(``" "``);` `            ``}  ` `          ``for` `(``int` `j = i; j <= rows; j++)` `            ``{` `                ``System.out.print(j+``" "``);` `            ``}   ` `            ``System.out.println();` `        ``}` `    `  `    ``}` `}`

Output

```1 2 3 4 5 6 7
2 3 4 5 6 7
3 4 5 6 7
4 5 6 7
5 6 7
6 7
7
6 7
5 6 7
4 5 6 7
3 4 5 6 7
2 3 4 5 6 7
1 2 3 4 5 6 7 ```

Number Pattern

## Java

 `import` `java.io.*;`   `// Java code to demonstrate number pattern` `public` `class` `GeeksForGeeks` `{` `    ``// Function to demonstrate printing pattern` `    ``public` `static` `void` `printNums(``int` `n)` `    ``{` `        ``int` `i, j,num;`   `        ``// outer loop to handle number of rows` `        ``//  n in this case` `        ``for``(i=``0``; i

Output

```1
1 2
1 2 3
1 2 3 4
1 2 3 4 5 ```

## Java

 `// java program to print number pattern using while` `// loop`   `import` `java.io.*;`   `class` `GFG {` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `r = ``1``, c = ``1``, n = ``5``;` `        ``// the while loop check the conditions until the` `        ``// condition is false. if it is true then enter in` `        ``// to loop and execute the statements` `        ``while` `(r <= n) {` `            ``while` `(c <= r ) {` `                ``// printing the required pattern` `                ``System.out.print(c+``" "``);` `                ``c++;` `            ``}` `            ``r++;` `            ``c = ``1``;` `            ``// new line after each row` `            ``System.out.println();` `        ``}` `    ``}` `}`

Output

```1
1 2
1 2 3
1 2 3 4
1 2 3 4 5 ```

Numbers without re assigning

## Java

 `import` `java.io.*;`   `// Java code to demonstrate star pattern` `public` `class` `GeeksForGeeks` `{` `    ``// Function to demonstrate printing pattern` `    ``public` `static` `void` `printNums(``int` `n)` `    ``{` `        ``// initialising starting number` `        ``int` `i, j, num=``1``;` `        `  `        ``// outer loop to handle number of rows` `        ``// n in this case` `        ``for``(i=``0``; i

Output

```1
2 3
4 5 6
7 8 9 10
11 12 13 14 15 ```

Printing Christmas Tree Using Pyramid

## Java

 `class`  `PrintChristmasTree{`   `    ``//Value 5 is permanently provided to height variable` `  ``public` `static` `final` `int` `height = ``5``;` `  `  `   ``//Main Function` `  ``public` `static` `void` `main(String[] args) {` `    `  `    ``//Assigning Width ` `    ``int` `width = ``5``;`   `    ``//Assigning Space` `    ``int` `space = width*``5``;`   `    ``int` `x = ``1``;`   `    ``//Code to Print Upper Part of the Tree i.e. Pyramids.` `    ``for``(``int` `a = ``1``;a <= height ;a++){`   `      ``for``(``int` `i = x;i <= width;i++){`   `        ``for``(``int` `j = space;j >= i;j--){`   `          ``System.out.print(``" "``);` `        ``}`   `        ``for``(``int` `k = ``1``;k <= i;k++){`   `          ``System.out.print(``"* "``);` `        ``}`   `        ``System.out.println();` `      ``}`   `      ``x = x+``2``;` `      ``width = width+``2``;` `    ``}`     `    ``//Printing  Branch of Christmas Tree` `    ``for``(``int` `i = ``1``;i <= ``4``;i++){`   `      ``for``(``int` `j = space-``3``;j >= ``1``;j--){` `        `  `        ``System.out.print(``" "``);` `      ``}`   `      ``for``(``int` `k= ``1``;k <= ``4``;k++){` `        ``System.out.print(``"* "``);` `      ``}`   `      ``System.out.println();` `    ``}` `  ``}` `}`

Output

```                         *
* *
* * *
* * * *
* * * * *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * * * * *
* * * * * * * * * * *
* * * * * * * * *
* * * * * * * * * *
* * * * * * * * * * *
* * * * * * * * * * * *
* * * * * * * * * * * * *
* * * *
* * * *
* * * *
* * * * ```

Time complexity: O(h*w*w) for given height h and width w

Auxiliary Space: O(1)