Posted on by Kalkicode
Code Pattern

Display Hut Star Pattern

The "Display Hut Star Pattern" program is a C program that generates a hut-shaped pattern using stars (*). The program takes an input size and prints the corresponding hut pattern based on that size.

Problem Statement

The problem is to create a hut star pattern using asterisks. The pattern consists of a top shell, a bottom shell, and a base. The size of the pattern determines the number of rows and columns in the pattern.

For example, if the input size is 5, the pattern will be:

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

The hut pattern has a top shell that forms an inverted pyramid of stars, a bottom shell that forms a pyramid of stars, and a base that consists of three rows of stars with empty spaces in the middle.

Algorithm and Pseudocode

1. Start the main function.

2. Define the function space to print spaces. It takes an input size and prints spaces equal to the given size.

3. Define the function print_star to print stars. It takes an input size and prints stars equal to the given size.

4. Define the function hut_star_pattern to generate the hut pattern. It takes an input size and follows the following steps:

  • a. Print the size of the pattern.
  • b. Use a loop to print the top shell of the hut pattern. The loop iterates from 0 to size-1.
  • c. Inside the loop, call the space function to print the required number of spaces.
  • d. Call the print_star function to print the required number of stars.
  • e. Print a newline character to move to the next line.
  • f. Use a loop to print the bottom shell of the hut pattern. The loop iterates 3 times.
  • g. Inside the loop, use another loop to print each line of the bottom shell.
  • h. Check the conditions to print stars or spaces based on the position.
  • i. Print a newline character to move to the next line.

5. In the main function, call the hut_star_pattern function with different test cases.

6. End the main function.

Code Solution

Here given code implementation process.

//C Program 
//Display Hut Star pattern
#include <stdio.h>
#include <stdlib.h>

//Include Space of given size
void space(int size) {

  int counter = 0;

  for (counter = 0; counter < size; counter++) {

    //Add space
    printf(" ");
  }
}
//Include star of given size
void print_star(int size) {

  int counter = 0;

  for (counter = 0; counter < size; counter++) {

    //Add space
    printf("*");
  }
}

//Display the hut star pattern of given size
void hut_star_pattern(int size) {

  
  printf("\n Size : %d \n\n", size);
  int i = 0;
  int j = 0; 
 
  //Display top shell of result
  for (i = 0; i < size; i++) {
    space(size-i-1);
    print_star((i+i)+1);
    printf("\n");
  }
  //print the bottom shell of result
  for (int k = 0; k < 3; ++k)
  {
    for (j = 0; j < size+size-1; j++) {

      if(j<=2 || j>=(size+size-1)-3)
      {
        printf("*");
      }
      else
      {
        printf(" ");
      }
    }
    printf("\n");
  }
}


int main() {
  //Test Cases
  hut_star_pattern(5);
  hut_star_pattern(4);
  hut_star_pattern(7);
  return 0;
}

Output

 Size : 5

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

 Size : 4

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

 Size : 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
/*
  C++ Program
  Display hut star pattern
*/
#include<iostream>

using namespace std;
class MyPattern {
	public:

    //Include Space of given size
    void space(int size) {
      int counter = 0;
      for (counter = 0; counter < size; counter++) {
        //Add space

        cout << " ";
      }
    }
	//Include star of given size
	void print_star(int size) {
		int counter = 0;
		for (counter = 0; counter < size; counter++) {
			//Add space

			cout << "*";
		}
	}
	//Display the hut star pattern of given size
	void hut_star_pattern(int size) {
		cout << "\n Size : " << size << " \n\n";
		int i = 0;
		int j = 0;
		//Display top shell of result

		for (i = 0; i < size; i++) {
			this->space(size - i - 1);
			this->print_star((i + i) + 1);
			cout << "\n";
		}
		//print the bottom shell of result

		for (int k = 0; k < 3; ++k) {
			for (j = 0; j < size + size - 1; j++) {
				if (j <= 2 ||
					j >= (size + size - 1) - 3) {
					cout << "*";
				} else {
					cout << " ";
				}
			}
			cout << "\n";
		}
	}
};
int main() {
	MyPattern obj =  MyPattern();
	//Test Cases
	obj.hut_star_pattern(5);
	obj.hut_star_pattern(4);
	obj.hut_star_pattern(7);
	return 0;
}

