Posted on by Kalkicode
Code Pattern

Print hexagonal star pattern

The hexagonal star pattern is a geometric pattern consisting of hexagons formed by stars. It is an interesting pattern that can be created using loops and conditional statements in a programming language. In this article, we will discuss the problem statement, provide an explanation of the code, and analyze its time complexity.

Problem Statement

The problem is to write a program that prints a hexagonal star pattern based on a given size. The program should take an integer as input representing the size of the hexagon, and then display the hexagon pattern on the console.

For example, if the input size is 4, the program should print the following pattern:

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Code Explanation

The provided code is written in the C programming language. It consists of several functions to create the hexagonal pattern:

  • space(int size): This function prints spaces based on the given size.
  • print_symbol(int size): This function prints a symbol (in this case, an asterisk '*') based on the given size.
  • hexagonal_pattern(int size): This function generates the hexagonal pattern based on the given size.
  • main(): This is the entry point of the program where the hexagonal patterns of different sizes are printed.

The hexagonal_pattern function takes the size of the hexagon as input. It first checks if the size is less than 2 and returns if it is. Then it proceeds to print the top layers and bottom layers of the hexagon using loops and conditional statements.

Algorithm and Pseudocode

Here is the algorithm for generating the hexagonal pattern:

  1. Check if the given size is less than 2. If so, return.
  2. Calculate the midpoint of the size.
  3. Print the top layers of the hexagon:
    1. Iterate from 0 to size - 1:
    2. Print spaces based on size - i.
    3. If i is 0, print the entire row with symbols (print_symbol function).
    4. Otherwise, print an asterisk, spaces ((size - 1) * 2) + i * 2 - 1, and another asterisk.
  4. Print the bottom layers of the hexagon:
    1. Iterate from 1 to size - 1:
    2. Print spaces based on i + 1.
    3. If i + 1 is equal to size, print the entire row with symbols (print_symbol function).
    4. Otherwise, print an asterisk, spaces ((size - 1) * 4) - i * 2 - 1, and another asterisk.

Here is the corresponding pseudocode:

function space(size):
    for counter from 0 to size:
        print space

function print_symbol(size):
    for counter from 0 to size:
        print asterisk

function hexagonal_pattern(size):
    if size < 2:
        return
    mid = size / 2
    for i from 0 to size:
        space(size - i)
        if i == 0:
            print_symbol(size)
        else:
            print asterisk
            space(((size - 1) * 2) + i * 2 - 1)
            print asterisk
        print new line
    for i from 1 to size:
        space(i + 1)
        if i + 1 == size:
            print_symbol(size)
        else:
            print asterisk
            space(((size - 1) * 4) - i * 2 - 1)
            print asterisk
        print new line

main function:
    hexagonal_pattern(4)
    hexagonal_pattern(7)
    hexagonal_pattern(9)

Code Solution

Here given code implementation process.

//C Program 
//Print hexagonal star 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(" ");
	}
}
void print_symbol(int size)
{
	int counter = 0;
	for (counter = 0; counter < size; counter++)
	{
		printf("* ");
	}
}
//Print hexagon of given side
void hexagonal_pattern(int size)
{
	if (size < 2)
	{
		return;
	}
	printf("\nSize : %d\n\n", size);
	int mid = size / 2;
	int i = 0;
	//Print top layers
	for (i = 0; i < size; ++i)
	{
		space(size - i);
		if (i == 0)
		{
			//first layer
			print_symbol(size);
		}
		else
		{
			printf("*");
			space(((size - 1) * 2) + i * 2 - 1);
			printf("*");
		}
		printf("\n");
	}
	//Print bottom layers
	for (i = 1; i < size; ++i)
	{
		space(i + 1);
		if (i + 1 == size)
		{
			//last layer
			print_symbol(size);
		}
		else
		{
			printf("*");
			space(((size - 1) * 4) - i * 2 - 1);
			printf("*");
		}
		printf("\n");
	}
}
int main()
{
	//Simple test
	hexagonal_pattern(4);
	hexagonal_pattern(7);
	hexagonal_pattern(9);
	return 0;
}

Output

