Skip to main content

Print the pattern with two hollow triangles

In this article, we will explore a C program to print a pattern consisting of two hollow triangles. We will provide an explanation of the problem, present a suitable example, provide an algorithm and pseudocode, and discuss the resultant output along with the time complexity of the code.

Introduction

The objective of this problem is to create a pattern with two hollow triangles using asterisks as the pattern elements. The pattern will have a top section, an intermediate layer, a bottom layer, and a bottom section.

Problem Statement

Given an input value 'n,' the program should print a pattern with two hollow triangles. The value of 'n' determines the size of the pattern and affects the number of asterisks in each row.

Example:

Let's consider two examples:

Example 1: Given n = 5

            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

Example 2: Given n = 8

                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰

Algorithm and Pseudocode

The algorithm to print the pattern with two hollow triangles can be broken down into the following steps:

  1. Define a function to include spaces for creating indentation in the pattern.
  2. Define the main function to print the pattern.
  3. Print the top section of the pattern.
  4. Print the intermediate layer of the pattern.
  5. Print the bottom layer of the pattern.
  6. Print the bottom section of the pattern.
  7. Call the main function with different input values to test the pattern printing.

Below is the pseudocode for the program:


includeSpace(n):
    for i from 0 to n-1:
        print space

printPattern(n):
    print "Given n: " + n
    // Top Section
    for i from 0 to n-1:
        includeSpace((1 + n - i) * 2)
        for j from 0 to i * 2:
            print "✰ "
        print new line

    // Intermediate layer
    for i from 1 to n:
        includeSpace(4)
        for j from 0 to i-1:
            print "✰ "
        includeSpace((n - i) * 4 - 2)
        for j from 0 to i-1:
            if (j + 1) != n:
                print "✰ "
        print new line

    // Bottom layer
    for i from n-1 to 1:
        includeSpace(4)
        for j from 0 to i-1:
            print "✰ "
        includeSpace((n - i) * 4 - 2)
        for j from 0 to i-1:
            if (j + 1) != n:
                print "✰ "
        print new line

    // Bottom Section
    for i from 1 to n:
        includeSpace(2 + i * 2)
        for j from 0 to (n - i) * 2:
            print "✰ "
        print new line

main():
    printPattern(5)
    printPattern(8)

The main function calls the printPattern function with different input values to generate the desired pattern.

Code Solution

//  C program for
//  Print the pattern with two hollow triangles
#include <stdio.h>
 // This is display empty space of given length
