GFG App
Open App
Browser
Continue

# Programs for printing pyramid patterns in Java

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)

This article is contributed by Nikhil Meherwal(S. Shafaq). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.