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 <bits/stdc++.h>
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

<?php
// php program to print hollow`
// and solid rhombus patterns

// Function for Solid Rhombus
function solidRhombus($rows)
{

    for ($i = 1; $i <= $rows; $i++)
    {

        // Print trailing spaces
        for ($j = 1; $j <= $rows - $i; $j++)
            echo " ";

        // Print stars after spaces
        for ($j = 1; $j <= $rows; $j++)
            echo "*";

        // Move to the next line/row
        echo "\n";
    }
}

// Function for Hollow Rhombus
function hollowRhombus($rows)
{
    for ($i = 1; $i <= $rows; $i++)
    {

        // Print trailing spaces
        for ($j = 1; $j <= $rows - $i; $j++)
            echo " ";

        // Print stars after spaces
        // Print stars for each solid $rows
        if ($i == 1 || $i == $rows)
            for ($j = 1; $j <= $rows; $j++)
                echo "*";

        // stars for hollow $rows
        else
            for ($j = 1; $j <= $rows; $j++)
                if ($j == 1 || $j == $rows)
                    echo "*";
                else
                    echo " ";
        // Move to the next line/row
        echo "\n";
    }
}

// utility program to print
// all patterns
function printPattern($rows)
{
    echo "\nSolid Rhombus:\n";
    solidRhombus($rows);

    echo "\nHollow Rhombus:\n";
    hollowRhombus($rows);
}

    // Driver Code
    $rows = 5;
    printPattern ($rows);

// This code is contributed by mits
?>

Javascript

<script>
      // JavaScript program to print
      // hollow and solid rhombus patterns

      // Function for Solid Rhombus
      function solidRhombus(rows)
      {
        var i, j;
        for (i = 1; i <= rows; i++)
        {

          // Print trailing spaces
          for (j = 1; j <= rows - i; j++) document.write("  ");

          // Print stars after spaces
          for (j = 1; j <= rows; j++) document.write("*");

          // Move to the next line/row
          document.write("<br>");
        }
      }

      // Function for Rhombus
      function hollowRhombus(rows)
      {
        var i, j;
        for (i = 1; i <= rows; i++)
        {

          // Print trailing spaces
          for (j = 1; j <= rows - i; j++) document.write("  ");

          // Print stars after spaces
          // Print stars for each solid rows
          if (i == 1 || i == rows)
            for (j = 1; j <= rows; j++) document.write("*");

          // stars for hollow rows
          else
            for (j = 1; j <= rows; j++)
              if (j == 1 || j == rows) document.write("*");
              else document.write("  ");

          // Move to the next line/row
          document.write("<br>");
        }
      }

      // utility program to print all patterns
      function printPattern(rows)
      {
        document.write("Solid Rhombus:<br>");
        solidRhombus(rows);

        document.write("Hollow Rhombus:<br>");
        hollowRhombus(rows);
      }

      // driver program
      var rows = 5;
      printPattern(rows);

      // This code is contributed by rdtank.
    </script>

Output

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

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

Time Complexity: O(r²), 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 <stdio.h>

// 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 <iostream>

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