void includeSpace(int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf(" ");
	}
}
void printPattern(int n)
{
	printf("\n Given n : %d \n", n);
	// Top Section
	for (int i = 0; i < n; ++i)
	{
		includeSpace((1 + n - i) *2);
		for (int j = 0; j <= i *2; ++j)
		{
			printf("✰ ");
		}
		printf("\n");
	}
	// Intermediate layer
	for (int i = 1; i <= n; ++i)
	{
		includeSpace(4);
		for (int j = 0; j < i; ++j)
		{
			printf("✰ ");
		}
		includeSpace((n - i) *4 - 2);
		for (int j = 0; j < i; ++j)
		{
			if (j + 1 != n)
			{
				printf("✰ ");
			}
		}
		printf("\n");
	}
	// Bottom layer
	for (int i = n - 1; i > 0; --i)
	{
		includeSpace(4);
		for (int j = 0; j < i; ++j)
		{
			printf("✰ ");
		}
		includeSpace((n - i) *4 - 2);
		for (int j = 0; j < i; ++j)
		{
			if (j + 1 != n)
			{
				printf("✰ ");
			}
		}
		printf("\n");
	}
	// Bottom Section
	for (int i = 1; i <= n; ++i)
	{
		includeSpace(2 + i *2);
		for (int j = 0; j <= (n - i) *2; ++j)
		{
			printf("✰ ");
		}
		printf("\n");
	}
}
int main(int argc, char
	const *argv[])
{
	// Test
	printPattern(5);
	printPattern(8);
	return 0;
}

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
/*
    Java Program
    Print the pattern with two hollow triangles
*/
public class Pattern
{
	// This is display empty space of given length
	public void includeSpace(int n)
	{
		for (int i = 0; i < n; ++i)
		{
			System.out.print(" ");
		}
	}
	public void printPattern(int n)
	{
		System.out.print("\n Given n : " + n + " \n");
		// Top Section
		for (int i = 0; i < n; ++i)
		{
			includeSpace((1 + n - i) * 2);
			for (int j = 0; j <= i * 2; ++j)
			{
				System.out.print("✰ ");
			}
			System.out.print("\n");
		}
		// Intermediate layer
		for (int i = 1; i <= n; ++i)
		{
			includeSpace(4);
			for (int j = 0; j < i; ++j)
			{
				System.out.print("✰ ");
			}
			includeSpace((n - i) * 4 - 2);
			for (int j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					System.out.print("✰ ");
				}
			}
			System.out.print("\n");
		}
		// Bottom layer
		for (int i = n - 1; i > 0; --i)
		{
			includeSpace(4);
			for (int j = 0; j < i; ++j)
			{
				System.out.print("✰ ");
			}
			includeSpace((n - i) * 4 - 2);
			for (int j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					System.out.print("✰ ");
				}
			}
			System.out.print("\n");
		}
		// Bottom Section
		for (int i = 1; i <= n; ++i)
		{
			includeSpace(2 + i * 2);
			for (int j = 0; j <= (n - i) * 2; ++j)
			{
				System.out.print("✰ ");
			}
			System.out.print("\n");
		}
	}
	public static void main(String[] args)
	{
		Pattern task = new Pattern();
		// Test
		task.printPattern(5);
		task.printPattern(8);
	}
}

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
// Include header file
#include <iostream>
using namespace std;
/*
    C++ Program
    Print the pattern with two hollow triangles
*/
class Pattern
{
	public:
		// This is display empty space of given length
		void includeSpace(int n)
		{
			for (int i = 0; i < n; ++i)
			{
				cout << " ";
			}
		}
	void printPattern(int n)
	{
		cout << "\n Given n : " << n << " \n";
		// Top Section
		for (int i = 0; i < n; ++i)
		{
			this->includeSpace((1 + n - i) *2);
			for (int j = 0; j <= i *2; ++j)
			{
				cout << "✰ ";
			}
			cout << "\n";
		}
		// Intermediate layer
		for (int i = 1; i <= n; ++i)
		{
			this->includeSpace(4);
			for (int j = 0; j < i; ++j)
			{
				cout << "✰ ";
			}
			this->includeSpace((n - i) *4 - 2);
			for (int j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					cout << "✰ ";
				}
			}
			cout << "\n";
		}
		// Bottom layer
		for (int i = n - 1; i > 0; --i)
		{
			this->includeSpace(4);
			for (int j = 0; j < i; ++j)
			{
				cout << "✰ ";
			}
			this->includeSpace((n - i) *4 - 2);
			for (int j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					cout << "✰ ";
				}
			}
			cout << "\n";
		}
		// Bottom Section
		for (int i = 1; i <= n; ++i)
		{
			this->includeSpace(2 + i *2);
			for (int j = 0; j <= (n - i) *2; ++j)
			{
				cout << "✰ ";
			}
			cout << "\n";
		}
	}
};
int main()
{
	Pattern *task = new Pattern();
	// Test
	task->printPattern(5);
	task->printPattern(8);
	return 0;
}

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
// Include namespace system
using System;
/*
    Csharp Program
    Print the pattern with two hollow triangles
*/
public class Pattern
{
	// This is display empty space of given length
	public void includeSpace(int n)
	{
		for (int i = 0; i < n; ++i)
		{
			Console.Write(" ");
		}
	}
	public void printPattern(int n)
	{
		Console.Write("\n Given n : " + n + " \n");
		// Top Section
		for (int i = 0; i < n; ++i)
		{
			this.includeSpace((1 + n - i) * 2);
			for (int j = 0; j <= i * 2; ++j)
			{
				Console.Write("✰ ");
			}
			Console.Write("\n");
		}
		// Intermediate layer
		for (int i = 1; i <= n; ++i)
		{
			this.includeSpace(4);
			for (int j = 0; j < i; ++j)
			{
				Console.Write("✰ ");
			}
			this.includeSpace((n - i) * 4 - 2);
			for (int j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					Console.Write("✰ ");
				}
			}
			Console.Write("\n");
		}
		// Bottom layer
		for (int i = n - 1; i > 0; --i)
		{
			this.includeSpace(4);
			for (int j = 0; j < i; ++j)
			{
				Console.Write("✰ ");
			}
			this.includeSpace((n - i) * 4 - 2);
			for (int j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					Console.Write("✰ ");
				}
			}
			Console.Write("\n");
		}
		// Bottom Section
		for (int i = 1; i <= n; ++i)
		{
			this.includeSpace(2 + i * 2);
			for (int j = 0; j <= (n - i) * 2; ++j)
			{
				Console.Write("✰ ");
			}
			Console.Write("\n");
		}
	}
	public static void Main(String[] args)
	{
		Pattern task = new Pattern();
		// Test
		task.printPattern(5);
		task.printPattern(8);
	}
}

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
package main
import "fmt"
/*
    Go Program
    Print the pattern with two hollow triangles
*/
type Pattern struct {}
func getPattern() * Pattern {
	var me *Pattern = &Pattern {}
	return me
}
// This is display empty space of given length
func(this Pattern) includeSpace(n int) {
	for i := 0 ; i < n ; i++ {
		fmt.Print(" ")
	}
}
func(this Pattern) printPattern(n int) {
	fmt.Print("\n Given n : ", n, " \n")
	// Top Section
	for i := 0 ; i < n ; i++ {
		this.includeSpace((1 + n - i) * 2)
		for j := 0 ; j <= i * 2 ; j++ {
			fmt.Print("✰ ")
		}
		fmt.Print("\n")
	}
	// Intermediate layer
	for i := 1 ; i <= n ; i++ {
		this.includeSpace(4)
		for j := 0 ; j < i ; j++ {
			fmt.Print("✰ ")
		}
		this.includeSpace((n - i) * 4 - 2)
		for j := 0 ; j < i ; j++ {
			if j + 1 != n {
				fmt.Print("✰ ")
			}
		}
		fmt.Print("\n")
	}
	// Bottom layer
	for i := n - 1 ; i > 0 ; i-- {
		this.includeSpace(4)
		for j := 0 ; j < i ; j++ {
			fmt.Print("✰ ")
		}
		this.includeSpace((n - i) * 4 - 2)
		for j := 0 ; j < i ; j++ {
			if j + 1 != n {
				fmt.Print("✰ ")
			}
		}
		fmt.Print("\n")
	}
	// Bottom Section
	for i := 1 ; i <= n ; i++ {
		this.includeSpace(2 + i * 2)
		for j := 0 ; j <= (n - i) * 2 ; j++ {
			fmt.Print("✰ ")
		}
		fmt.Print("\n")
	}
}
func main() {
	var task * Pattern = getPattern()
	// Test
	task.printPattern(5)
	task.printPattern(8)
}

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
<?php
/*
    Php Program
    Print the pattern with two hollow triangles
*/
class Pattern
{
	// This is display empty space of given length
	public	function includeSpace($n)
	{
		for ($i = 0; $i < $n; ++$i)
		{
			echo(" ");
		}
	}
	public	function printPattern($n)
	{
		echo("\n Given n : ".$n." \n");
		// Top Section
		for ($i = 0; $i < $n; ++$i)
		{
			$this->includeSpace((1 + $n - $i) * 2);
			for ($j = 0; $j <= $i * 2; ++$j)
			{
				echo("✰ ");
			}
			echo("\n");
		}
		// Intermediate layer
		for ($i = 1; $i <= $n; ++$i)
		{
			$this->includeSpace(4);
			for ($j = 0; $j < $i; ++$j)
			{
				echo("✰ ");
			}
			$this->includeSpace(($n - $i) * 4 - 2);
			for ($j = 0; $j < $i; ++$j)
			{
				if ($j + 1 != $n)
				{
					echo("✰ ");
				}
			}
			echo("\n");
		}
		// Bottom layer
		for ($i = $n - 1; $i > 0; --$i)
		{
			$this->includeSpace(4);
			for ($j = 0; $j < $i; ++$j)
			{
				echo("✰ ");
			}
			$this->includeSpace(($n - $i) * 4 - 2);
			for ($j = 0; $j < $i; ++$j)
			{
				if ($j + 1 != $n)
				{
					echo("✰ ");
				}
			}
			echo("\n");
		}
		// Bottom Section
		for ($i = 1; $i <= $n; ++$i)
		{
			$this->includeSpace(2 + $i * 2);
			for ($j = 0; $j <= ($n - $i) * 2; ++$j)
			{
				echo("✰ ");
			}
			echo("\n");
		}
	}
}

