# 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.

Previous
Next
Share your thoughts in the comments
Similar Reads