Skip to main content

Display Staircase Pattern

Here given code implementation process.

// C Program 
// Display Staircase Pattern
#include <stdio.h>

// We will use this symbol (▒,▅,▃,▓)
void display_symbols(int size)
{
	for (int i = 0; i < size; ++i)
	{
		printf("▓");
	}
}
//Displaying of Staircase in given size
void staircase_pattern(int size)
{
	if (size <= 0)
	{
		// When get a invalid size
		return;
	}
	// Display size of Staircase
	printf("\n Size : %d\n ", size);
	for (int i = 0; i <= size; ++i)
	{
		display_symbols(i + i);
		//include new line
		printf("\n ");
	}
}
int main()
{
	//Test Cases
	staircase_pattern(8);
	staircase_pattern(12);
	staircase_pattern(3);
	return 0;
}

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

/*
    Java program 
    Display Staircase Pattern

*/
class StaircasePattern
{
	// We will use this symbol (▒,▅,▃,▓)
	public void display_symbols(int size)
	{
		for (int i = 0; i < size; ++i)
		{
			System.out.print("▓");
		}
	}
	//Displaying of Staircase in given size
	public void staircase_pattern(int size)
	{
		if (size <= 0)
		{
			// When get a invalid size
			return;
		}
		// Display size of Staircase
		System.out.print("\n Size : " + size + "\n ");
		for (int i = 0; i <= size; ++i)
		{
			display_symbols(i + i);
			//include new line
			System.out.print("\n ");
		}
	}
	public static void main(String[] args)
	{
		StaircasePattern pattern = new StaircasePattern();
		//Test Cases
		pattern.staircase_pattern(8);
		pattern.staircase_pattern(12);
		pattern.staircase_pattern(3);
	}
}

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

// Include header file
#include <iostream>
using namespace std;

/*
    C++ program 
    Display Staircase Pattern
*/

class StaircasePattern
{
	public:
		//  We will use this symbol (▒,▅,▃,▓)
		void display_symbols(int size)
		{
			for (int i = 0; i < size; ++i)
			{
				cout << "▓";
			}
		}
	// Displaying of Staircase in given size
	void staircase_pattern(int size)
	{
		//  When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		cout << "\n Size : " << size << "\n ";
		for (int i = 0; i <= size; ++i)
		{
			this->display_symbols(i + i);
			// include new line
			cout << "\n ";
		}
	}
};
int main()
{
	StaircasePattern pattern = StaircasePattern();
	// Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
	return 0;
}

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

// Include namespace system
using System;

/*
    C# program 
    Display Staircase Pattern

*/

public class StaircasePattern
{
	//  We will use this symbol (▒,▅,▃,▓)
	public void display_symbols(int size)
	{
		for (int i = 0; i < size; ++i)
		{
			Console.Write("▓");
		}
	}
	// Displaying of Staircase in given size
	public void staircase_pattern(int size)
	{
		//  When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		Console.Write("\n Size : " + size + "\n ");
		for (int i = 0; i <= size; ++i)
		{
			display_symbols(i + i);
			// include new line
			Console.Write("\n ");
		}
	}
	public static void Main(String[] args)
	{
		StaircasePattern pattern = new StaircasePattern();
		// Test Cases
		pattern.staircase_pattern(8);
		pattern.staircase_pattern(12);
		pattern.staircase_pattern(3);
	}
}

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

<?php
/*
    Php program 
    Display Staircase Pattern

*/
class StaircasePattern
{
	//  We will use this symbol (▒,▅,▃,▓)
	public	function display_symbols($size)
	{
		for ($i = 0; $i < $size; ++$i)
		{
			echo "▓";
		}
	}
	// Displaying of Staircase in given size
	public	function staircase_pattern($size)
	{
		//  When get a invalid size
		if ($size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		echo "\n Size : ". $size ."\n ";
		for ($i = 0; $i <= $size; ++$i)
		{
			$this->display_symbols($i + $i);
			// include new line
			echo "\n ";
		}
	}
}

function main()
{
	$pattern = new StaircasePattern();
	// Test Cases
	$pattern->staircase_pattern(8);
	$pattern->staircase_pattern(12);
	$pattern->staircase_pattern(3);
}
main();

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

/*
    Node Js program 
    Display Staircase Pattern
*/
class StaircasePattern
{
	//  We will use this symbol (▒,▅,▃,▓)
	display_symbols(size)
	{
		for (var i = 0; i < size; ++i)
		{
			process.stdout.write("▓");
		}
	}
	// Displaying of Staircase in given size
	staircase_pattern(size)
	{
		//  When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		process.stdout.write("\n Size : " + size + "\n ");
		for (var i = 0; i <= size; ++i)
		{
			this.display_symbols(i + i);
			// include new line
			process.stdout.write("\n ");
		}
	}
}

function main()
{
	var pattern = new StaircasePattern();
	// Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
}
main();

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

#  Python 3 program 
#  Display Staircase Pattern

class StaircasePattern :
	# We will use this symbol (▒,▅,▃,▓)
	def display_symbols(self, size) :
		i = 0
		while (i < size) :
			print("▓", end = "")
			i += 1
		
	
	#  Displaying of Staircase in given size
	def staircase_pattern(self, size) :
		# When get a invalid size
		if (size <= 0) :
			return
		