function main()
{
	$task = new Pattern();
	// Test
	$task->printPattern(5);
	$task->printPattern(8);
}
main();

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
/*
    Node JS Program
    Print the pattern with two hollow triangles
*/
class Pattern
{
	// This is display empty space of given length
	includeSpace(n)
	{
		for (var i = 0; i < n; ++i)
		{
			process.stdout.write(" ");
		}
	}
	printPattern(n)
	{
		process.stdout.write("\n Given n : " + n + " \n");
		// Top Section
		for (var i = 0; i < n; ++i)
		{
			this.includeSpace((1 + n - i) * 2);
			for (var j = 0; j <= i * 2; ++j)
			{
				process.stdout.write("✰ ");
			}
			process.stdout.write("\n");
		}
		// Intermediate layer
		for (var i = 1; i <= n; ++i)
		{
			this.includeSpace(4);
			for (var j = 0; j < i; ++j)
			{
				process.stdout.write("✰ ");
			}
			this.includeSpace((n - i) * 4 - 2);
			for (var j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					process.stdout.write("✰ ");
				}
			}
			process.stdout.write("\n");
		}
		// Bottom layer
		for (var i = n - 1; i > 0; --i)
		{
			this.includeSpace(4);
			for (var j = 0; j < i; ++j)
			{
				process.stdout.write("✰ ");
			}
			this.includeSpace((n - i) * 4 - 2);
			for (var j = 0; j < i; ++j)
			{
				if (j + 1 != n)
				{
					process.stdout.write("✰ ");
				}
			}
			process.stdout.write("\n");
		}
		// Bottom Section
		for (var i = 1; i <= n; ++i)
		{
			this.includeSpace(2 + i * 2);
			for (var j = 0; j <= (n - i) * 2; ++j)
			{
				process.stdout.write("✰ ");
			}
			process.stdout.write("\n");
		}
	}
}

