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++) {

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

int counter = 0;

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

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++) {

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

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++) {

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

int counter = 0;

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

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++) {

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

public 	function print_star(\$size) {
\$counter = 0;
for (\$counter = 0; \$counter < \$size; \$counter++) {

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++) {

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

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

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.

Categories
Relative Post