Open in App
Not now

# Program to print hollow pyramid, diamond pattern and their modifications

• Difficulty Level : Easy
• Last Updated : 27 Mar, 2023

For Prerequisite : Loops, If Else Statement
1. Hollow pyramid/triangle pattern
The pattern is similar to pyramid pattern. The only difference is, we will replace all internal ‘#’ or ‘*’ characters by space character and we will print 2*N-1 (N = number of rows in pattern) ‘#’ or ‘*’ characters in last row.
Examples:

```Input: n=6
Output:
#
# #
#   #
#     #
#       #
#         #
###########    ```

## C++14

 `// CPP program to print a hollow pyramid pattern` `#include ` `using` `namespace` `std;` `void` `printPattern(``int``);` `int` `main()` `{` `    ``int` `n = 6;`   `    ``printPattern(n);` `}` `void` `printPattern(``int` `n)` `{` `    ``int` `i, j, k = 0;` `    ``for` `(i = 1; i <= n; i++) ``// row=6` `    ``{` `        ``// Print spaces` `        ``for` `(j = i; j < n; j++) {` `            ``cout << ``" "``;` `        ``}` `        ``// Print #` `        ``while` `(k != (2 * i - 1)) {` `            ``if` `(k == 0 || k == 2 * i - 2)` `                ``cout << ``"#"``;` `            ``else` `                ``cout << ``" "``;` `            ``k++;` `        ``}` `        ``k = 0;` `        ``cout << endl; ``// print next row` `    ``}` `    ``// print last row` `    ``for` `(i = 0; i < 2 * n - 1; i++) {` `        ``cout << ``"#"``;` `    ``}` `}` `// this article is contributed by Shivani Ghughtyal`

## Java

 `// JAVA program to print a hollow ` `// pyramid pattern` `class` `GFG{` `    `  `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `n = ``6``;` `    `  `        ``printPattern(n);` `    ``}` `    `  `    ``static` `void` `printPattern(``int` `n)` `    ``{` `        ``int` `i, j, k = ``0``;` `        ``for` `(i = ``1``; i <= n; i++) ``// row=6` `        ``{` `            ``// Print spaces` `            ``for` `(j = i; j < n; j++) {` `                ``System.out.print(``" "``);` `            ``}` `            ``// Print #` `            ``while` `(k != (``2` `* i - ``1``)) {` `                ``if` `(k == ``0` `|| k == ``2` `* i - ``2``)` `                    ``System.out.print(``"#"``);` `                ``else` `                    ``System.out.print(``" "``);` `                ``k++;` `                ``;` `            ``}` `            ``k = ``0``;` `            `  `            ``// print next row` `            ``System.out.println(); ` `        ``}` `        ``// print last row` `        ``for` `(i = ``0``; i < ``2` `* n - ``1``; i++) {` `            ``System.out.print(``"#"``);` `        ``}` `    ``}` `}`   `/*This code is contributed by Nikita Tiwari.*/`

## Python

 `# Python program to print a hollow ` `# pyramid pattern`   `def` `printPattern( n) :` `    ``k ``=` `0` `    ``for` `i ``in` `range``(``1``,n``+``1``) : ``#row 6` `    `  `        ``# Print spaces` `        ``for` `j ``in` `range``(i,n) :` `            ``print``(``' '``, end``=``'')` `        `  `        ``# Print #` `        ``while` `(k !``=` `(``2` `*` `i ``-` `1``)) :` `            ``if` `(k ``=``=` `0` `or` `k ``=``=` `2` `*` `i ``-` `2``) :` `                ``print``(``'#'``, end``=``'')` `            ``else` `:` `                ``print``(``' '``, end ``=``'')` `            ``k ``=` `k ``+` `1` `        ``k ``=` `0``;` `        ``print` `("") ``# print next row` `        `  `    ``# print last row` `    ``for` `i ``in` `range``(``0``, ``2` `*` `n ``-``1``) :` `        ``print` `(``'#'``, end ``=` `'')`   `# Driver code ` `n ``=` `6` `printPattern(n)`   `# This code is contributed by Nikita Tiwari.`

## C#

 `using` `System;` `public` `class` `GFG{`   `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 6;` `        ``printPattern(n);` `    ``}` `    `  `    ``static` `void` `printPattern(``int` `n)` `    ``{` `        ``int` `i, j, k = 0;` `        ``for` `(i = 1; i <= n; i++) ``// row=6` `        ``{` `            ``// Print spaces` `            ``for` `(j = i; j < n; j++) {` `                ``Console.Write(``" "``);` `            ``}` `            ``// Print #` `            ``while` `(k != (2 * i - 1)) {` `                ``if` `(k == 0 || k == 2 * i - 2)` `                    ``Console.Write(``"#"``);` `                ``else` `                    ``Console.Write(``" "``);` `                ``k++;` `                ``;` `            ``}` `            ``k = 0;` `            `  `            ``// print next row` `            ``Console.WriteLine(); ` `        ``}` `        ``// print last row` `        ``for` `(i = 0; i < 2 * n - 1; i++) {` `            ``Console.Write(``"#"``);` `        ``}` `    ``}` `}`   `// This code is contributed by laxmigangarajula03`

## PHP

 ``

## Javascript

 ``

Output

```     #
# #
#   #
#     #
#       #
#         #
###########```

Time complexity: O(N^2),This algorithm has a time complexity of O(N^2), where N is the number of rows. This is because we are looping through the rows and columns of the pattern, which takes O(N^2) time to complete.

Space complexity: O(1),This algorithm does not require any additional space, so its space complexity is O(1).

2. Hollow Diamond

Note: For even input, print the pattern for n-1.

Example:

Input: 1

Output:

For n=1

Input: 7

Output:

For n=7

Input: 9

Output:

For n=9

Approach: To print diamond we need to print spaces before star and after the star to achieve constant increasing distance of stars.

To print the box shape we need to print ‘-‘ for i==1 (first row) & i==n (last row) and ‘|’ for j==1 (first column) and j==n (last column).

Algorithm: 1. If n is odd increment n.

2. Find mid=n/2.

3. Traverse from 1 to mid to print upper half of the pattern (say i).

4. Traverse from 1 to mid-i to print spaces for upper left most outer box (say j).

5. If (i==1) print ‘*’ (since for first row we need only one star).

6. else print ‘*’ and traverse from 1 to 2*i-3 to print spaces for hollow diamond (say j) and print ‘*’ after loop is over.

7. Traverse from 1 to mid-i to print spaces again for upper right most outer box (say j).

8. Close the loop at step 3.

9. Traverse from mid+1 to n-1 to print lower half of the pattern (say i).

4. Traverse from 1 to i-mid to print spaces for lower left most outer box (say j).

5. If (i==n-1) print ‘*’ (since for last row we need only one star).

6. else print ‘*’ and traverse from 1 to 2*(n-i)-3 to print spaces for hollow diamond (say j) and print ‘*’ after loop is over.

7. Traverse from 1 to i-mid to print spaces again for lower right most outer box (say j).

8. Close the loop at step 9.

## C++14

 `#include ` `using` `namespace` `std;`   `// function to print the pattern` `void` `printPattern(``int``& n)` `{` `    ``int` `i,j,mid;` `    ``if``(n%2==1) ``//when n is odd, increase it by 1 to make it even` `      ``n++;` `    ``mid = n/2;` `    `  `    ``// upper half pattern` `    ``for``(i = 1; i<= mid; i++) {` `      ``for``(j = 1; j<=mid-i; j++) ``//print the blank spaces and outer box before star` `         ``cout<<``" "``;` `         `  `      ``if``(i == 1) {` `         ``cout << ``"*"``;` `      ``}``else``{` `         ``cout << ``"*"``; ``//in each line star at start and end position` `         ``for``(j = 1; j<=2*i-3; j++) { ``//print space to make hollow` `            ``cout << ``" "``;` `         ``}` `         ``cout << ``"*"``;` `      ``}` `      ``for``(j = 1; j<=mid-i; j++) ``//print the blank spaces and outer box after star` `         ``cout<<``" "``;` `         `  `      ``cout << endl;` `   ``}` `   `  `   ``// lower half pattern` `   ``for``(i = mid+1; i

## Java

 `// JAVA program` `class` `GFG{` `    `  `// function to print the pattern` `static` `void` `printPattern(``int` `n)` `{` `    ``int` `i,j,mid;` `    ``if``(n%``2``==``1``) ``//when n is odd, increase it by 1 to make it even` `      ``n++;` `    ``mid = n/``2``;` `     `  `    ``// upper half pattern` `    ``for``(i = ``1``; i<= mid; i++) {` `      ``for``(j = ``1``; j<=mid-i; j++) ``//print the blank spaces and outer box before star` `         ``System.out.print(``" "``);` `          `  `      ``if``(i == ``1``) {` `         ``System.out.print(``"*"``);` `      ``}``else``{` `         ``System.out.print(``"*"``); ``//in each line star at start and end position` `         ``for``(j = ``1``; j<=``2``*i-``3``; j++) { ``//print space to make hollow` `            ``System.out.print(``" "``);` `         ``}` `         ``System.out.print(``"*"``);` `      ``}` `      ``for``(j = ``1``; j<=mid-i; j++) ``//print the blank spaces and outer box after star` `         ``System.out.print(``" "``);` `          `  `      ``System.out.println();` `   ``}` `    `  `   ``// lower half pattern` `   ``for``(i = mid+``1``; i

## C#

 `// C# program` `using` `System;` `public` `class` `GFG{`   `  ``// function to print the pattern` `  ``public` `static` `void` `printPattern(``int` `n)` `  ``{` `    ``int` `i, j, mid;` `    ``if``(n % 2 == 1) ``//when n is odd, increase it by 1 to make it even` `      ``n++;` `    ``mid = n/2;`   `    ``// upper half pattern` `    ``for``(i = 1; i <= mid; i++) {` `      ``for``(j = 1; j <= mid - i; j++) ``//print the blank spaces and outer box before star` `        ``Console.Write(``" "``);`   `      ``if``(i == 1) {` `        ``Console.Write(``"*"``);` `      ``}``else``{` `        ``Console.Write(``"*"``); ``//in each line star at start and end position` `        ``for``(j = 1; j <= 2 * i - 3; j++) { ``//print space to make hollow` `          ``Console.Write(``" "``);` `        ``}` `        ``Console.Write(``"*"``);` `      ``}` `      ``for``(j = 1; j <= mid - i; j++) ``//print the blank spaces and outer box after star` `        ``Console.Write(``" "``);`   `      ``Console.WriteLine();` `    ``}`   `    ``// lower half pattern` `    ``for``(i = mid + 1; i < n; i++) {`   `      ``for``(j = 1; j <= i - mid; j++) ``//print the blank spaces and outer box before star` `        ``Console.Write(``" "``);`   `      ``if``(i == n - 1) {` `        ``Console.Write(``"*"``);` `      ``}``else``{` `        ``Console.Write(``"*"``); ``//in each line star at start and end position` `        ``for``(j = 1; j <= 2*(n - i)-3; j++) { ``//print space to make hollow` `          ``Console.Write(``" "``);` `        ``}` `        ``Console.Write(``"*"``);` `      ``}` `      ``for``(j = 1; j<=i-mid; j++) ``//print the blank spaces and outer box after star` `        ``Console.Write(``" "``);`   `      ``Console.WriteLine();` `    ``}`   `  ``}`   `  ``// driver's code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int` `n = 7;` `    ``printPattern(n);` `  ``}` `}`   `// This code is contributed by Aman Kumar.`

## Javascript

 `// function to print the pattern` `function` `printPattern( n)` `{` `    ``let i,j,mid;` `    ``if``(n % 2 == 1) ``//when n is odd, increase it by 1 to make it even` `      ``n++;` `    ``mid = n/2;` `    `  `    ``// upper half pattern` `    ``for``(i = 1; i <= mid; i++) {` `      ``for``(j = 1; j <= mid - i; j++) ``//print the blank spaces and outer box before star` `        ``console.log(``"  "``);` `         `  `      ``if``(i == 1) {` `        ``console.log(``"*"``);` `      ``}``else``{` `        ``console.log(``"*"``); ``//in each line star at start and end position` `         ``for``(j = 1; j<=2*i-3; j++) { ``//print space to make hollow` `            ``console.log(``"  "``);` `         ``}` `        ``console.log(``"*"``);` `      ``}` `      ``for``(j = 1; j<=mid-i; j++) ``//print the blank spaces and outer box after star` `        ``console.log(``"  "``);` `         `  `    ``console.log(``"
"``);  ` `    ``}` `   `  `   ``// lower half pattern` `   ``for``(i = mid+1; i"``); ` ` ``}` `}`   `// driver's code` `let n=7;` `printPattern(n);`

## Python3

 `# Python program`   `class` `GFG:` `    `  `    ``# function to print the pattern` `    ``@staticmethod` `    ``def` `printPattern(n):` `        ``i, j, mid ``=` `0``, ``0``, ``0` `        `  `        ``if` `n ``%` `2` `=``=` `1``: ``#when n is odd, increase it by 1 to make it even` `          ``n ``+``=` `1` `          `  `        ``mid ``=` `n ``/``/` `2` `        `  `        ``# upper half pattern` `        ``for` `i ``in` `range``(``1``, mid``+``1``):` `            ``for` `j ``in` `range``(``1``, mid``-``i``+``1``): ``#print the blank spaces and outer box before star` `                ``print``(``" "``, end``=``"")` `                `  `            ``if` `i ``=``=` `1``:` `                ``print``(``"*"``, end``=``"")` `            ``else``:` `                ``print``(``"*"``, end``=``"") ``#in each line star at start and end position` `                ``for` `j ``in` `range``(``1``, ``2``*``i``-``3``+``1``): ``#print space to make hollow` `                    ``print``(``" "``, end``=``"")` `                ``print``(``"*"``, end``=``"")` `            `  `            ``for` `j ``in` `range``(``1``, mid``-``i``+``1``): ``#print the blank spaces and outer box after star` `                ``print``(``" "``, end``=``"")` `            `  `            ``print``()` `        `  `        ``# lower half pattern` `        ``for` `i ``in` `range``(mid``+``1``, n):` `            ``for` `j ``in` `range``(``1``, i``-``mid``+``1``): ``#print the blank spaces and outer box before star` `                ``print``(``" "``, end``=``"")` `            `  `            ``if` `i ``=``=` `n``-``1``:` `                ``print``(``"*"``, end``=``"")` `            ``else``:` `                ``print``(``"*"``, end``=``"") ``#in each line star at start and end position` `                ``for` `j ``in` `range``(``1``, ``2``*``(n``-``i)``-``3``+``1``): ``#print space to make hollow` `                    ``print``(``" "``, end``=``"")` `                ``print``(``"*"``, end``=``"")` `            `  `            ``for` `j ``in` `range``(``1``, i``-``mid``+``1``): ``#print the blank spaces and outer box after star` `                ``print``(``" "``, end``=``"")` `            `  `            ``print``()` `    `  `# driver's code` `if` `__name__ ``=``=` `'__main__'``:` `    ``n ``=` `7` `    ``GFG.printPattern(n)`   `# This code is contributed by sharmashivam215.`

Output

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

Time Complexity: O(n^2) for given input n

Auxiliary Space: O(1)

3. Hollow Diamond bounded inside a rectangular box made of horizontal and vertical dashes(-).

Write a program to Print hollow diamond pattern bound inside a box made of dash(-) and bitwise-OR(|) as shown below.

Note: For even input, print the pattern for n-1.

Example:

Input: 1

Output:

For n=1

Input: 7

Output:

For n=7

Input: 9

Output:

For n=9

Approach: To print diamond we need to print spaces before star and after the star to achieve constant increasing distance of stars.

To print the box shape we need to print ‘-‘ for i==1 (first row) & i==n (last row) and ‘|’ for j==1 (first column) and j==n (last column).

Algorithm: 1. If n is odd increment n.

2. Find mid=n/2.

3. Traverse from 1 to mid to print upper half of the pattern (say i).

4. Traverse from 1 to mid-i to print upper left most outer box (say j).

5. If (i==1) print ‘*’ (since for first row we need only one star).

6. else print ‘*’ and traverse from 1 to 2*i-3 to print spaces for hollow diamond (say j) and print ‘*’ after loop is over.

7. Traverse from 1 to mid-i to print upper right most outer box (say j).

8. Close the loop at step 3.

9. Traverse from mid+1 to n-1 to print lower half of the pattern (say i).

4. Traverse from 1 to i-mid to print lower left most outer box (say j).

5. If (i==n-1) print ‘*’ (since for last row we need only one star).

6. else print ‘*’ and traverse from 1 to 2*(n-i)-3 to print spaces for hollow diamond (say j) and print ‘*’ after loop is over.

7. Traverse from 1 to i-mid to print lower right most outer box (say j).

8. Close the loop at step 9.

## C++14

 `#include ` `using` `namespace` `std;`   `// function to print the pattern` `void` `printPattern(``int``& n)` `{` `    ``int` `i,j,mid;` `    ``if``(n%2==1) ``//when n is odd, increase it by 1 to make it even` `      ``n++;` `    ``mid = n/2;` `    `  `    ``// upper half pattern` `    ``for``(i = 1; i<= mid; i++) {` `      ``for``(j = 1; j<=mid-i; j++) { ``//print the blank spaces and outer box before star` `         ``if``(i==1)` `         ``cout<<``"-"``;` `         ``else` `if``(j==1)` `         ``cout << ``"|"``;` `         ``else` `cout<<``" "``;` `      ``}` `      ``if``(i == 1) {` `         ``cout << ``"*"``;` `      ``}``else``{` `         ``cout << ``"*"``; ``//in each line star at start and end position` `         ``for``(j = 1; j<=2*i-3; j++) { ``//print space to make hollow` `            ``cout << ``" "``;` `         ``}` `         ``cout << ``"*"``;` `      ``}` `      ``for``(j = 1; j<=mid-i; j++) { ``//print the blank spaces and outer box after star` `         ``if``(i==1)` `         ``cout<<``"-"``;` `         ``else` `if``(j==mid-i)` `         ``cout << ``"|"``;` `         ``else` `cout<<``" "``;` `      ``}` `      ``cout << endl;` `   ``}` `   `  `   ``// lower half pattern` `   ``for``(i = mid+1; i

## Java

 `// Java code to implement the above approach`   `import` `java.io.*;` `import` `java.util.*; ` ` `  `class` `GFG` `{` `  ``// function to print the pattern` `  ``public` `static` `void` `printPattern(``int` `n)` `  ``{` `      ``int` `i,j,mid;` `      ``if``(n%``2``==``1``) ``//when n is odd, increase it by 1 to make it even` `      ``n++;` `      ``mid = n/``2``;` `      `  `      ``// upper half pattern` `      ``for``(i = ``1``; i<= mid; i++) {` `          ``for``(j = ``1``; j<=mid-i; j++) { ``//print the blank spaces and outer box before star` `          ``if``(i==``1``)` `          ``System.out.print(``"-"``);` `          ``else` `if``(j==``1``)` `          ``System.out.print(``"|"``);` `          ``else` `          ``System.out.print(``" "``);` `          ``}` `          `  `      ``if``(i == ``1``) {` `         ``System.out.print(``"*"``);` `      ``}` `      ``else``{` `         ``System.out.print(``"*"``); ``//in each line star at start and end position` `         ``for``(j = ``1``; j<=``2``*i-``3``; j++) { ``//print space to make hollow` `            ``System.out.print(``" "``);` `         ``}` `         ``System.out.print(``"*"``);` `      ``}` `      ``for``(j = ``1``; j<=mid-i; j++) { ``//print the blank spaces and outer box after star` `         ``if``(i==``1``)` `         ``System.out.print(``"-"``);` `         ``else` `if``(j==mid-i)` `         ``System.out.print(``"|"``);` `         ``else` `System.out.print(``" "``);` `      ``}` `      ``System.out.print(``"\n"``);` `   ``}` `   `  `   ``// lower half pattern` `   ``for``(i = mid+``1``; i

## Python3

 `# function to print the pattern` `def` `printPattern(n):` `    ``if` `n ``%` `2` `=``=` `1``: ``# when n is odd, increase it by 1 to make it even` `        ``n ``+``=` `1` `    ``mid ``=` `n ``/``/` `2` `    `  `    ``# upper half pattern` `    ``for` `i ``in` `range``(``1``, mid``+``1``):` `        ``for` `j ``in` `range``(``1``, mid``-``i``+``1``): ``# print the blank spaces and outer box before star` `            ``if` `i ``=``=` `1``:` `                ``print``(``"-"``, end``=``"")` `            ``elif` `j ``=``=` `1``:` `                ``print``(``"|"``, end``=``"")` `            ``else``:` `                ``print``(``" "``, end``=``"")` `        ``if` `i ``=``=` `1``:` `            ``print``(``"*"``, end``=``"")` `        ``else``:` `            ``print``(``"*"``, end``=``"") ``# in each line star at start and end position` `            ``for` `j ``in` `range``(``1``, ``2``*``i``-``2``): ``# print space to make hollow` `                ``print``(``" "``, end``=``"")` `            ``print``(``"*"``, end``=``"")` `        ``for` `j ``in` `range``(``1``, mid``-``i``+``1``): ``# print the blank spaces and outer box after star` `            ``if` `i ``=``=` `1``:` `                ``print``(``"-"``, end``=``"")` `            ``elif` `j ``=``=` `mid``-``i:` `                ``print``(``"|"``, end``=``"")` `            ``else``:` `                ``print``(``" "``, end``=``"")` `        ``print``()` `    `  `    ``# lower half pattern` `    ``for` `i ``in` `range``(mid``+``1``, n):` `        ``for` `j ``in` `range``(``1``, i``-``mid``+``1``): ``# print the blank spaces and outer box before star` `            ``if` `i ``=``=` `n``-``1``:` `                ``print``(``"-"``, end``=``"")` `            ``elif` `j ``=``=` `1``:` `                ``print``(``"|"``, end``=``"")` `            ``else``:` `                ``print``(``" "``, end``=``"")` `        ``if` `i ``=``=` `n``-``1``:` `            ``print``(``"*"``, end``=``"")` `        ``else``:` `            ``print``(``"*"``, end``=``"") ``# in each line star at start and end position` `            ``for` `j ``in` `range``(``1``, ``2``*``(n``-``i)``-``2``): ``# print space to make hollow` `                ``print``(``" "``, end``=``"")` `            ``print``(``"*"``, end``=``"")` `        ``for` `j ``in` `range``(``1``, i``-``mid``+``1``): ``# print the blank spaces and outer box after star` `            ``if` `i ``=``=` `n``-``1``:` `                ``print``(``"-"``, end``=``"")` `            ``elif` `j ``=``=` `i``-``mid:` `                ``print``(``"|"``, end``=``"")` `            ``else``:` `                ``print``(``" "``, end``=``"")` `        ``print``()`   `# driver's code` `n ``=` `12` `printPattern(n)` `# This code is contributed by prasad264`

## C#

 `using` `System;`   `namespace` `Pattern` `{` `  ``class` `Program` `  ``{` `    ``static` `void` `PrintPattern(``ref` `int` `n)` `    ``{` `      ``int` `i, j, mid;` `      ``if` `(n % 2 == 1) ``//when n is odd, increase it by 1 to make it even` `        ``n++;` `      ``mid = n / 2;`   `      ``// upper half pattern` `      ``for` `(i = 1; i <= mid; i++)` `      ``{` `        ``for` `(j = 1; j <= mid - i; j++)` `        ``{ ``//print the blank spaces and outer box before star` `          ``if` `(i == 1)` `            ``Console.Write(``"-"``);` `          ``else` `if` `(j == 1)` `            ``Console.Write(``"|"``);` `          ``else` `Console.Write(``" "``);` `        ``}` `        ``if` `(i == 1)` `        ``{` `          ``Console.Write(``"*"``);` `        ``}` `        ``else` `        ``{` `          ``Console.Write(``"*"``); ``//in each line star at start and end position` `          ``for` `(j = 1; j <= 2 * i - 3; j++)` `          ``{ ``//print space to make hollow` `            ``Console.Write(``" "``);` `          ``}` `          ``Console.Write(``"*"``);` `        ``}` `        ``for` `(j = 1; j <= mid - i; j++)` `        ``{ ``//print the blank spaces and outer box after star` `          ``if` `(i == 1)` `            ``Console.Write(``"-"``);` `          ``else` `if` `(j == mid - i)` `            ``Console.Write(``"|"``);` `          ``else` `Console.Write(``" "``);` `        ``}` `        ``Console.WriteLine();` `      ``}`   `      ``// lower half pattern` `      ``for` `(i = mid + 1; i < n; i++)` `      ``{`   `        ``for` `(j = 1; j <= i - mid; j++)` `        ``{ ``//print the blank spaces and outer box before star` `          ``if` `(i == n - 1)` `            ``Console.Write(``"-"``);` `          ``else` `if` `(j == 1)` `            ``Console.Write(``"|"``);` `          ``else` `Console.Write(``" "``);` `        ``}` `        ``if` `(i == n - 1)` `        ``{` `          ``Console.Write(``"*"``);` `        ``}` `        ``else` `        ``{` `          ``Console.Write(``"*"``); ``//in each line star at start and end position` `          ``for` `(j = 1; j <= 2 * (n - i) - 3; j++)` `          ``{ ``//print space to make hollow` `            ``Console.Write(``" "``);` `          ``}` `          ``Console.Write(``"*"``);` `        ``}` `        ``for` `(j = 1; j <= i - mid; j++)` `        ``{ ``//print the blank spaces and outer box after star` `          ``if` `(i == n - 1)` `            ``Console.Write(``"-"``);` `          ``else` `if` `(j == i - mid)` `            ``Console.Write(``"|"``);` `          ``else` `Console.Write(``" "``);` `        ``}` `        ``Console.WriteLine();` `      ``}` `    ``}`   `    ``static` `void` `Main(``string``[] args)` `    ``{` `      ``int` `n = 12;` `      ``PrintPattern(``ref` `n);` `    ``}` `  ``}` `}`   `// This code is contributed by factworx412`

## Javascript

 `// JavaScript code to implement the above approach`   `// function to print the pattern` `function` `printPattern(n) {` `    ``let i, j, mid;` `    ``if` `(n % 2 === 1) { ``// when n is odd, increase it by 1 to make it even` `        ``n++;` `    ``}` `    ``mid = n / 2;`   `    ``// upper half pattern` `    ``for` `(i = 1; i <= mid; i++) {` `        ``let line = ``""``;` `        ``for` `(j = 1; j <= mid - i; j++) { ``// print the blank spaces and outer box before star` `            ``if` `(i === 1) {` `                ``line += ``"-"``;` `            ``} ` `            ``else` `if` `(j === 1) {` `                ``line += ``"|"``;` `            ``} ` `            ``else` `{` `                ``line += ``" "``;` `            ``}` `        ``}`   `        ``if` `(i === 1) {` `            ``line += ``"*"``;` `        ``} ` `        ``else` `{` `            ``line += ``"*"``; ``// in each line star at start and end position` `            ``for` `(j = 1; j <= 2 * i - 3; j++) { ``// print space to make hollow` `                ``line += ``" "``;` `            ``}` `            ``line += ``"*"``;` `        ``}`   `        ``for` `(j = 1; j <= mid - i; j++) { ``// print the blank spaces and outer box after star` `            ``if` `(i === 1) {` `                ``line += ``"-"``;` `            ``} ` `            ``else` `if` `(j === mid - i) {` `                ``line += ``"|"``;` `            ``} ` `            ``else` `{` `                ``line += ``" "``;` `            ``}` `        ``}` `        ``console.log(line);` `    ``}`   `    ``// lower half pattern` `    ``for` `(i = mid + 1; i < n; i++) {` `        ``let line = ``""``;` `        ``for` `(j = 1; j <= i - mid; j++) { ``// print the blank spaces and outer box before star` `            ``if` `(i === n - 1) {` `                ``line += ``"-"``;` `            ``} ` `            ``else` `if` `(j === 1) {` `                ``line += ``"|"``;` `            ``} ` `            ``else` `{` `                ``line += ``" "``;` `            ``}` `        ``}`   `        ``if` `(i === n - 1) {` `            ``line += ``"*"``;` `        ``} ` `        ``else` `{` `            ``line += ``"*"``; ``// in each line star at start and end position` `            ``for` `(j = 1; j <= 2 * (n - i) - 3; j++) { ``// print space to make hollow` `                ``line += ``" "``;` `            ``}` `            ``line += ``"*"``;` `        ``}`   `        ``for` `(j = 1; j <= i - mid; j++) { ``// print the blank spaces and outer box after star` `            ``if` `(i === n - 1) {` `                ``line += ``"-"``;` `            ``} ` `            ``else` `if` `(j === i - mid) {` `                ``line += ``"|"``;` `            ``} ` `            ``else` `{` `                ``line += ``" "``;` `            ``}` `        ``}` `        ``console.log(line);` `    ``} ` `}`   `// Driver Code` `let n = 12;` `printPattern(n);`

Output

```-----*-----
|   * *   |
|  *   *  |
| *     * |
|*       *|
*         *
|*       *|
| *     * |
|  *   *  |
|   * *   |
-----*-----```

Time Complexity: O(n*n)

Auxiliary Space: O(1)

This article is contributed by Shivani Ghughtyal and improved by Himanshu Patel(@prophet1999). 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.