GFG App
Open App
Browser
Continue

# Program to print solid and hollow rhombus patterns

For any given number n, print Hollow and solid Squares and Rhombus made with stars(*).
Examples:

```Input : n = 4
Output :
Solid Rhombus:
****
****
****
****

Hollow Rhombus:
****
*  *
*  *
****```

1. Solid Rhombus : Making Solid Rhombus is a bit similar to making solid square rather than the concept that for each ith row we have n-i blank spaces before stars as:
– – – ****
– – ****
– ****
****
2. Hollow Rhombus : Formation of Hollow Rhombus uses the idea behind formation of hollow square and solid rhombus. A hollow square with n-i blank spaces before stars in each ith rows result in formation of hollow rhombus.

## C++

 `// C++ program to print ` `// hollow and solid rhombus patterns `   `#include ` `using` `namespace` `std; `     `// Function for Solid Rhombus ` `void` `solidRhombus(``int` `rows) ` `{ ` `    ``int` `i, j; ` `    ``for` `(i=1; i<=rows; i++) ` `    ``{ ` `        ``// Print trailing spaces ` `        ``for` `(j=1; j<=rows - i; j++) ` `            ``cout << ``" "``; ` `            `  `        ``// Print stars after spaces ` `        ``for` `(j=1; j<=rows; j++) ` `            ``cout << ``"*"``; ` `            `  `        ``// Move to the next line/row ` `        ``cout << ``"\n"``; ` `    ``} ` `} `   `// Function for Rhombus ` `void` `hollowRhombus(``int` `rows) ` `{ ` `    ``int` `i, j; ` `    ``for` `(i=1; i<=rows; i++) ` `    ``{ ` `        ``// Print trailing spaces ` `        ``for` `(j=1; j<=rows - i; j++) ` `            ``cout << ``" "``; ` `            `  `        ``// Print stars after spaces ` `        ``// Print stars for each solid rows ` `        ``if` `(i==1 || i==rows) ` `            ``for` `(j=1; j<=rows; j++) ` `                ``cout << ``"*"``; ` `                `  `        ``// stars for hollow rows ` `        ``else` `            ``for` `(j=1; j<=rows; j++) ` `                ``if` `(j==1 || j==rows) ` `                    ``cout << ``"*"``; ` `                ``else` `                    ``cout << ``" "``; ` `        ``// Move to the next line/row ` `        ``cout << ``"\n"``; ` `    ``} ` `} `   `// utility program to print all patterns ` `void` `printPattern(``int` `rows) ` `{ ` `    ``cout << ``"\nSolid Rhombus:\n"``; ` `    ``solidRhombus(rows); ` `    `  `    ``cout << ``"\nHollow Rhombus:\n"``; ` `    ``hollowRhombus(rows); ` `} `   `// driver program ` `int` `main() ` `{ ` `    ``int` `rows = 5; ` `    ``printPattern (rows); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print ` `// hollow and solid rhombus patterns` `import` `java.io.*;`   `class` `GFG ` `{` `    ``// Function for Solid Rhombus` `    ``static` `void` `solidRhombus(``int` `rows)` `    ``{` `        ``int` `i, j;` `        ``for` `(i=``1``; i<=rows; i++)` `        ``{` `            ``// Print trailing spaces` `            ``for` `(j=``1``; j<=rows - i; j++)` `                ``System.out.print(``" "``);` `             `  `            ``// Print stars after spaces` `            ``for` `(j=``1``; j<=rows; j++)` `                ``System.out.print(``"*"``);` `             `  `            ``// Move to the next line/row` `            ``System.out.println();` `        ``}` `    ``}` ` `  `    ``// Function for Hollow Rhombus` `    ``static` `void` `hollowRhombus(``int` `rows)` `    ``{` `        ``int` `i, j;` `        ``for` `(i=``1``; i<=rows; i++)` `        ``{` `            ``// Print trailing spaces` `            ``for` `(j=``1``; j<=rows - i; j++)` `                ``System.out.print(``" "``);` `             `  `            ``// Print stars after spaces` `            ``// Print stars for each solid rows` `            ``if` `(i==``1` `|| i==rows)` `                ``for` `(j=``1``; j<=rows; j++)` `                    ``System.out.print(``"*"``);` `                 `  `            ``// stars for hollow rows` `            ``else` `                ``for` `(j=``1``; j<=rows; j++)` `                    ``if` `(j==``1` `|| j==rows)` `                        ``System.out.print(``"*"``);` `                    ``else` `                        ``System.out.print(``" "``);` `            ``// Move to the next line/row` `            ``System.out.println();` `        ``}` `    ``}` ` `  `    ``// utility program to print all patterns` `    ``static` `void` `printPattern(``int` `rows)` `    ``{` `        ``System.out.println(``"Solid Rhombus:"``);` `        ``solidRhombus(rows);` `     `  `        ``System.out.println(``"Hollow Rhombus:"``);` `        ``hollowRhombus(rows);` `    ``}` `    `  `    ``// driver program` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``int` `rows = ``5``;` `        ``printPattern (rows);` `    ``}` `}`   `// Contributed by Pramod Kumar`