Output

 Size : 5

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

 Size : 4

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

 Size : 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
/*
  Java Program
  Display hut star pattern
*/

public class MyPattern {

  //Include Space of given size
  public void space(int size) {

    int counter = 0;

    for (counter = 0; counter < size; counter++) {

      //Add space
      System.out.print(" ");
    }
  }
  //Include star of given size
  public void print_star(int size) {

    int counter = 0;

    for (counter = 0; counter < size; counter++) {

      //Add space
      System.out.print("*");
    }
  }

  //Display the hut star pattern of given size
  public void hut_star_pattern(int size) {

    
    System.out.print("\n Size : "+size+" \n\n");
    int i = 0;
    int j = 0; 
   
    //Display top shell of result
    for (i = 0; i < size; i++) {
      space(size-i-1);
      print_star((i+i)+1);
      System.out.print("\n");
    }
    //print the bottom shell of result
    for (int k = 0; k < 3; ++k)
    {
      for (j = 0; j < size+size-1; j++) {

        if(j<=2 || j>=(size+size-1)-3)
        {
          System.out.print("*");
        }
        else
        {
          System.out.print(" ");
        }
      }
      System.out.print("\n");
    }
  }
  public static void main(String[] args) {

    MyPattern obj = new MyPattern();
    //Test Cases
    obj.hut_star_pattern(5);
    obj.hut_star_pattern(4);
    obj.hut_star_pattern(7);
  }
}

Output

 Size : 5

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

 Size : 4

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

 Size : 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
/*
  C# Program
  Display hut star pattern
*/
using System;

public class MyPattern {
	//Include Space of given size
	public void space(int size) {
		int counter = 0;
		for (counter = 0; counter < size; counter++) {
			Console.Write(" ");
		}
	}
	//Include star of given size
	public void print_star(int size) {
		int counter = 0;
		for (counter = 0; counter < size; counter++) {
			Console.Write("*");
		}
	}
	//Display the hut star pattern of given size
	public void hut_star_pattern(int size) {
		Console.Write("\n Size : " + size + " \n\n");
		int i = 0;
		int j = 0;
		//Display top shell of result

		for (i = 0; i < size; i++) {
			space(size - i - 1);
			print_star((i + i) + 1);
			Console.Write("\n");
		}
		//print the bottom shell of result

		for (int k = 0; k < 3; ++k) {
			for (j = 0; j < size + size - 1; j++) {
				if (j <= 2 ||
					j >= (size + size - 1) - 3) {
					Console.Write("*");
				} else {
					Console.Write(" ");
				}
			}
			Console.Write("\n");
		}
	}
	public static void Main(String[] args) {
		MyPattern obj = new MyPattern();
		obj.hut_star_pattern(5);
		obj.hut_star_pattern(4);
		obj.hut_star_pattern(7);
	}
}

Output

 Size : 5

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

 Size : 4

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

 Size : 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
<?php
/*
  Php Program
  Display hut star pattern
*/
class MyPattern {
	//Include Space of given size

	public 	function space($size) {
		$counter = 0;
		for ($counter = 0; $counter < $size; $counter++) {
			//Add space

			echo(" ");
		}
	}
	//Include star of given size

	public 	function print_star($size) {
		$counter = 0;
		for ($counter = 0; $counter < $size; $counter++) {
			//Add space

			echo("*");
		}
	}
	//Display the hut star pattern of given size

	public 	function hut_star_pattern($size) {
		echo("\n Size : ". $size ." \n\n");
		$i = 0;
		$j = 0;
		//Display top shell of result

		for ($i = 0; $i < $size; $i++) {
			$this->space($size - $i - 1);
			$this->print_star(($i + $i) + 1);
			echo("\n");
		}
		//print the bottom shell of result

		for ($k = 0; $k < 3; ++$k) {
			for ($j = 0; $j < $size + $size - 1; $j++) {
				if ($j <= 2 ||
					$j >= ($size + $size - 1) - 3) {
					echo("*");
				} else {
					echo(" ");
				}
			}
			echo("\n");
		}
	}
}