function main()
{
	var task = new Pattern();
	// Test
	task.printPattern(5);
	task.printPattern(8);
}
main();

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
#    Python 3 Program
#    Print the pattern with two hollow triangles
class Pattern :
	#  This is display empty space of given length
	def includeSpace(self, n) :
		i = 0
		while (i < n) :
			print(" ", end = "")
			i += 1
		
	
	def printPattern(self, n) :
		print("\n Given n : ", n ," ")
		i = 0
		#  Top Section
		while (i < n) :
			self.includeSpace((1 + n - i) * 2)
			j = 0
			while (j <= i * 2) :
				print("✰ ", end = "")
				j += 1
			
			print(end = "\n")
			i += 1
		
		i = 1
		#  Intermediate layer
		while (i <= n) :
			self.includeSpace(4)
			j = 0
			while (j < i) :
				print("✰ ", end = "")
				j += 1
			
			self.includeSpace((n - i) * 4 - 2)
			j = 0
			while (j < i) :
				if (j + 1 != n) :
					print("✰ ", end = "")
				
				j += 1
			
			print(end = "\n")
			i += 1
		
		i = n - 1
		#  Bottom layer
		while (i > 0) :
			self.includeSpace(4)
			j = 0
			while (j < i) :
				print("✰ ", end = "")
				j += 1
			
			self.includeSpace((n - i) * 4 - 2)
			j = 0
			while (j < i) :
				if (j + 1 != n) :
					print("✰ ", end = "")
				
				j += 1
			
			print(end = "\n")
			i -= 1
		
		i = 1
		#  Bottom Section
		while (i <= n) :
			self.includeSpace(2 + i * 2)
			j = 0
			while (j <= (n - i) * 2) :
				print("✰ ", end = "")
				j += 1
			
			print(end = "\n")
			i += 1
		
	

def main() :
	task = Pattern()
	#  Test
	task.printPattern(5)
	task.printPattern(8)

if __name__ == "__main__": main()

Output

 Given n :  5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n :  8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
#    Ruby Program
#    Print the pattern with two hollow triangles
class Pattern 
	#  This is display empty space of given length
	def includeSpace(n) 
		i = 0
		while (i < n) 
			print(" ")
			i += 1
		end

	end

	def printPattern(n) 
		print("\n Given n : ", n ," \n")
		i = 0
		#  Top Section
		while (i < n) 
			self.includeSpace((1 + n - i) * 2)
			j = 0
			while (j <= i * 2) 
				print("✰ ")
				j += 1
			end

			print("\n")
			i += 1
		end

		i = 1
		#  Intermediate layer
		while (i <= n) 
			self.includeSpace(4)
			j = 0
			while (j < i) 
				print("✰ ")
				j += 1
			end

			self.includeSpace((n - i) * 4 - 2)
			j = 0
			while (j < i) 
				if (j + 1 != n) 
					print("✰ ")
				end

				j += 1
			end

			print("\n")
			i += 1
		end

		i = n - 1
		#  Bottom layer
		while (i > 0) 
			self.includeSpace(4)
			j = 0
			while (j < i) 
				print("✰ ")
				j += 1
			end

			self.includeSpace((n - i) * 4 - 2)
			j = 0
			while (j < i) 
				if (j + 1 != n) 
					print("✰ ")
				end

				j += 1
			end

			print("\n")
			i -= 1
		end

		i = 1
		#  Bottom Section
		while (i <= n) 
			self.includeSpace(2 + i * 2)
			j = 0
			while (j <= (n - i) * 2) 
				print("✰ ")
				j += 1
			end

			print("\n")
			i += 1
		end

	end

end

def main() 
	task = Pattern.new()
	#  Test
	task.printPattern(5)
	task.printPattern(8)
end

main()

Output

 Given n : 5 
            ✰ 
          ✰ ✰ ✰ 
        ✰ ✰ ✰ ✰ ✰ 
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰               ✰ 
    ✰ ✰           ✰ ✰ 
    ✰ ✰ ✰       ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰       ✰ ✰ ✰ 
    ✰ ✰           ✰ ✰ 
    ✰               ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
        ✰ ✰ ✰ ✰ ✰ 
          ✰ ✰ ✰ 
            ✰ 

 Given n : 8 
                  ✰ 
                ✰ ✰ ✰ 
              ✰ ✰ ✰ ✰ ✰ 
            ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰                           ✰ 
    ✰ ✰                       ✰ ✰ 
    ✰ ✰ ✰                   ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰ 
    ✰ ✰ ✰                   ✰ ✰ ✰ 
    ✰ ✰                       ✰ ✰ 
    ✰                           ✰ 
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
            ✰ ✰ ✰ ✰ ✰ ✰ ✰ 
              ✰ ✰ ✰ ✰ ✰ 
                ✰ ✰ ✰ 
                  ✰ 