		#   Display size of Staircase
		print("\n Size : ", size ,"\n ", end = "")
		i = 0
		while (i <= size) :
			self.display_symbols(i + i)
			#  include new line
			print("\n ", end = "")
			i += 1
		
	

def main() :
	pattern = StaircasePattern()
	#  Test Cases
	pattern.staircase_pattern(8)
	pattern.staircase_pattern(12)
	pattern.staircase_pattern(3)

if __name__ == "__main__": main()

Output

 Size :  8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size :  12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size :  3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

#  Ruby program 
#  Display Staircase Pattern

class StaircasePattern 
	#   We will use this symbol (▒,▅,▃,▓)
	def display_symbols(size) 
		i = 0
		while (i < size) 
			print("▓")
			i += 1
		end

	end

	#  Displaying of Staircase in given size
	def staircase_pattern(size) 
		#   When get a invalid size
		if (size <= 0) 
			return
		end

		#   Display size of Staircase
		print("\n Size : ", size ,"\n ")
		i = 0
		while (i <= size) 
			self.display_symbols(i + i)
			#  include new line
			print("\n ")
			i += 1
		end

	end

end

def main() 
	pattern = StaircasePattern.new()
	#  Test Cases
	pattern.staircase_pattern(8)
	pattern.staircase_pattern(12)
	pattern.staircase_pattern(3)
end

main()

Output

 Size : 8
 
 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 
 Size : 12
 
 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 
 Size : 3
 
 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 
/*
    Scala program 
    Display Staircase Pattern

*/
class StaircasePattern
{
	//   We will use this symbol (▒,▅,▃,▓)
	def display_symbols(size: Int): Unit = {
		var i: Int = 0;
		while (i < size)
		{
			print("▓");
			i += 1;
		}
	}
	//  Displaying of Staircase in given size
	def staircase_pattern(size: Int): Unit = {
		//   When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//   Display size of Staircase
		print("\n Size : " + size + "\n ");
		var i: Int = 0;
		while (i <= size)
		{
			this.display_symbols(i + i);
			//  include new line
			print("\n ");
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var pattern: StaircasePattern = new StaircasePattern();
		//  Test Cases
		pattern.staircase_pattern(8);
		pattern.staircase_pattern(12);
		pattern.staircase_pattern(3);
	}
}

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

/*
    Swift 4 program 
    Display Staircase Pattern

*/
class StaircasePattern
{
	//   We will use this symbol (▒,▅,▃,▓)
	func display_symbols(_ size: Int)
	{
		var i: Int = 0;
		while (i < size)
		{
			print("▓", terminator: "");
			i += 1;
		}
	}
	//  Displaying of Staircase in given size
	func staircase_pattern(_ size: Int)
	{
		//   When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//   Display size of Staircase
		print("\n Size : ", size ,"\n ", terminator: "");
		var i: Int = 0;
		while (i <= size)
		{
			self.display_symbols(i + i);
			//  include new line
			print("\n ", terminator: "");
			i += 1;
		}
	}
}
func main()
{
	let pattern: StaircasePattern = StaircasePattern();
	//  Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
}
main();

Output

 Size :  8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size :  12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size :  3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

/*
    Kotlin program 
    Display Staircase Pattern

*/
class StaircasePattern
{
	// We will use this symbol (▒,▅,▃,▓)
	fun display_symbols(size: Int): Unit
	{
		var i: Int = 0;
		while (i < size)
		{
			print("▓");
			i += 1;
		}
	}
	//  Displaying of Staircase in given size
	fun staircase_pattern(size: Int): Unit
	{
		//   When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//   Display size of Staircase
		print("\n Size : " + size + "\n ");
		var i: Int = 0;
		while (i <= size)
		{
			this.display_symbols(i + i);
			//  include new line
			print("\n ");
			i += 1;
		}
	}
}
fun main(args: Array < String > ): Unit
{
	var pattern: StaircasePattern = StaircasePattern();
	//  Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
}

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

// Rust Program 
// Display Staircase Pattern

fn main()
{
	//Test Cases
	staircase_pattern(8);
	staircase_pattern(12);
	staircase_pattern(3);
}
fn staircase_pattern(size: i32)
{
	if size <= 0
	{
		// When get a invalid size
		return;
	}
	// Display size of Staircase
	print!("\n Size : {}\n ", size);
	let mut i: i32 = 0;
	while i <= size
	{
		display_symbols(i + i);
		//include new line
		print!("\n ");
		i += 1;
	}
}
fn display_symbols(size: i32)
{
	let mut i: i32 = 0;
	while i < size
	{
		print!("▓");
		i += 1;
	}
}

Output

 Size : 8

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 12

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
 ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

 Size : 3

 ▓▓
 ▓▓▓▓
 ▓▓▓▓▓▓

// C Program 
// Display Staircase Pattern Set B
#include <stdio.h>

// We will use this symbol (▒,▅,▃,▓)
void display_symbols(int size)
{

    for (int i = 0; i < size; ++i)
    {
        printf("▃");
    }
}

// include space
void space(int size)
{

    for (int i = 0; i < size; ++i)
    {
        printf(" ");
    }
}
//Displaying of Staircase in given size
void staircase_pattern(int size)
{
    if (size <= 0)
    {
        // When get a invalid size
        return;
    }
    // Display size of Staircase
    printf("\n Size : %d\n ", size);

    for (int i = 1; i <=size; ++i)
    {
        space((size-i)*2);
        display_symbols(i+i);
        //include new line
        printf("\n ");
    }
}
int main()
{
    //Test Cases
    staircase_pattern(8);
    staircase_pattern(12);
    staircase_pattern(3);
    return 0;
}

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

/*
    Java program 
    Display Staircase Pattern Set B
*/
class StaircasePattern
{
// We will use this symbol (▒,▅,▃,▓)
public void display_symbols(int size)
{
    for (int i = 0; i < size; ++i)
    {
        System.out.print("▃");
    }
}
// include space
public void space(int size)
{
    for (int i = 0; i < size; ++i)
    {
        System.out.print(" ");
    }
}
//Displaying of Staircase in given size
public void staircase_pattern(int size)
{
    if (size <= 0)
    {
        // When get a invalid size
        return;
    }
    // Display size of Staircase
    System.out.print("\n Size : " + size + "\n ");
    for (int i = 1; i <= size; ++i)
    {
        space((size - i) * 2);
        display_symbols(i + i);
        //include new line
        System.out.print("\n ");
    }
}
    public static void main(String[] args) 
    {
        StaircasePattern pattern = new StaircasePattern();
        
            //Test Cases
    pattern.staircase_pattern(8);
    pattern.staircase_pattern(12);
    pattern.staircase_pattern(3);
    }
}

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

// Include header file
#include <iostream>
using namespace std;

/*
    C++ program 
    Display Staircase Pattern Set B
*/

class StaircasePattern
{
	public:
		//  We will use this symbol (▒,▅,▃,▓)
		void display_symbols(int size)
		{
			for (int i = 0; i < size; ++i)
			{
				cout << "▃";
			}
		}
	//  include space
	void space(int size)
	{
		for (int i = 0; i < size; ++i)
		{
			cout << " ";
		}
	}
	// Displaying of Staircase in given size
	void staircase_pattern(int size)
	{
		//  When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		cout << "\n Size : " << size << "\n ";
		for (int i = 1; i <= size; ++i)
		{
			this->space((size - i) *2);
			this->display_symbols(i + i);
			// include new line
			cout << "\n ";
		}
	}
};
int main()
{
	StaircasePattern pattern = StaircasePattern();
	// Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
	return 0;
}

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

// Include namespace system
using System;
/*
    C# program 
    Display Staircase Pattern Set B
*/
public class StaircasePattern
{
	//  We will use this symbol (▒,▅,▃,▓)
	public void display_symbols(int size)
	{
		for (int i = 0; i < size; ++i)
		{
			Console.Write("▃");
		}
	}
	//  include space
	public void space(int size)
	{
		for (int i = 0; i < size; ++i)
		{
			Console.Write(" ");
		}
	}
	// Displaying of Staircase in given size
	public void staircase_pattern(int size)
	{
		//  When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		Console.Write("\n Size : " + size + "\n ");
		for (int i = 1; i <= size; ++i)
		{
			space((size - i) * 2);
			display_symbols(i + i);
			// include new line
			Console.Write("\n ");
		}
	}
	public static void Main(String[] args)
	{
		StaircasePattern pattern = new StaircasePattern();
		// Test Cases
		pattern.staircase_pattern(8);
		pattern.staircase_pattern(12);
		pattern.staircase_pattern(3);
	}
}

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

<?php
/*
    Php program 
    Display Staircase Pattern Set B
*/
class StaircasePattern
{
	//  We will use this symbol (▒,▅,▃,▓)
	public	function display_symbols($size)
	{
		for ($i = 0; $i < $size; ++$i)
		{
			echo "▃";
		}
	}
	//  include space
	public	function space($size)
	{
		for ($i = 0; $i < $size; ++$i)
		{
			echo " ";
		}
	}
	// Displaying of Staircase in given size
	public	function staircase_pattern($size)
	{
		//  When get a invalid size
		if ($size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		echo "\n Size : ". $size ."\n ";
		for ($i = 1; $i <= $size; ++$i)
		{
			$this->space(($size - $i) * 2);
			$this->display_symbols($i + $i);
			// include new line
			echo "\n ";
		}
	}
}

function main()
{
	$pattern = new StaircasePattern();
	// Test Cases
	$pattern->staircase_pattern(8);
	$pattern->staircase_pattern(12);
	$pattern->staircase_pattern(3);
}
main();

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

/*
    Node Js program 
    Display Staircase Pattern Set B
*/
class StaircasePattern
{
	//  We will use this symbol (▒,▅,▃,▓)
	display_symbols(size)
	{
		for (var i = 0; i < size; ++i)
		{
			process.stdout.write("▃");
		}
	}
	//  include space
	space(size)
	{
		for (var i = 0; i < size; ++i)
		{
			process.stdout.write(" ");
		}
	}
	// Displaying of Staircase in given size
	staircase_pattern(size)
	{
		//  When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//  Display size of Staircase
		process.stdout.write("\n Size : " + size + "\n ");
		for (var i = 1; i <= size; ++i)
		{
			this.space((size - i) * 2);
			this.display_symbols(i + i);
			// include new line
			process.stdout.write("\n ");
		}
	}
}

function main()
{
	var pattern = new StaircasePattern();
	// Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
}
main();

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

#  Python 3 program 
#  Display Staircase Pattern Set B

class StaircasePattern :
	#   We will use this symbol (▒,▅,▃,▓)
	def display_symbols(self, size) :
		i = 0
		while (i < size) :
			print("▃", end = "")
			i += 1
		
	
	#   include space
	def space(self, size) :
		i = 0
		while (i < size) :
			print(" ", end = "")
			i += 1
		
	
	#  Displaying of Staircase in given size
	def staircase_pattern(self, size) :
		#   When get a invalid size
		if (size <= 0) :
			return
		
		#   Display size of Staircase
		print("\n Size : ", size ,"\n ", end = "")
		i = 1
		while (i <= size) :
			self.space((size - i) * 2)
			self.display_symbols(i + i)
			#  include new line
			print("\n ", end = "")
			i += 1
		
	

def main() :
	pattern = StaircasePattern()
	#  Test Cases
	pattern.staircase_pattern(8)
	pattern.staircase_pattern(12)
	pattern.staircase_pattern(3)

if __name__ == "__main__": main()

Output

 Size :  8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size :  12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size :  3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

#  Ruby program 
#  Display Staircase Pattern Set B

class StaircasePattern 
	#   We will use this symbol (▒,▅,▃,▓)
	def display_symbols(size) 
		i = 0
		while (i < size) 
			print("▃")
			i += 1
		end

	end

	#   include space
	def space(size) 
		i = 0
		while (i < size) 
			print(" ")
			i += 1
		end

	end

	#  Displaying of Staircase in given size
	def staircase_pattern(size) 
		#   When get a invalid size
		if (size <= 0) 
			return
		end

		#   Display size of Staircase
		print("\n Size : ", size ,"\n ")
		i = 1
		while (i <= size) 
			self.space((size - i) * 2)
			self.display_symbols(i + i)
			#  include new line
			print("\n ")
			i += 1
		end