function main() {
	$obj = new MyPattern();
	//Test Cases

	$obj->hut_star_pattern(5);
	$obj->hut_star_pattern(4);
	$obj->hut_star_pattern(7);

}
main();

Output

 Size : 5

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

 Size : 4

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

 Size : 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
/*
  Node Js Program
  Display hut star pattern
*/
class MyPattern {
	//Include Space of given size
	space(size) {
		var counter = 0;
		for (counter = 0; counter < size; counter++) {
			//Add space

			process.stdout.write(" ");
		}
	}

	//Include star of given size
	print_star(size) {
		var counter = 0;
		for (counter = 0; counter < size; counter++) {
			//Add space

			process.stdout.write("*");
		}
	}

	//Display the hut star pattern of given size
	hut_star_pattern(size) {
		process.stdout.write("\n Size : " + size + " \n\n");
		var i = 0;
		var j = 0;
		//Display top shell of result

		for (i = 0; i < size; i++) {
			this.space(size - i - 1);
			this.print_star((i + i) + 1);
			process.stdout.write("\n");
		}

		//print the bottom shell of result

		for (var k = 0; k < 3; ++k) {
			for (j = 0; j < size + size - 1; j++) {
				if (j <= 2 ||
					j >= (size + size - 1) - 3) {
					process.stdout.write("*");
				} else {
					process.stdout.write(" ");
				}
			}

			process.stdout.write("\n");
		}
	}
}

function main(args) {
	var obj = new MyPattern();
	//Test Cases
	obj.hut_star_pattern(5);
	obj.hut_star_pattern(4);
	obj.hut_star_pattern(7);
}

main();

Output

 Size : 5

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

 Size : 4

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

 Size : 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
# Python 3 Program
# Display hut star pattern

class MyPattern :
	# Include Space of given size
	def space(self, size) :
		counter = 0
		while (counter < size) :
			print(" ", end = "")
			counter += 1
		
	
	# Include star of given size
	def print_star(self, size) :
		counter = 0
		while (counter < size) :
			print("*", end = "")
			counter += 1
		
	
	# Display the hut star pattern of given size
	def hut_star_pattern(self, size) :
		print("\n Size : ", size ," \n\n", end = "")
		i = 0
		j = 0
		# Display top shell of result
		while (i < size) :
			self.space(size - i - 1)
			self.print_star((i + i) + 1)
			print("\n", end = "")
			i += 1
		
		# print the bottom shell of result
		k = 0
		while (k < 3) :
			j = 0
			while (j < size + size - 1) :
				if (j <= 2 or j >= (size + size - 1) - 3) :
					print("*", end = "")
				else :
					print(" ", end = "")
				
				j += 1
			
			print("\n", end = "")
			k += 1
		
	

def main() :
	obj = MyPattern()
	obj.hut_star_pattern(5)
	obj.hut_star_pattern(4)
	obj.hut_star_pattern(7)


if __name__ == "__main__":
	main()

Output

 Size :  5

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

 Size :  4

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

 Size :  7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
#   Ruby Program
#   Display hut star pattern

class MyPattern 
	 # Include Space of given size
	def space(size) 
		counter = 0
		while (counter < size) 
			print(" ")
			counter += 1
		end
	end
	 # Include star of given size
	def print_star(size) 
		counter = 0
		while (counter < size) 
			print("*")
			counter += 1
		end
	end
	 # Display the hut star pattern of given size
	def hut_star_pattern(size) 
		print("\n Size  :", size ," \n\n")
		i = 0
		j = 0
		 # Display top shell of result
		while (i < size) 
			self.space(size - i - 1)
			self.print_star((i + i) + 1)
			print("\n")
			i += 1
		end
		 # print the bottom shell of result
		k = 0
		while (k < 3) 
			j = 0
			while (j < size + size - 1) 
				if (j <= 2 ||
					j >= (size + size - 1) - 3) 
					print("*")
				else 
					print(" ")
				end
				j += 1
			end
			print("\n")
			k += 1
		end
	end
end
def main() 
	obj = MyPattern.new()
	obj.hut_star_pattern(5)
	obj.hut_star_pattern(4)
	obj.hut_star_pattern(7)
end
main()

Output

 Size  :5 

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

 Size  :4 

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

 Size  :7 

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
/*
  Scala Program
  Display hut star pattern
*/
class MyPattern {
	//Include Space of given size
	def space(size: Int): Unit = {
		var counter: Int = 0;
		while (counter < size) {
			print(" ");
			counter += 1;
		}
	}
	//Include star of given size
	def print_star(size: Int): Unit = {
		var counter: Int = 0;
		while (counter < size) {
			print("*");
			counter += 1;
		}
	}
	//Display the hut star pattern of given size
	def hut_star_pattern(size: Int): Unit = {
		print("\n Size : " + size + " \n\n");
		var i: Int = 0;
		var j: Int = 0;

		//Display top shell of result
		while (i < size) {
			this.space(size - i - 1);
			this.print_star((i + i) + 1);
			print("\n");
			i += 1;
		}
		//print the bottom shell of result
		var k: Int = 0;
		while (k < 3) {
			j = 0;
			while (j < size + size - 1) {
				if (j <= 2 ||
					j >= (size + size - 1) - 3) {
					print("*");
				} else {
					print(" ");
				}
				j += 1;
			}
			print("\n");
			k += 1;
		}
	}
}
object Main {
	def main(args: Array[String]): Unit = {
		val obj: MyPattern = new MyPattern();
		obj.hut_star_pattern(5);
		obj.hut_star_pattern(4);
		obj.hut_star_pattern(7);
	}
}

Output

 Size : 5

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

 Size : 4

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

 Size : 7

      *
     ***
    *****
   *******
  *********
 ***********
*************
***       ***
***       ***
***       ***
/*
  Swift Program
  Display hut star pattern
*/
class MyPattern {
	//Include Space of given size
	func space(_ size: Int) {
		var counter = 0;
		while (counter < size) {
			print(" ", terminator: "");
			counter += 1;
		}
	}
	//Include star of given size
	func print_star(_ size: Int) {
		var counter = 0;
		while (counter < size) {
			print("*", terminator: "");
			counter += 1;
		}
	}
	//Display the hut star pattern of given size
	func hut_star_pattern(_ size: Int) {
		print("\n Size : ", size ," \n\n", terminator: "");
		var i = 0;
		var j = 0;
		//Display top shell of result
		while (i < size) {
			self.space(size - i - 1);
			self.print_star((i + i) + 1);
			print("\n", terminator: "");
			i += 1;
		}
		//print the bottom shell of result
		var k = 0;
		while (k < 3) {
			j = 0;
			while (j < size + size - 1) {
				if (j <= 2 ||
					j >= (size + size - 1) - 3) {
					print("*", terminator: "");
				} else {
					print(" ", terminator: "");
				}
				j += 1;
			}
			print("\n", terminator: "");
			k += 1;
		}
	}
}
func main() {
	let obj = MyPattern();
	obj.hut_star_pattern(5);
	obj.hut_star_pattern(4);
	obj.hut_star_pattern(7);
}
main();

Output

 Size :  5

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

 Size :  4

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

 Size :  7

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

Time Complexity

The time complexity of the program is O(n^2), where n is the input size. The program uses nested loops to print the pattern, with the outer loop running size times and the inner loop running (size+size-1) times. Therefore, the time complexity is quadratic.

Output Explanation

The program generates the hut star pattern for different input sizes. The output is displayed with the corresponding size mentioned at the top.

For example, when the size is 5, the pattern is:

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

Here, the top shell has a base of 5 stars, and each subsequent row has two additional stars. The bottom shell has three rows with a base of 7 stars. The base has three rows with three stars and three spaces in between.

Similarly, the program generates patterns for input sizes 4 and 7, and displays them along with the respective sizes.

The generated patterns follow the algorithm described earlier and create the hut-shaped star pattern with the given sizes.

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