Size : 4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size : 7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size : 9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
/*
  Java Program
  Print hexagonal star 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++)
  {
    System.out.print("* ");
  }
}
//Print hexagon of given side
public void hexagonal_pattern(int size)
{
  if (size < 2)
  {
    return;
  }
  System.out.print("\nSize : "+size+"\n\n");
  int mid = size / 2;
  int i = 0;
  //Print top layers
  for (i = 0; i < size; ++i)
  {
    space(size - i);
    if (i == 0)
    {
      //first layer
      print_symbol(size);
    }
    else
    {
      System.out.print("*");
      space(((size - 1) * 2) + i * 2 - 1);
      System.out.print("*");
    }
    System.out.print("\n");
  }
  //Print bottom layers
  for (i = 1; i < size; ++i)
  {
    space(i + 1);
    if (i + 1 == size)
    {
      //last layer
      print_symbol(size);
    }
    else
    {
      System.out.print("*");
      space(((size - 1) * 4) - i * 2 - 1);
      System.out.print("*");
    }
    System.out.print("\n");
  }
}
  public static void main(String[] args)
  {
    MyPattern obj = new MyPattern();
 
    //Simple test
    obj.hexagonal_pattern(4);
    obj.hexagonal_pattern(7);
    obj.hexagonal_pattern(9);
  }
}

Output

Size : 4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size : 7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size : 9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
/*
  C++ Program
  Print hexagonal star 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++)
		{
			cout << "* ";
		}
	}
	//Print hexagon of given side
	void hexagonal_pattern(int size)
	{
		if (size < 2)
		{
			return;
		}
		cout << "\nSize : " << size << "\n\n";
		int mid = size / 2;
		int i = 0;
		//Print top layers
		for (i = 0; i < size; ++i)
		{
			this->space(size - i);
			if (i == 0)
			{
				//first layer
				this->print_symbol(size);
			}
			else
			{
				cout << "*";
				this->space(((size - 1) * 2) + i * 2 - 1);
				cout << "*";
			}
			cout << "\n";
		}
		//Print bottom layers
		for (i = 1; i < size; ++i)
		{
			this->space(i + 1);
			if (i + 1 == size)
			{
				//last layer
				this->print_symbol(size);
			}
			else
			{
				cout << "*";
				this->space(((size - 1) * 4) - i * 2 - 1);
				cout << "*";
			}
			cout << "\n";
		}
	}
};
int main()
{
	MyPattern obj = MyPattern();
	//Simple test
	obj.hexagonal_pattern(4);
	obj.hexagonal_pattern(7);
	obj.hexagonal_pattern(9);
	return 0;
}

Output

Size : 4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size : 7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size : 9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
/*
  C# Program
  Print hexagonal star pattern
*/
using System;
class MyPattern
{
	public void space(int size)
	{
		int counter = 0;
		for (counter = 0; counter < size; counter++)
		{
			//Add space
			Console.Write(" ");
		}
	}
	public void print_symbol(int size)
	{
		int counter = 0;
		for (counter = 0; counter < size; counter++)
		{
			Console.Write("* ");
		}
	}
	//Print hexagon of given side
	public void hexagonal_pattern(int size)
	{
		if (size < 2)
		{
			return;
		}
		Console.Write("\nSize : " + size + "\n\n");
		int i = 0;
		//Print top layers
		for (i = 0; i < size; i++)
		{
			space(size - i);
			if (i == 0)
			{
				//first layer
				print_symbol(size);
			}
			else
			{
				Console.Write("*");
				space(((size - 1) * 2) + i * 2 - 1);
				Console.Write("*");
			}
			Console.Write("\n");
		}
		//Print bottom layers
		for (i = 1; i < size; i++)
		{
			space(i + 1);
			if (i + 1 == size)
			{
				//last layer
				print_symbol(size);
			}
			else
			{
				Console.Write("*");
				space(((size - 1) * 4) - i * 2 - 1);
				Console.Write("*");
			}
			Console.Write("\n");
		}
	}
	public static void Main(String[] args)
	{
		MyPattern obj = new MyPattern();
		//Simple test
		obj.hexagonal_pattern(4);
		obj.hexagonal_pattern(7);
		obj.hexagonal_pattern(9);
	}
}

Output

Size : 4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size : 7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size : 9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
<?php
/*
  Php Program
  Print hexagonal star pattern
*/
class MyPattern
{
	public	function space($size)
	{
		$counter = 0;
		for ($counter = 0; $counter < $size; $counter++)
		{
			//Add space
			echo(" ");
		}
	}
	public	function print_symbol($size)
	{
		$counter = 0;
		for ($counter = 0; $counter < $size; $counter++)
		{
			echo("* ");
		}
	}
	//Print hexagon of given side
	public	function hexagonal_pattern($size)
	{
		if ($size < 2)
		{
			return;
		}
		echo("\nSize : ". $size ."\n\n");
		$i = 0;
		//Print top layers
		for ($i = 0; $i < $size; ++$i)
		{
			$this->space($size - $i);
			if ($i == 0)
			{
				//first layer
				$this->print_symbol($size);
			}
			else
			{
				echo("*");
				$this->space((($size - 1) * 2) + $i * 2 - 1);
				echo("*");
			}
			echo("\n");
		}
		//Print bottom layers
		for ($i = 1; $i < $size; ++$i)
		{
			$this->space($i + 1);
			if ($i + 1 == $size)
			{
				//last layer
				$this->print_symbol($size);
			}
			else
			{
				echo("*");
				$this->space((($size - 1) * 4) - $i * 2 - 1);
				echo("*");
			}
			echo("\n");
		}
	}
}

