Open In App

Program to print solid and hollow rhombus patterns

Last Updated : 20 Apr, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

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("&nbsp;&nbsp;");

          // 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("&nbsp;&nbsp;");

          // 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("&nbsp;&nbsp;");
              
          // 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(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 <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.


 


Next Article
Program to print solid and hollow rhombus patterns

K

kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox