Skip to main content

Print H pattern

Here given code implementation process.

//C Program 
//Display H patterns
#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(" ");
  }
}

void print_symbol(int size) {
  int counter = 0;
  for (counter = 0; counter < size; counter++) {
    printf("━");
  }
}
//Display H pattern of given odd size
void h_pattern(int size) {
  if(size<0 || size%2==0)
  {
    return;
  }
  
  printf("\n  Size : %d \n\n", size);
  
  int i=0;

  for(i=0;i<size;i++){
    space(2);
    printf("┃");
    
    if(i==(size/2)  )
    {
      print_symbol(size);
    }
    else
    {
      space(size);
    }
    printf("┃");
    printf("\n");
  } 
 
}


int main() {
  //Test Cases
  h_pattern(3);
  h_pattern(5);
  h_pattern(7);
  return 0;
}

Output

  Size : 3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

  Size : 5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

  Size : 7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
/*
  C++ Program
  Display H patterns
*/
#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 << " ";
      }
    }
	void print_symbol(int size) {
		int counter = 0;
		for (counter = 0; counter < size; counter++) {
			cout << "━";
		}
	}
	//Display H pattern of given odd size
	void h_pattern(int size) {
		if (size < 0 ||
			size % 2 == 0) {
			return;
		}
		cout << "\n Size : " << size << " \n\n";
		int i = 0;
		for (i = 0; i < size; i++) {
			this->space(2);
			cout << "┃";
			if (i == (size / 2)) {
				this->print_symbol(size);
			} else {
				this->space(size);
			}
			cout << "┃";
			cout << "\n";
		}
	}
};
int main() {
	MyPattern obj =  MyPattern();
	//Test Cases
	obj.h_pattern(3);
	obj.h_pattern(5);
	obj.h_pattern(7);
	return 0;
}

Output

 Size : 3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size : 5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size : 7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
/*
  Java Program
  Display H patterns
*/

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(" ");
    }
  }

  void print_symbol(int size) {
    int counter = 0;
    for (counter = 0; counter < size; counter++) {
      System.out.print("━");
    }
  }
  //Display H pattern of given odd size
  void h_pattern(int size) {
    if(size<0 || size%2==0)
    {
      return;
    }
    
    System.out.print("\n  Size : "+size+" \n\n");
    
    int i=0;

    for(i=0;i<size;i++){
      space(2);
      System.out.print("┃");
      
      if(i==(size/2))
      {
        print_symbol(size);
      }
      else
      {
        space(size);
      }
      System.out.print("┃");
      System.out.print("\n");
    } 
  }

  public static void main(String[] args) {

    MyPattern obj = new MyPattern();
    //Test Cases
    obj.h_pattern(3);
    obj.h_pattern(5);
    obj.h_pattern(7);
  }
}

Output

 Size : 3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size : 5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size : 7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
/*
  C# Program
  Display H patterns
*/
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(" ");
		}
	}
	void print_symbol(int size) {
		int counter = 0;
		for (counter = 0; counter < size; counter++) {
			Console.Write("━");
		}
	}
	//Display H pattern of given odd size
	void h_pattern(int size) {
		if (size < 0 ||
			size % 2 == 0) {
			return;
		}
		Console.Write("\n Size : " + size + " \n\n");
		int i = 0;
		for (i = 0; i < size; i++) {
			space(2);
			Console.Write("┃");
			if (i == (size / 2)) {
				print_symbol(size);
			} else {
				space(size);
			}
			Console.Write("┃");
			Console.Write("\n");
		}
	}
	public static void Main(String[] args) {
		MyPattern obj = new MyPattern();
		obj.h_pattern(3);
		obj.h_pattern(5);
		obj.h_pattern(7);
	}
}

Output

 Size : 3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size : 5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size : 7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
<?php
/*
  Php Program
  Display H patterns
*/
class MyPattern {
	/*Include Space of given size*/

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

			echo(" ");
		}
	}

	function print_symbol($size) {
		$counter = 0;
		for ($counter = 0; $counter < $size; $counter++) {
			echo("━");
		}
	}
	//Display H pattern of given odd size
	function h_pattern($size) {
		if ($size < 0 ||
			$size % 2 == 0) {
			return;
		}
		echo("\n Size : ". $size ." \n\n");
		$i = 0;
		for ($i = 0; $i < $size; $i++) {
			$this->space(2);
			echo("┃");
			if ($i == (intval($size / 2))) {
				$this->print_symbol($size);
			} else {
				$this->space($size);
			}
			echo("┃");
			echo("\n");
		}
	}
}

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

	$obj->h_pattern(3);
	$obj->h_pattern(5);
	$obj->h_pattern(7);

}
main();

Output

 Size : 3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size : 5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size : 7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
/*
  Node Js Program
  Display H patterns
*/
class MyPattern {
	/*Include Space of given size*/
	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("━");
		}
	}

	//Display H pattern of given odd size
	h_pattern(size) {
		if (size < 0 ||
			size % 2 == 0) {
			return;
		}

		process.stdout.write("\n Size : " + size + " \n\n");
		var i = 0;
		for (i = 0; i < size; i++) {
			this.space(2);
			process.stdout.write("┃");
			if (i == (parseInt(size / 2))) {
				this.print_symbol(size);
			} else {
				this.space(size);
			}

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

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

main();

Output

 Size : 3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size : 5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size : 7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
#   Python 3 Program
#   Display H patterns

class MyPattern :
	# Include Space of given size
	def space(self, size) :
		counter = 0
		while (counter < size) :
			print(" ", end = "")
			counter += 1
		
	
	def print_symbol(self, size) :
		counter = 0
		while (counter < size) :
			print("━", end = "")
			counter += 1
		
	
	def h_pattern(self, size) :
		if (size < 0 or size % 2 == 0) :
			return
		
		print("\n Size : ", size ," \n\n", end = "")
		i = 0
		while (i < size) :
			self.space(2)
			print("┃", end = "")
			if (i == (int(size / 2))) :
				self.print_symbol(size)
			else :
				self.space(size)
			
			print("┃", end = "")
			print("\n", end = "")
			i += 1
		
	

def main() :
	obj = MyPattern()
	obj.h_pattern(3)
	obj.h_pattern(5)
	obj.h_pattern(7)


if __name__ == "__main__":
	main()

Output

 Size :  3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size :  5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size :  7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
#   Ruby Program
#   Display H patterns

class MyPattern 
	# Include Space of given size
	def space(size) 
		counter = 0
		while (counter < size) 
			print(" ")
			counter += 1
		end
	end
	def print_symbol(size) 
		counter = 0
		while (counter < size) 
			print("━")
			counter += 1
		end
	end
	def h_pattern(size) 
		if (size < 0 ||
			size % 2 == 0) 
			return
		end
		print("\n Size  :", size ," \n\n")
		i = 0
		while (i < size) 
			self.space(2)
			print("┃")
			if (i == (size / 2)) 
				self.print_symbol(size)
			else 
				self.space(size)
			end
			print("┃")
			print("\n")
			i += 1
		end
	end
end
def main() 
	obj = MyPattern.new()
	obj.h_pattern(3)
	obj.h_pattern(5)
	obj.h_pattern(7)
end
main()

Output

 Size  :3 

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size  :5 

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size  :7 

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃

/*
  Scala Program
  Display H patterns
*/
class MyPattern {
	/*Include Space of given size*/
	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;
		}
	}
	def h_pattern(size: Int): Unit = {
		if (size < 0 ||
			size % 2 == 0) {
			return;
		}
		print("\n Size : " + size + " \n\n");
		var i: Int = 0;
		while (i < size) {
			this.space(2);
			print("┃");

			if (i == ((size / 2).toInt)) {
				this.print_symbol(size);
			} else {
				this.space(size);
			}
			print("┃");
			print("\n");
			i += 1;
		}
	}
}
object Main {
	def main(args: Array[String]): Unit = {
		val obj: MyPattern = new MyPattern();
		obj.h_pattern(3);
		obj.h_pattern(5);
		obj.h_pattern(7);
	}
}

Output

 Size : 3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size : 5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size : 7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
/*
  Swift Program
  Display H patterns
*/
class MyPattern {
	/*Include Space of given size*/
	func space(_ size: Int) {
		var counter = 0;
		while (counter < size) {
			print(" ", terminator: "");
			counter += 1;
		}
	}
	func print_symbol(_ size: Int) {
		var counter = 0;
		while (counter < size) {
			print("━", terminator: "");
			counter += 1;
		}
	}
	func h_pattern(_ size: Int) {
		if (size < 0 ||
			size % 2 == 0) {
			return;
		}
		print("\n Size : ", size ," \n\n", terminator: "");
		var i = 0;
		while (i < size) {
			self.space(2);
			print("┃", terminator: "");
			if (i == (size / 2)) {
				self.print_symbol(size);
			} else {
				self.space(size);
			}
			print("┃", terminator: "");
			print("\n", terminator: "");
			i += 1;
		}
	}
}
func main() {
	let obj = MyPattern();
	obj.h_pattern(3);
	obj.h_pattern(5);
	obj.h_pattern(7);
}
main();

Output

 Size :  3

  ┃   ┃
  ┃━━━┃
  ┃   ┃

 Size :  5

  ┃     ┃
  ┃     ┃
  ┃━━━━━┃
  ┃     ┃
  ┃     ┃

 Size :  7

  ┃       ┃
  ┃       ┃
  ┃       ┃
  ┃━━━━━━━┃
  ┃       ┃
  ┃       ┃
  ┃       ┃
Last updated on by Kalkicode




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