/*
    Scala Program
    Print the pattern with two hollow triangles
*/
class Pattern()
{
	// This is display empty space of given length
	def includeSpace(n: Int): Unit = {
		var i: Int = 0;
		while (i < n)
		{
			print(" ");
			i += 1;
		}
	}
	def printPattern(n: Int): Unit = {
		print("\n Given n : " + n + " \n");
		var i: Int = 0;
		// Top Section
		while (i < n)
		{
			includeSpace((1 + n - i) * 2);
			var j: Int = 0;
			while (j <= i * 2)
			{
				print("✰ ");
				j += 1;
			}
			print("\n");
			i += 1;
		}
		i = 1;
		// Intermediate layer
		while (i <= n)
		{
			includeSpace(4);
			var j: Int = 0;
			while (j < i)
			{
				print("✰ ");
				j += 1;
			}
			includeSpace((n - i) * 4 - 2);
			j = 0;
			while (j < i)
			{
				if (j + 1 != n)
				{
					print("✰ ");
				}
				j += 1;
			}
			print("\n");
			i += 1;
		}
		i = n - 1;
		// Bottom layer
		while (i > 0)
		{
			includeSpace(4);
			var j: Int = 0;
			while (j < i)
			{
				print("✰ ");
				j += 1;
			}
			includeSpace((n - i) * 4 - 2);
			j = 0;
			while (j < i)
			{
				if (j + 1 != n)
				{
					print("✰ ");
				}
				j += 1;
			}
			print("\n");
			i -= 1;
		}
		i = 1;
		// Bottom Section
		while (i <= n)
		{
			includeSpace(2 + i * 2);
			var j: Int = 0;
			while (j <= (n - i) * 2)
			{
				print("✰ ");
				j += 1;
			}
			print("\n");
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Pattern = new Pattern();
		// Test
		task.printPattern(5);
		task.printPattern(8);
	}
}

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
/*
    Swift 4 Program
    Print the pattern with two hollow triangles
*/
class Pattern
{
	// This is display empty space of given length
	func includeSpace(_ n: Int)
	{
		var i: Int = 0;
		while (i < n)
		{
			print(" ", terminator: "");
			i += 1;
		}
	}
	func printPattern(_ n: Int)
	{
		print("\n Given n : ", n ," ");
		var i: Int = 0;
		// Top Section
		while (i < n)
		{
			self.includeSpace((1 + n - i) * 2);
			var j: Int = 0;
			while (j <= i * 2)
			{
				print("✰ ", terminator: "");
				j += 1;
			}
			print(terminator: "\n");
			i += 1;
		}
		i = 1;
		// Intermediate layer
		while (i <= n)
		{
			self.includeSpace(4);
			var j: Int = 0;
			while (j < i)
			{
				print("✰ ", terminator: "");
				j += 1;
			}
			self.includeSpace((n - i) * 4 - 2);
			j = 0;
			while (j < i)
			{
				if (j + 1  != n)
				{
					print("✰ ", terminator: "");
				}
				j += 1;
			}
			print(terminator: "\n");
			i += 1;
		}
		i = n - 1;
		// Bottom layer
		while (i > 0)
		{
			self.includeSpace(4);
			var j: Int = 0;
			while (j < i)
			{
				print("✰ ", terminator: "");
				j += 1;
			}
			self.includeSpace((n - i) * 4 - 2);
			j = 0;
			while (j < i)
			{
				if (j + 1  != n)
				{
					print("✰ ", terminator: "");
				}
				j += 1;
			}
			print(terminator: "\n");
			i -= 1;
		}
		i = 1;
		// Bottom Section
		while (i <= n)
		{
			self.includeSpace(2 + i * 2);
			var j: Int = 0;
			while (j <= (n - i) * 2)
			{
				print("✰ ", terminator: "");
				j += 1;
			}
			print(terminator: "\n");
			i += 1;
		}
	}
}
func main()
{
	let task: Pattern = Pattern();
	// Test
	task.printPattern(5);
	task.printPattern(8);
}
main();

Output