## Python 3

 `# Python 3 program to print ` `# hollow and solid rhombus patterns`   `# Function for Solid Rhombus`   `def` `solidRhombus(rows):` `    `  `    ``for` `i ``in` `range` `(``1``,rows ``+` `1``):` `        `  `        ``# Print trailing spaces` `        `  `        ``for` `j ``in` `range` `(``1``,rows ``-` `i ``+` `1``):` `            ``print` `(end``=``" "``)` `            `  `        ``# Print stars after spaces` `        `  `        ``for` `j ``in` `range` `(``1``,rows ``+` `1``):` `            ``print` `(``"*"``,end``=``"")` `            `  `        ``# Move to the next line/row` `        ``print``()`   `# Function for Hollow Rhombus`   `def` `hollowRhombus(rows):` `    `  `    ``for` `i ``in` `range` `(``1``, rows ``+` `1``):` `        ``# Print trailing spaces` `        `  `        ``for` `j ``in` `range` `(``1``, rows ``-` `i ``+` `1``):` `            ``print` `(end``=``" "``)` `            `  `        ``# Print stars after spaces` `        ``# Print stars for each solid rows` `        `  `        ``if` `i ``=``=` `1` `or` `i ``=``=` `rows:` `            ``for` `j ``in` `range` `(``1``, rows ``+` `1``):` `                ``print` `(``"*"``,end``=``"")` `                `  `        ``# stars for hollow rows` `        ``else``:` `            ``for` `j ``in` `range` `(``1``,rows``+``1``):` `                ``if` `(j ``=``=` `1` `or` `j ``=``=` `rows):` `                    ``print` `(``"*"``,end``=``"")` `                ``else``:` `                    ``print` `(end``=``" "``)` `        ``# Move to the next line/row` `        ``print``()`   `# utility program to print all patterns` `def` `printPattern(rows):` `    `  `    ``print` `(``"Solid Rhombus:"``)` `    ``solidRhombus(rows)` `    `  `    ``print``(``"\nHollow Rhombus:"``)` `    ``hollowRhombus(rows)`   `# driver program`   `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``rows ``=` `5` `    ``printPattern (rows)`

## C#

 `// C# program to print ` `// hollow and solid rhombus patterns` `using` `System;`   `class` `GFG ` `{` `    ``// Function for Solid Rhombus` `    ``static` `void` `solidRhombus(``int` `rows)` `    ``{` `        ``int` `i, j;` `        ``for` `(i=1; i<=rows; i++)` `        ``{` `            ``// Print trailing spaces` `            ``for` `(j=1; j<=rows - i; j++)` `                ``Console.Write(``" "``);` `            `  `            ``// Print stars after spaces` `            ``for` `(j=1; j<=rows; j++)` `                ``Console.Write(``"*"``);` `            `  `            ``// Move to the next line/row` `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``// Function for Hollow Rhombus` `    ``static` `void` `hollowRhombus(``int` `rows)` `    ``{` `        ``int` `i, j;` `        ``for` `(i=1; i<=rows; i++)` `        ``{` `            ``// Print trailing spaces` `            ``for` `(j=1; j<=rows - i; j++)` `                ``Console.Write(``" "``);` `            `  `            ``// Print stars after spaces` `            ``// Print stars for each solid rows` `            ``if` `(i==1 || i==rows)` `                ``for` `(j=1; j<=rows; j++)` `                    ``Console.Write(``"*"``);` `                `  `            ``// stars for hollow rows` `            ``else` `                ``for` `(j=1; j<=rows; j++)` `                    ``if` `(j==1 || j==rows)` `                        ``Console.Write(``"*"``);` `                    ``else` `                    ``Console.Write(``" "``);` `            ``// Move to the next line/row` `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``// utility program to print all patterns` `    ``static` `void` `printPattern(``int` `rows)` `    ``{` `        ``Console.WriteLine(``"\nSolid Rhombus:\n"``);` `        ``solidRhombus(rows);` `    `  `        ``Console.WriteLine(``"\nHollow Rhombus:\n"``);` `        ``hollowRhombus(rows);` `    ``}` `    `  `    ``// driver program` `    ``public` `static` `void` `Main ()     {` `        ``int` `rows = 5;` `        ``printPattern (rows);` `    ``}` `}`   `// Contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output

```Solid Rhombus:
*****
*****
*****
*****
*****

Hollow Rhombus:
*****
*   *
*   *
*   *
*****```

Time Complexity: O(r2), where r represents the given number of rows.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

#### Approach:

solidRhombus function:

• Initialize variables i and j.
• Loop from i = 1 to n:
• Loop from j = 1 to n – i and print spaces.
• Loop from j = 1 to n and print asterisks.
• Print a new line.
• End of function.
•

hollowRhombus function:

• Initialize variables i and j.
• Loop from i = 1 to n:
• Loop from j = 1 to n – i and print spaces.
• Loop from j = 1 to n:
• If i = 1 or i = n or j = 1 or j = n, print an asterisk.
• Else, print a space.
• Print a new line.
• End of function.

## C

 `#include `   `// function to print solid rhombus` `void` `solidRhombus(``int` `n) {` `    ``int` `i, j;` `    ``for` `(i = 1; i <= n; i++) {` `        ``for` `(j = 1; j <= n - i; j++) {` `            ``printf``(``" "``);` `        ``}` `        ``for` `(j = 1; j <= n; j++) {` `            ``printf``(``"*"``);` `        ``}` `        ``printf``(``"\n"``);` `    ``}` `}`   `// function to print hollow rhombus` `void` `hollowRhombus(``int` `n) {` `    ``int` `i, j;` `    ``for` `(i = 1; i <= n; i++) {` `        ``for` `(j = 1; j <= n - i; j++) {` `            ``printf``(``" "``);` `        ``}` `        ``for` `(j = 1; j <= n; j++) {` `            ``if` `(i == 1 || i == n || j == 1 || j == n) {` `                ``printf``(``"*"``);` `            ``} ``else` `{` `                ``printf``(``" "``);` `            ``}` `        ``}` `        ``printf``(``"\n"``);` `    ``}` `}`   `int` `main() {` `    ``int` `n = 5;` `    ``printf``(``"Solid Rhombus:\n"``);` `    ``solidRhombus(n);`   `    ``printf``(``"Hollow Rhombus:\n"``);` `    ``hollowRhombus(n);`   `    ``return` `0;` `}`

## C++

 `#include `   `// function to print solid rhombus` `void` `solidRhombus(``int` `n) {` `    ``int` `i, j;` `    ``for` `(i = 1; i <= n; i++) {` `        ``for` `(j = 1; j <= n - i; j++) {` `            ``std::cout << ``" "``;` `        ``}` `        ``for` `(j = 1; j <= n; j++) {` `            ``std::cout << ``"*"``;` `        ``}` `        ``std::cout << std::endl;` `    ``}` `}`   `// function to print hollow rhombus` `void` `hollowRhombus(``int` `n) {` `    ``int` `i, j;` `    ``for` `(i = 1; i <= n; i++) {` `        ``for` `(j = 1; j <= n - i; j++) {` `            ``std::cout << ``" "``;` `        ``}` `        ``for` `(j = 1; j <= n; j++) {` `            ``if` `(i == 1 || i == n || j == 1 || j == n) {` `                ``std::cout << ``"*"``;` `            ``} ``else` `{` `                ``std::cout << ``" "``;` `            ``}` `        ``}` `        ``std::cout << std::endl;` `    ``}` `}`   `int` `main() {` `    ``int` `n = 5;` `    ``std::cout << ``"Solid Rhombus:"` `<< std::endl;` `    ``solidRhombus(n);`   `    ``std::cout << ``"Hollow Rhombus:"` `<< std::endl;` `    ``hollowRhombus(n);`   `    ``return` `0;` `}`

## Java

 `public` `class` `Rhombus {`   `    ``// function to print solid rhombus` `    ``public` `static` `void` `solidRhombus(``int` `n)` `    ``{` `        ``for` `(``int` `i = ``1``; i <= n; i++) {` `            ``for` `(``int` `j = ``1``; j <= n - i; j++) {` `                ``System.out.print(``" "``);` `            ``}` `            ``for` `(``int` `j = ``1``; j <= n; j++) {` `                ``System.out.print(``"*"``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// function to print hollow rhombus` `    ``public` `static` `void` `hollowRhombus(``int` `n)` `    ``{` `        ``for` `(``int` `i = ``1``; i <= n; i++) {` `            ``for` `(``int` `j = ``1``; j <= n - i; j++) {` `                ``System.out.print(``" "``);` `            ``}` `            ``for` `(``int` `j = ``1``; j <= n; j++) {` `                ``if` `(i == ``1` `|| i == n || j == ``1` `|| j == n) {` `                    ``System.out.print(``"*"``);` `                ``}` `                ``else` `{` `                    ``System.out.print(``" "``);` `                ``}` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``5``;` `        ``System.out.println(``"Solid Rhombus:"``);` `        ``solidRhombus(n);`   `        ``System.out.println(``"Hollow Rhombus:"``);` `        ``hollowRhombus(n);` `    ``}` `}`

## Python3

 `# function to print solid rhombus` `def` `solidRhombus(n):` `    ``for` `i ``in` `range``(``1``, n``+``1``):` `        ``for` `j ``in` `range``(``1``, n``-``i``+``1``):` `            ``print``(``" "``, end``=``"")` `        ``for` `j ``in` `range``(``1``, n``+``1``):` `            ``print``(``"*"``, end``=``"")` `        ``print``()` `        `  `# function to print hollow rhombus` `def` `hollowRhombus(n):` `    ``for` `i ``in` `range``(``1``, n``+``1``):` `        ``for` `j ``in` `range``(``1``, n``-``i``+``1``):` `            ``print``(``" "``, end``=``"")` `        ``for` `j ``in` `range``(``1``, n``+``1``):` `            ``if` `i``=``=``1` `or` `i``=``=``n ``or` `j``=``=``1` `or` `j``=``=``n:` `                ``print``(``"*"``, end``=``"")` `            ``else``:` `                ``print``(``" "``, end``=``"")` `        ``print``()`   `n ``=` `5` `print``(``"Solid Rhombus:"``)` `solidRhombus(n)`   `print``(``"Hollow Rhombus:"``)` `hollowRhombus(n)`

## C#

 `using` `System;`   `public` `class` `Rhombus {` `    ``// function to print solid rhombus` `    ``public` `static` `void` `solidRhombus(``int` `n) {` `        ``for` `(``int` `i = 1; i <= n; i++) {` `            ``for` `(``int` `j = 1; j <= n - i; j++) {` `                ``Console.Write(``" "``);` `            ``}` `            ``for` `(``int` `j = 1; j <= n; j++) {` `                ``Console.Write(``"*"``);` `            ``}` `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``// function to print hollow rhombus` `    ``public` `static` `void` `hollowRhombus(``int` `n) {` `        ``for` `(``int` `i = 1; i <= n; i++) {` `            ``for` `(``int` `j = 1; j <= n - i; j++) {` `                ``Console.Write(``" "``);` `            ``}` `            ``for` `(``int` `j = 1; j <= n; j++) {` `                ``if` `(i == 1 || i == n || j == 1 || j == n) {` `                    ``Console.Write(``"*"``);` `                ``} ``else` `{` `                    ``Console.Write(``" "``);` `                ``}` `            ``}` `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``public` `static` `void` `Main() {` `        ``int` `n = 5;` `        ``Console.WriteLine(``"Solid Rhombus:"``);` `        ``solidRhombus(n);`   `        ``Console.WriteLine(``"Hollow Rhombus:"``);` `        ``hollowRhombus(n);` `    ``}` `}`

## Javascript

 `// Javascript code addition `   `// function to print solid rhombus` `function` `solidRhombus(n) {` `  ``for` `(let i = 1; i <= n; i++) {` `    ``for` `(let j = 1; j <= n - i; j++) {` `      ``process.stdout.write(``" "``);` `    ``}` `    ``for` `(let j = 1; j <= n; j++) {` `      ``process.stdout.write(``"*"``);` `    ``}` `    ``process.stdout.write(``"\n"``);` `  ``}` `}`   `// function to print hollow rhombus` `function` `hollowRhombus(n) {` `  ``for` `(let i = 1; i <= n; i++) {` `    ``for` `(let j = 1; j <= n - i; j++) {` `      ``process.stdout.write(``" "``);` `    ``}` `    ``for` `(let j = 1; j <= n; j++) {` `      ``if` `(i == 1 || i == n || j == 1 || j == n) {` `        ``process.stdout.write(``"*"``);` `      ``} ``else` `{` `        ``process.stdout.write(``" "``);` `      ``}` `    ``}` `    ``process.stdout.write(``"\n"``);` `  ``}` `}`   `const n = 5;` `process.stdout.write(``"Solid Rhombus:\n"``);` `solidRhombus(n);` `process.stdout.write(``"Hollow Rhombus:\n"``);` `hollowRhombus(n);`   `// The code is contributed by Arushi Goel. `

Output

```Solid Rhombus:
*****
*****
*****
*****
*****
Hollow Rhombus:
*****
*   *
*   *
*   *
*****```

The time complexity of both functions is O(n^2), because there are two nested loops that iterate over all the rows and columns of the rhombus.
The space complexity is O(1), because only a constant amount of memory is used regardless of the size of the rhombus.

This article is contributed by Shivam Pradhan (anuj_charm). 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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up