Display Staircase Pattern
A staircase star pattern is a pattern of stars or asterisks arranged in a stair-like shape. This pattern is often used for decorative purposes or in programming to create visual designs or shapes.
The pattern consists of one or more rows of stars, each row offset from the previous row to create the stair-like effect. The number of stars in each row increases or decreases as the rows progress, depending on the desired pattern.
There are different variations of the staircase star pattern, including symmetrical and asymmetrical designs, and the pattern can be created using loops or recursive functions in programming languages. The pattern can also be customized by adjusting the number of rows and stars in each row to create different shapes and sizes.
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
▃▃
▃▃▃▃
▃▃▃▃▃▃
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