function main()
{
	$obj = new MyPattern();
	//Simple test
	$obj->hexagonal_pattern(4);
	$obj->hexagonal_pattern(7);
	$obj->hexagonal_pattern(9);
}
main();

Output

Size : 4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size : 7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size : 9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
/*
  Node Js Program
  Print hexagonal star pattern
*/
class MyPattern
{
	space(size)
	{
		var counter = 0;
		for (counter = 0; counter < size; counter++)
		{
			//Add space
			process.stdout.write(" ");
		}
	}
	print_symbol(size)
	{
		var counter = 0;
		for (counter = 0; counter < size; counter++)
		{
			process.stdout.write("* ");
		}
	}
	//Print hexagon of given side
	hexagonal_pattern(size)
	{
		if (size < 2)
		{
			return;
		}
		process.stdout.write("\nSize : " + size + "\n\n");
		var i = 0;
		//Print top layers
		for (i = 0; i < size; ++i)
		{
			this.space(size - i);
			if (i == 0)
			{
				//first layer
				this.print_symbol(size);
			}
			else
			{
				process.stdout.write("*");
				this.space(((size - 1) * 2) + i * 2 - 1);
				process.stdout.write("*");
			}
			process.stdout.write("\n");
		}
		//Print bottom layers
		for (i = 1; i < size; ++i)
		{
			this.space(i + 1);
			if (i + 1 == size)
			{
				//last layer
				this.print_symbol(size);
			}
			else
			{
				process.stdout.write("*");
				this.space(((size - 1) * 4) - i * 2 - 1);
				process.stdout.write("*");
			}
			process.stdout.write("\n");
		}
	}
}

function main(args)
{
	var obj = new MyPattern();
	//Simple test
	obj.hexagonal_pattern(4);
	obj.hexagonal_pattern(7);
	obj.hexagonal_pattern(9);
}
main();

Output

Size : 4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size : 7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size : 9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
#   Python 3 Program
#   Print hexagonal star pattern

class MyPattern :
	def space(self, size) :
		counter = 0
		counter = 0
		while (counter < size) :
			print(" ", end = "")
			counter += 1
		
	
	def print_symbol(self, size) :
		counter = 0
		counter = 0
		while (counter < size) :
			print("* ", end = "")
			counter += 1
		
	
	# Print hexagon of given side
	def hexagonal_pattern(self, size) :
		if (size < 2) :
			return
		
		print("\nSize : ", size ,"\n\n", end = "")
		i = 0
		# Print top layers
		i = 0
		while (i < size) :
			self.space(size - i)
			if (i == 0) :
				# first layer
				self.print_symbol(size)
			else :
				print("*", end = "")
				self.space(((size - 1) * 2) + i * 2 - 1)
				print("*", end = "")
			
			print("\n", end = "")
			i += 1
		
		# Print bottom layers
		i = 1
		while (i < size) :
			self.space(i + 1)
			if (i + 1 == size) :
				# last layer
				self.print_symbol(size)
			else :
				print("*", end = "")
				self.space(((size - 1) * 4) - i * 2 - 1)
				print("*", end = "")
			
			print("\n", end = "")
			i += 1
		
	

def main() :
	obj = MyPattern()
	# Simple test
	obj.hexagonal_pattern(4)
	obj.hexagonal_pattern(7)
	obj.hexagonal_pattern(9)


if __name__ == "__main__": main()

Output

Size :  4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size :  7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size :  9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
# Ruby Program
# Print hexagonal star pattern

class MyPattern

	def space(size)
	
		counter = 0
		counter = 0
		while (counter < size)
		
			print(" ")
			counter += 1
		end
	end
	def print_symbol(size)
	
		counter = 0
		counter = 0
		while (counter < size)
		
			print("* ")
			counter += 1
		end
	end
	# Print hexagon of given side
	def hexagonal_pattern(size)
	
		if (size < 2)
		
			return
		end
		print("\nSize : ", size ,"\n\n")
		i = 0
		# Print top layers
		i = 0
		while (i < size)
		
			self.space(size - i)
			if (i == 0)
			
				# first layer
				self.print_symbol(size)
			else
			
				print("*")
				self.space(((size - 1) * 2) + i * 2 - 1)
				print("*")
			end
			print("\n")
			i += 1
		end
		# Print bottom layers
		i = 1
		while (i < size)
		
			self.space(i + 1)
			if (i + 1 == size)
			
				# last layer
				self.print_symbol(size)
			else
			
				print("*")
				self.space(((size - 1) * 4) - i * 2 - 1)
				print("*")
			end
			print("\n")
			i += 1
		end
	end
