Print flying machine pattern
In this article, we will explore a C program to print a flying machine pattern. The program will generate a visually appealing pattern using symbols. We will discuss the problem statement, provide an explanation with suitable examples, present the algorithm and pseudocode, and finally explain the output and time complexity of the code.

Problem Statement
The task is to create a C program that prints a flying machine pattern based on the given height. The height determines the size of the pattern. The pattern consists of a symmetrical representation of a flying machine using symbols.
Example:
For a height of 6, the pattern would look like this:
☆ ☆☀☀☀☆ ☆☀☀☀☀☀☀☀☆ ☆☀☀☀☆ ☆☀☀☀☆ ☆☀☆ ☆☀☆ ☆ ☆
Algorithm and Pseudocode
1. Create a function named space
that takes a size parameter. This function will print spaces based on the given size.
2. Create a function named print_symbol
that takes a size parameter. This function will print symbols based on the given size. In this case, the symbol chosen is the star (☆
) for the edges and the sun (☀
) for the inner part of the machine.
3. Create a function named flying_pattern
that takes a height parameter. This function will display the flying machine pattern based on the given height.
4. Inside the flying_pattern
function, check if the height is less than 4 or odd. If it is, return from the function.
5. Print the height value.
6. Use a loop to display the top half shell of the pattern. Inside the loop:
- Call the
space
function to print initial spaces based on the height. - Call the
print_symbol
function to print symbols based on the current iteration. - Print a new line.
7. Use another loop to display the bottom half shell of the pattern. Inside the loop:
- Call the
space
function to print initial spaces based on the height and current iteration. - Call the
print_symbol
function to print symbols based on the current iteration. - Call the
space
function to print spaces in between the two halves. - Call the
print_symbol
function again to print symbols based on the current iteration. - Print a new line.
8. In the main
function, test the flying_pattern
function with different heights.
Output Explanation
The output shows the flying machine pattern for different heights: 6, 8, and 12. Each pattern is displayed with the height value.
The pattern is constructed using spaces and symbols. The spaces create the indentation effect, while the symbols form the shape of the flying machine. The star symbol (☆
) is used for the edges, and the sun symbol (☀
) is used for the inner part.
As the height increases, the pattern becomes more intricate, with a larger number of symbols and spaces to create the desired shape. The pattern is symmetric, and both halves are identical.
Code Solution
Given an integer height, our goal is to display a relevant flying machine pattern of given this even height. For example.
In this example outer layer is form of ☆ symbol. and inner layer is form of an ☀ symbol. Here given code implementation process.
//C Program
//Print flying machine pattern
#include <stdio.h>
/*Include Space of given size*/
void space(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
//Add space
printf(" ");
}
}
/*Include Symbol*/
void print_symbol(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
if (counter == 0 || counter + 1 == size)
{
printf("☆");
}
else
{
printf("☀");
}
}
}
//Display the flying machine pattern of given height
void flying_pattern(int height)
{
if (height < 4 || height % 2 != 0)
{
return;
}
printf("\n Height : %d \n", height);
int i = 0;
//Display the result of top half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
space((height * 2) - (i * 2));
//include symbol we can use any symbol
print_symbol((i * 4) + 1);
printf("\n");
}
//Display the result of bottom half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
space(((height / 2) - i) * 2);
print_symbol((height / 2 - i) * 2 - 1);
space((i * 8) + 3);
print_symbol((height / 2 - i) * 2 - 1);
printf("\n");
}
}
int main()
{
//Test Cases
flying_pattern(6);
flying_pattern(8);
flying_pattern(12);
return 0;
}
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
/*
Java Program
Print flying machine pattern
*/
class MyPattern
{
public void space(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
//Add space
System.out.print(" ");
}
}
public void print_symbol(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
if (counter == 0 || counter + 1 == size)
{
System.out.print("☆");
}
else
{
System.out.print("☀");
}
}
}
//Display the flying machine pattern of given height
public void flying_pattern(int height)
{
if (height < 4 || height % 2 != 0)
{
return;
}
System.out.print("\n Height : " + height + " \n");
int i = 0;
//Display the result of top half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
space((height * 2) - (i * 2));
//include symbol we can use any symbol
print_symbol((i * 4) + 1);
System.out.print("\n");
}
//Display the result of bottom half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
space(((height / 2) - i) * 2);
print_symbol((height / 2 - i) * 2 - 1);
space((i * 8) + 3);
print_symbol((height / 2 - i) * 2 - 1);
System.out.print("\n");
}
}
public static void main(String[] args)
{
MyPattern obj = new MyPattern();
//Test Cases
obj.flying_pattern(6);
obj.flying_pattern(8);
obj.flying_pattern(12);
}
}
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
/*
C++ Program
Print flying machine pattern
*/
#include<iostream>
using namespace std;
class MyPattern
{
public: void space(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
cout << " ";
}
}
void print_symbol(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
if (counter == 0 || counter + 1 == size)
{
cout << "☆";
}
else
{
cout << "☀";
}
}
}
//Display the flying machine pattern of given height
void flying_pattern(int height)
{
if (height < 4 || height % 2 != 0)
{
return;
}
cout << "\n Height : " << height << " \n";
int i = 0;
//Display the result of top half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
this->space((height * 2) - (i * 2));
//include symbol we can use any symbol
this->print_symbol((i * 4) + 1);
cout << "\n";
}
//Display the result of bottom half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
this->space(((height / 2) - i) * 2);
this->print_symbol((height / 2 - i) * 2 - 1);
this->space((i * 8) + 3);
this->print_symbol((height / 2 - i) * 2 - 1);
cout << "\n";
}
}
};
int main()
{
MyPattern obj;
//Test Cases
obj.flying_pattern(6);
obj.flying_pattern(8);
obj.flying_pattern(12);
return 0;
}
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
/*
C# Program
Print flying machine pattern
*/
using System;
class MyPattern
{
public void space(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
Console.Write(" ");
}
}
public void print_symbol(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
if (counter == 0 || counter + 1 == size)
{
Console.Write("☆");
}
else
{
Console.Write("☀");
}
}
}
//Display the flying machine pattern of given height
public void flying_pattern(int height)
{
if (height < 4 || height % 2 != 0)
{
return;
}
Console.Write("\n Height : " + height + " \n");
int i = 0;
//Display the result of top half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
space((height * 2) - (i * 2));
//include symbol we can use any symbol
print_symbol((i * 4) + 1);
Console.Write("\n");
}
//Display the result of bottom half shell
for (i = 0; i < height / 2; i++)
{
//include initial space
space(((height / 2) - i) * 2);
print_symbol((height / 2 - i) * 2 - 1);
space((i * 8) + 3);
print_symbol((height / 2 - i) * 2 - 1);
Console.Write("\n");
}
}
public static void Main(String[] args)
{
MyPattern obj = new MyPattern();
//Test Cases
obj.flying_pattern(6);
obj.flying_pattern(8);
obj.flying_pattern(12);
}
}
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
<?php
/*
Php Program
Print flying machine pattern
*/
class MyPattern
{
function space($size)
{
$counter = 0;
for ($counter = 0; $counter < $size; $counter++)
{
echo " ";
}
}
function print_symbol($size)
{
$counter = 0;
for ($counter = 0; $counter < $size; $counter++)
{
if ($counter == 0 || $counter + 1 == $size)
{
echo "☆";
}
else
{
echo "☀";
}
}
}
//Display the flying machine pattern of given height
function flying_pattern($height)
{
if ($height < 4 || $height % 2 != 0)
{
return;
}
echo "\n Height : ". $height ." \n";
$i = 0;
//Display the result of top half shell
for ($i = 0; $i < intval($height / 2); $i++)
{
//include initial space
$this->space(($height * 2) - ($i * 2));
//include symbol we can use any symbol
$this->print_symbol(($i * 4) + 1);
echo "\n";
}
//Display the result of bottom half shell
for ($i = 0; $i < intval($height / 2); $i++)
{
//include initial space
$this->space(((intval($height / 2)) - $i) * 2);
$this->print_symbol((intval($height / 2) - $i) * 2 - 1);
$this->space(($i * 8) + 3);
$this->print_symbol((intval($height / 2) - $i) * 2 - 1);
echo "\n";
}
}
}
function main()
{
$obj = new MyPattern();
//Test Cases
$obj->flying_pattern(6);
$obj->flying_pattern(8);
$obj->flying_pattern(12);
}
main();
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
/*
Node Js Program
Print flying machine pattern
*/
class MyPattern
{
space(size)
{
var counter = 0;
for (counter = 0; counter < size; counter++)
{
process.stdout.write(" ");
}
}
print_symbol(size)
{
var counter = 0;
for (counter = 0; counter < size; counter++)
{
if (counter == 0 || counter + 1 == size)
{
process.stdout.write("☆");
}
else
{
process.stdout.write("☀");
}
}
}
//Display the flying machine pattern of given height
flying_pattern(height)
{
if (height < 4 || height % 2 != 0)
{
return;
}
process.stdout.write("\n Height : " + height + " \n");
var i = 0;
//Display the result of top half shell
for (i = 0; i < parseInt(height / 2); i++)
{
//include initial space
this.space((height * 2) - (i * 2));
//include symbol we can use any symbol
this.print_symbol((i * 4) + 1);
process.stdout.write("\n");
}
//Display the result of bottom half shell
for (i = 0; i < parseInt(height / 2); i++)
{
//include initial space
this.space(((parseInt(height / 2)) - i) * 2);
this.print_symbol((parseInt(height / 2) - i) * 2 - 1);
this.space((i * 8) + 3);
this.print_symbol((parseInt(height / 2) - i) * 2 - 1);
process.stdout.write("\n");
}
}
}
function main()
{
var obj = new MyPattern();
//Test Cases
obj.flying_pattern(6);
obj.flying_pattern(8);
obj.flying_pattern(12);
}
main();
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
# Python 3 Program
# Print flying machine pattern
class MyPattern :
def space(self, size) :
counter = 0
while (counter < size) :
print(" ", end = "")
counter += 1
def print_symbol(self, size) :
counter = 0
while (counter < size) :
if (counter == 0 or counter + 1 == size) :
print("☆", end = "")
else :
print("☀", end = "")
counter += 1
# Display the flying machine pattern of given height
def flying_pattern(self, height) :
if (height < 4 or height % 2 != 0) :
return
print("\n Height : ", height ," \n", end = "")
i = 0
# Display the result of top half shell
while (i < int(height / 2)) :
# include initial space
self.space((height * 2) - (i * 2))
# include symbol we can use any symbol
self.print_symbol((i * 4) + 1)
print("\n", end = "")
i += 1
# Display the result of bottom half shell
i = 0
while (i < int(height / 2)) :
# include initial space
self.space(((int(height / 2)) - i) * 2)
self.print_symbol((int(height / 2) - i) * 2 - 1)
self.space((i * 8) + 3)
self.print_symbol((int(height / 2) - i) * 2 - 1)
print("\n", end = "")
i += 1
def main() :
obj = MyPattern()
# Test Cases
obj.flying_pattern(6)
obj.flying_pattern(8)
obj.flying_pattern(12)
if __name__ == "__main__": main()
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
# Ruby Program
# Print flying machine pattern
class MyPattern
def space(size)
counter = 0
while (counter < size)
# Add space
print(" ")
counter += 1
end
end
def print_symbol(size)
counter = 0
while (counter < size)
if (counter == 0 || counter + 1 == size)
print("☆")
else
print("☀")
end
counter += 1
end
end
# Display the flying machine pattern of given height
def flying_pattern(height)
if (height < 4 || height % 2 != 0)
return
end
print("\n Height : ", height ," \n")
i = 0
# Display the result of top half shell
while (i < height / 2)
# include initial space
self.space((height * 2) - (i * 2))
# include symbol we can use any symbol
self.print_symbol((i * 4) + 1)
print("\n")
i += 1
end
# Display the result of bottom half shell
i = 0
while (i < height / 2)
# include initial space
self.space(((height / 2) - i) * 2)
self.print_symbol((height / 2 - i) * 2 - 1)
self.space((i * 8) + 3)
self.print_symbol((height / 2 - i) * 2 - 1)
print("\n")
i += 1
end
end
end
def main()
obj = MyPattern.new()
# Test Cases
obj.flying_pattern(6)
obj.flying_pattern(8)
obj.flying_pattern(12)
end
main()
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
/*
Scala Program
Print flying machine pattern
*/
class MyPattern
{
def space(size: Int): Unit = {
var counter: Int = 0;
while (counter < size)
{
//Add space
print(" ");
counter += 1;
}
}
def print_symbol(size: Int): Unit = {
var counter: Int = 0;
while (counter < size)
{
if (counter == 0 || counter + 1 == size)
{
print("☆");
}
else
{
print("☀");
}
counter += 1;
}
}
//Display the flying machine pattern of given height
def flying_pattern(height: Int): Unit = {
if (height < 4 || height % 2 != 0)
{
return;
}
print("\n Height : " + height + " \n");
var i: Int = 0;
//Display the result of top half shell
while (i < (height / 2).toInt)
{
//include initial space
space((height * 2) - (i * 2));
//include symbol we can use any symbol
print_symbol((i * 4) + 1);
print("\n");
i += 1;
}
//Display the result of bottom half shell
i = 0;
while (i < (height / 2).toInt)
{
//include initial space
space((((height / 2).toInt) - i) * 2);
print_symbol(((height / 2).toInt - i) * 2 - 1);
space((i * 8) + 3);
print_symbol(((height / 2).toInt - i) * 2 - 1);
print("\n");
i += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var obj: MyPattern = new MyPattern();
//Test Cases
obj.flying_pattern(6);
obj.flying_pattern(8);
obj.flying_pattern(12);
}
}
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
/*
Swift Program
Print flying machine pattern
*/
class MyPattern
{
func space(_ size: Int)
{
var counter: Int = 0;
while (counter < size)
{
print(" ", terminator: "");
counter += 1;
}
}
func print_symbol(_ size: Int)
{
var counter: Int = 0;
while (counter < size)
{
if (counter == 0 || counter + 1 == size)
{
print("☆", terminator: "");
}
else
{
print("☀", terminator: "");
}
counter += 1;
}
}
//Display the flying machine pattern of given height
func flying_pattern(_ height: Int)
{
if (height < 4 || height % 2 != 0)
{
return;
}
print("\n Height : ", height ," \n", terminator: "");
var i: Int = 0;
//Display the result of top half shell
while (i < height / 2)
{
//include initial space
self.space((height * 2) - (i * 2));
//include symbol we can use any symbol
self.print_symbol((i * 4) + 1);
print("\n", terminator: "");
i += 1;
}
//Display the result of bottom half shell
i = 0;
while (i < height / 2)
{
//include initial space
self.space(((height / 2) - i) * 2);
self.print_symbol((height / 2 - i) * 2 - 1);
self.space((i * 8) + 3);
self.print_symbol((height / 2 - i) * 2 - 1);
print("\n", terminator: "");
i += 1;
}
}
}
func main()
{
let obj: MyPattern = MyPattern();
//Test Cases
obj.flying_pattern(6);
obj.flying_pattern(8);
obj.flying_pattern(12);
}
main();
Output
Height : 6
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 8
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Height : 12
☆
☆☀☀☀☆
☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☀☀☆ ☆☀☀☀☀☀☀☀☆
☆☀☀☀☀☀☆ ☆☀☀☀☀☀☆
☆☀☀☀☆ ☆☀☀☀☆
☆☀☆ ☆☀☆
☆ ☆
Time Complexity
The time complexity of the program can be analyzed based on the number of iterations in the loops. The top half shell and the bottom half shell are printed separately, each in its respective loop.
Let n be the given height. The top half shell loop iterates n/2 times, and the bottom half shell loop also iterates n/2 times. Therefore, the total number of iterations is approximately n.
Thus, the time complexity of the code can be approximated as O(n), where n represents the height of the flying machine pattern.
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