# 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)
{
// Test
}
}``````

#### 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()
{
// Test
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)
{
// Test
}
}``````

#### 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
}``````

#### 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()
{
// Test
}
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()
{
// Test
}
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() :
#  Test

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()
#  Test
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
}
}``````

#### 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()
{
// Test
}
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
{
// Test
}``````

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