end
def main()

	obj = MyPattern.new()
	# Simple test
	obj.hexagonal_pattern(4)
	obj.hexagonal_pattern(7)
	obj.hexagonal_pattern(9)
end
main()

Output

Size : 4

    * * * * 
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * * 

Size : 7

       * * * * * * * 
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * * 

Size : 9

         * * * * * * * * * 
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * * 

/*
  Scala Program
  Print hexagonal star pattern
*/
class MyPattern
{
	def space(size: Int): Unit = {
		var counter: Int = 0;
		while (counter < size)
		{
			print(" ");
			counter += 1;
		}
	}
	def print_symbol(size: Int): Unit = {
		var counter: Int = 0;
		while (counter < size)
		{
			print("* ");
			counter += 1;
		}
	}
	//Print hexagon of given side
	def hexagonal_pattern(size: Int): Unit = {
		if (size < 2)
		{
			return;
		}
		print("\nSize : " + size + "\n\n");
		var i: Int = 0;
		//Print top layers
		i = 0;
		while (i < size)
		{
			space(size - i);
			if (i == 0)
			{
				//first layer
				print_symbol(size);
			}
			else
			{
				print("*");
				space(((size - 1) * 2) + i * 2 - 1);
				print("*");
			}
			print("\n");
			i += 1;
		}
		//Print bottom layers
		i = 1;
		while (i < size)
		{
			space(i + 1);
			if (i + 1 == size)
			{
				//last layer
				print_symbol(size);
			}
			else
			{
				print("*");
				space(((size - 1) * 4) - i * 2 - 1);
				print("*");
			}
			print("\n");
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var obj: MyPattern = new MyPattern();
		//Simple test
		obj.hexagonal_pattern(4);
		obj.hexagonal_pattern(7);
		obj.hexagonal_pattern(9);
	}
}

Output

Size : 4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size : 7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size : 9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *
/*
  Swift Program
  Print hexagonal star 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)
		{
			print("* ", terminator: "");
			counter += 1;
		}
	}
	//Print hexagon of given side
	func hexagonal_pattern(_ size: Int)
	{
		if (size < 2)
		{
			return;
		}
		print("\nSize : ", size ,"\n\n", terminator: "");
		var i: Int = 0;
		//Print top layers
		i = 0;
		while (i < size)
		{
			self.space(size - i);
			if (i == 0)
			{
				//first layer
				self.print_symbol(size);
			}
			else
			{
				print("*", terminator: "");
				self.space(((size - 1) * 2) + i * 2 - 1);
				print("*", terminator: "");
			}
			print("\n", terminator: "");
			i += 1;
		}
		//Print bottom layers
		i = 1;
		while (i < size)
		{
			self.space(i + 1);
			if (i + 1 == size)
			{
				//last layer
				self.print_symbol(size);
			}
			else
			{
				print("*", terminator: "");
				self.space(((size - 1) * 4) - i * 2 - 1);
				print("*", terminator: "");
			}
			print("\n", terminator: "");
			i += 1;
		}
	}
}
func main()
{
	let obj: MyPattern = MyPattern();
	//Simple test
	obj.hexagonal_pattern(4);
	obj.hexagonal_pattern(7);
	obj.hexagonal_pattern(9);
}
main();

Output

Size :  4

    * * * *
   *       *
  *         *
 *           *
  *         *
   *       *
    * * * *

Size :  7

       * * * * * * *
      *             *
     *               *
    *                 *
   *                   *
  *                     *
 *                       *
  *                     *
   *                   *
    *                 *
     *               *
      *             *
       * * * * * * *

Size :  9

         * * * * * * * * *
        *                 *
       *                   *
      *                     *
     *                       *
    *                         *
   *                           *
  *                             *
 *                               *
  *                             *
   *                           *
    *                         *
     *                       *
      *                     *
       *                   *
        *                 *
         * * * * * * * * *

Time Complexity Analysis

The time complexity of the provided code depends on the size of the hexagon (input) and can be analyzed as follows:

  • The space function and the print_symbol function both have a time complexity of O(size) since they involve looping based on the given size.
  • The hexagonal_pattern function has two nested loops. The first loop iterates from 0 to size, and the second loop iterates from 1 to size. Therefore, the overall time complexity of the function is O(size^2).
  • The main function calls the hexagonal_pattern function multiple times, but each call is independent of the size. Hence, the time complexity of the main function can be considered as O(1).

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





Categories
Relative Post