	end

end

def main() 
	pattern = StaircasePattern.new()
	#  Test Cases
	pattern.staircase_pattern(8)
	pattern.staircase_pattern(12)
	pattern.staircase_pattern(3)
end

main()

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 
 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 
 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃
 
/*
    Scala program 
    Display Staircase Pattern Set B
*/
class StaircasePattern
{
	// We will use this symbol (▒,▅,▃,▓)
	def display_symbols(size: Int): Unit = {
		var i: Int = 0;
		while (i < size)
		{
			print("▃");
			i += 1;
		}
	}
	// include space
	def space(size: Int): Unit = {
		var i: Int = 0;
		while (i < size)
		{
			print(" ");
			i += 1;
		}
	}
	// Displaying of Staircase in given size
	def staircase_pattern(size: Int): Unit = {
		// When get a invalid size
		if (size <= 0)
		{
			return;
		}
		// Display size of Staircase
		print("\n Size : " + size + "\n ");
		var i: Int = 1;
		while (i <= size)
		{
			this.space((size - i) * 2);
			this.display_symbols(i + i);
			//  include new line
			print("\n ");
			i += 1;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var pattern: StaircasePattern = new StaircasePattern();
		//  Test Cases
		pattern.staircase_pattern(8);
		pattern.staircase_pattern(12);
		pattern.staircase_pattern(3);
	}
}

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

/*
    Swift 4 program 
    Display Staircase Pattern Set B

*/
class StaircasePattern
{
	//   We will use this symbol (▒,▅,▃,▓)
	func display_symbols(_ size: Int)
	{
		var i: Int = 0;
		while (i < size)
		{
			print("▃", terminator: "");
			i += 1;
		}
	}
	//   include space
	func space(_ size: Int)
	{
		var i: Int = 0;
		while (i < size)
		{
			print(" ", terminator: "");
			i += 1;
		}
	}
	//  Displaying of Staircase in given size
	func staircase_pattern(_ size: Int)
	{
		//   When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//   Display size of Staircase
		print("\n Size : ", size ,"\n ", terminator: "");
		var i: Int = 1;
		while (i <= size)
		{
			self.space((size - i) * 2);
			self.display_symbols(i + i);
			//  include new line
			print("\n ", terminator: "");
			i += 1;
		}
	}
}
func main()
{
	let pattern: StaircasePattern = StaircasePattern();
	//  Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
}
main();

Output

 Size :  8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size :  12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size :  3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

/*
    Kotlin program 
    Display Staircase Pattern Set B
*/
class StaircasePattern
{
	//   We will use this symbol (▒,▅,▃,▓)
	fun display_symbols(size: Int): Unit
	{
		var i: Int = 0;
		while (i < size)
		{
			print("▃");
			i += 1;
		}
	}
	//   include space
	fun space(size: Int): Unit
	{
		var i: Int = 0;
		while (i < size)
		{
			print(" ");
			i += 1;
		}
	}
	//  Displaying of Staircase in given size
	fun staircase_pattern(size: Int): Unit
	{
		//   When get a invalid size
		if (size <= 0)
		{
			return;
		}
		//   Display size of Staircase
		print("\n Size : " + size + "\n ");
		var i: Int = 1;
		while (i <= size)
		{
			this.space((size - i) * 2);
			this.display_symbols(i + i);
			//  include new line
			print("\n ");
			i += 1;
		}
	}
}
fun main(args: Array < String > ): Unit
{
	var pattern: StaircasePattern = StaircasePattern();
	//  Test Cases
	pattern.staircase_pattern(8);
	pattern.staircase_pattern(12);
	pattern.staircase_pattern(3);
}

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃

fn main()
{
	//Test Cases
	staircase_pattern(8);
	staircase_pattern(12);
	staircase_pattern(3);
}
fn staircase_pattern(size: i32)
{
	if size <= 0
	{
		// When get a invalid size
		return;
	}
	// Display size of Staircase
	print!("\n Size : {}\n ", size);
	let mut i: i32 = 1;
	while i <= size
	{
		space((size - i) * 2);
		display_symbols(i + i);
		//include new line
		print!("\n ");
		i += 1;
	}
}
fn space(size: i32)
{
	let mut i: i32 = 0;
	while i < size
	{
		print!(" ");
		i += 1;
	}
}
fn display_symbols(size: i32)
{
	let mut i: i32 = 0;
	while i < size
	{
		print!("▃");
		i += 1;
	}
}

Output

 Size : 8
               ▃▃
             ▃▃▃▃
           ▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 12
                       ▃▃
                     ▃▃▃▃
                   ▃▃▃▃▃▃
                 ▃▃▃▃▃▃▃▃
               ▃▃▃▃▃▃▃▃▃▃
             ▃▃▃▃▃▃▃▃▃▃▃▃
           ▃▃▃▃▃▃▃▃▃▃▃▃▃▃
         ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
       ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
     ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
   ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃
 ▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃

 Size : 3
     ▃▃
   ▃▃▃▃
 ▃▃▃▃▃▃
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