 Given n :  5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n :  8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰
/*
    Kotlin Program
    Print the pattern with two hollow triangles
*/
class Pattern
{
	// This is display empty space of given length
	fun includeSpace(n: Int): Unit
	{
		var i: Int = 0;
		while (i < n)
		{
			print(" ");
			i += 1;
		}
	}
	fun printPattern(n: Int): Unit
	{
		print("\n Given n : " + n + " \n");
		var i: Int = 0;
		// Top Section
		while (i < n)
		{
			this.includeSpace((1 + n - i) * 2);
			var j: Int = 0;
			while (j <= i * 2)
			{
				print("✰ ");
				j += 1;
			}
			print("\n");
			i += 1;
		}
		i = 1;
		// Intermediate layer
		while (i <= n)
		{
			this.includeSpace(4);
			var j: Int = 0;
			while (j < i)
			{
				print("✰ ");
				j += 1;
			}
			this.includeSpace((n - i) * 4 - 2);
			j = 0;
			while (j < i)
			{
				if (j + 1 != n)
				{
					print("✰ ");
				}
				j += 1;
			}
			print("\n");
			i += 1;
		}
		i = n - 1;
		// Bottom layer
		while (i > 0)
		{
			this.includeSpace(4);
			var j: Int = 0;
			while (j < i)
			{
				print("✰ ");
				j += 1;
			}
			this.includeSpace((n - i) * 4 - 2);
			j = 0;
			while (j < i)
			{
				if (j + 1 != n)
				{
					print("✰ ");
				}
				j += 1;
			}
			print("\n");
			i -= 1;
		}
		i = 1;
		// Bottom Section
		while (i <= n)
		{
			this.includeSpace(2 + i * 2);
			var j: Int = 0;
			while (j <= (n - i) * 2)
			{
				print("✰ ");
				j += 1;
			}
			print("\n");
			i += 1;
		}
	}
}
fun main(args: Array < String > ): Unit
{
	val task: Pattern = Pattern();
	// Test
	task.printPattern(5);
	task.printPattern(8);
}

Output

 Given n : 5
            ✰
          ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰               ✰
    ✰ ✰           ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰
    ✰ ✰ ✰       ✰ ✰ ✰
    ✰ ✰           ✰ ✰
    ✰               ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰
            ✰

 Given n : 8
                  ✰
                ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰                           ✰
    ✰ ✰                       ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰   ✰ ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰ ✰       ✰ ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰ ✰           ✰ ✰ ✰ ✰ ✰
    ✰ ✰ ✰ ✰               ✰ ✰ ✰ ✰
    ✰ ✰ ✰                   ✰ ✰ ✰
    ✰ ✰                       ✰ ✰
    ✰                           ✰
    ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
      ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
        ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
          ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰ ✰
            ✰ ✰ ✰ ✰ ✰ ✰ ✰
              ✰ ✰ ✰ ✰ ✰
                ✰ ✰ ✰
                  ✰

The pattern consists of two hollow triangles, one on top of the other. The number of rows in each triangle is determined by the input value 'n.' The pattern is created using asterisks ('✰') as the pattern elements, with appropriate indentation and spacing.

Time Complexity

The time complexity of this code is O(n^2), where 'n' represents the input value. This is because there are nested loops that iterate up to 'n' in different sections of the code. As the input value increases, the number of iterations in each loop increases quadratically, resulting in a quadratic time complexity.

Finally

In this article, we explored a C program to print a pattern with two hollow triangles using asterisks as pattern elements. We provided an explanation of the problem, presented examples, discussed the algorithm and pseudocode, and explained the resultant output. The time complexity of the code was also analyzed. By understanding and implementing this program, you can create visually appealing patterns using nested loops and proper indentation.





Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment