Print Right Arrow Patterns

In this article, we will discuss the problem of printing right arrow patterns using a simple C program. The program takes a size as input and generates a right arrow pattern based on that size. We will explain the problem statement, provide a suitable example, present the algorithm and pseudocode with explanations, and finally, discuss the resultant output and the time complexity of the code.

Problem Statement

The problem is to write a program that prints a right arrow pattern using asterisks (*) and spaces. The pattern consists of two parts: the top part and the bottom part. The top part of the arrow starts with one asterisk and adds an extra asterisk in each line until it reaches the given size. The bottom part starts with the size minus one asterisks and decreases one asterisk in each line until it reaches one asterisk. The pattern should be centered, and the number of spaces before each line should be equal to its line number.

Example

Let's take an example to understand the problem better. Suppose we want to generate a right arrow pattern with a size of 4.

The expected pattern would be:

``` *
**
***
****
***
**
*
```

In this example, the top part of the arrow starts with one asterisk and increases by one asterisk in each line. The bottom part starts with three asterisks and decreases by one asterisk in each line.

Algorithm and Pseudocode

Based on the problem statement, we can design the following algorithm:

1. Define a function to print a given number of spaces.
2. Define a function to print a given number of asterisks.
3. Define a function to display the right arrow pattern.
4. Inside the function to display the right arrow pattern:
1. Print the size of the pattern.
2. Loop from 0 to size-1:
1. Call the space function with the current iteration index.
2. Call the print_star function with the current iteration index.
3. Print a new line.
3. Loop from 0 to size-1:
1. Call the space function with size minus the current iteration index.
2. Call the print_star function with size minus the current iteration index.
3. Print a new line.
5. Inside the main function:
1. Call the right_arrow function with different sizes to test the pattern.

Here is the pseudocode representation of the algorithm:

``````
function space(size):
for counter from 0 to size:
print a space

function print_star(size):
for counter from 0 to size:
print an asterisk

function right_arrow(size):
print "Size: " + size
for i from 0 to size-1:
space(i)
print_star(i)
print a new line
for i from 0 to size-1:
space(size-i)
print_star(size-i)
print a new line

main():
right_arrow(3)
right_arrow(4)
right_arrow(7)```
```

Code Solution

Here given code implementation process.

``````//C Program
//Print Right Arrow 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 Space of given size*/
void print_star(int size) {

int counter = 0;

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

printf("*");
}
}
//Display the right arrow of given size
void right_arrow(int size) {

printf("\n Size : %d \n", size);

int i=0;

for(i=0;i<size;i++){
space(i);
print_star(i);
printf("\n");
}
for(i=0;i<size;i++){
space(size-i);
print_star(size-i);
printf("\n");
}
}

int main() {
//Test Cases
right_arrow(3);
right_arrow(4);
right_arrow(7);
return 0;
}```
```

Output

`````` Size : 3

*
**
***
**
*

Size : 4

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

Size : 7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````/*
C++ Program
Print right Arrow 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 Space of given size*/
void print_star(int size) {
int counter = 0;
for (counter = 0; counter < size; counter++) {

cout << "*";
}
}
//Display the right arrow of given size
void right_arrow(int size) {
cout << "\n Size : " << size << " \n";
int i = 0;
for (i = 0; i < size; i++) {
this->space(i);
this->print_star(i);
cout << "\n";
}
for (i = 0; i < size; i++) {
this->space(size - i);
this->print_star(size - i);
cout << "\n";
}
}
};
int main() {
MyPattern obj =  MyPattern();
//Test Cases
obj.right_arrow(3);
obj.right_arrow(4);
obj.right_arrow(7);
return 0;
}```
```

Output

`````` Size : 3

*
**
***
**
*

Size : 4

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

Size : 7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````/*
Java Program
Print right Arrow 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 Space of given size*/
public void print_star(int size) {

int counter = 0;

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

System.out.print("*");
}
}
//Display the right arrow of given size
public void right_arrow(int size) {

System.out.print("\n Size : "+size+" \n");

int i=0;

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

space(i);

print_star(i);
System.out.print("\n");
}
for(i=0;i<size;i++){

space(size-i);

print_star(size-i);

System.out.print("\n");
}
}

public static void main(String[] args) {

MyPattern obj = new MyPattern();
//Test Cases
obj.right_arrow(3);
obj.right_arrow(4);
obj.right_arrow(7);
}
}```
```

Output

`````` Size : 3

*
**
***
**
*

Size : 4

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

Size : 7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````/*
C# Program
Print right Arrow 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 Space of given size*/
public void print_star(int size) {
int counter = 0;
for (counter = 0; counter < size; counter++) {
Console.Write("*");
}
}
//Display the right arrow of given size
public void right_arrow(int size) {
Console.Write("\n Size : " + size + " \n");
int i = 0;
for (i = 0; i < size; i++) {
space(i);
print_star(i);
Console.Write("\n");
}
for (i = 0; i < size; i++) {
space(size - i);
print_star(size - i);
Console.Write("\n");
}
}
public static void Main(String[] args) {
MyPattern obj = new MyPattern();
obj.right_arrow(3);
obj.right_arrow(4);
obj.right_arrow(7);
}
}```
```

Output

`````` Size : 3

*
**
***
**
*

Size : 4

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

Size : 7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````<?php
/*
Php Program
Print right Arrow Pattern
*/
class MyPattern {
/*Include Space of given size*/
public 	function space(\$size) {
\$counter = 0;
for (\$counter = 0; \$counter < \$size; \$counter++) {

echo(" ");
}
}
/*Include Space of given size*/
public 	function print_star(\$size) {
\$counter = 0;
for (\$counter = 0; \$counter < \$size; \$counter++) {

echo("*");
}
}
//Display the right arrow of given size
public 	function right_arrow(\$size) {
echo("\n Size : ". \$size ." \n");
\$i = 0;
for (\$i = 0; \$i < \$size; \$i++) {
\$this->space(\$i);
\$this->print_star(\$i);
echo("\n");
}
for (\$i = 0; \$i < \$size; \$i++) {
\$this->space(\$size - \$i);
\$this->print_star(\$size - \$i);
echo("\n");
}
}
}

function main() {
\$obj = new MyPattern();
//Test Cases
\$obj->right_arrow(3);
\$obj->right_arrow(4);
\$obj->right_arrow(7);

}
main();```
```

Output

`````` Size : 3

*
**
***
**
*

Size : 4

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

Size : 7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````/*
Node Js Program
Print right Arrow Pattern
*/
class MyPattern {
/*Include Space of given size*/
space(size) {
var counter = 0;
for (counter = 0; counter < size; counter++) {

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

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

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

//Display the right arrow of given size
right_arrow(size) {
process.stdout.write("\n Size : " + size + " \n");
var i = 0;
for (i = 0; i < size; i++) {
this.space(i);
this.print_star(i);
process.stdout.write("\n");
}

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

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

main();```
```

Output

`````` Size : 3

*
**
***
**
*

Size : 4

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

Size : 7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````#   Python 3 Program
#   Print right Arrow Pattern

class MyPattern :
# Include Space of given size
def space(self, size) :
counter = 0
while (counter < size) :
print(" ", end = "")
counter += 1

# Include Space of given size
def print_star(self, size) :
counter = 0
while (counter < size) :
print("*", end = "")
counter += 1

# Display the right arrow of given size
def right_arrow(self, size) :
print("\n Size : ", size ," \n", end = "")
i = 0
while (i < size) :
self.space(i)
self.print_star(i)
print("\n", end = "")
i += 1

i = 0
while (i < size) :
self.space(size - i)
self.print_star(size - i)
print("\n", end = "")
i += 1

def main() :
obj = MyPattern()
obj.right_arrow(3)
obj.right_arrow(4)
obj.right_arrow(7)

if __name__ == "__main__":
main()```
```

Output

`````` Size :  3

*
**
***
**
*

Size :  4

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

Size :  7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````#  Ruby Program
#  Print right Arrow Pattern

class MyPattern
# Include Space of given size
def space(size)
counter = 0
while (counter < size)
print(" ")
counter += 1
end
end
# Include Space of given size
def print_star(size)
counter = 0
while (counter < size)
print("*")
counter += 1
end
end
# Display the right arrow of given size
def right_arrow(size)
print("\n Size  :", size ," \n")
i = 0
while (i < size)
self.space(i)
self.print_star(i)
print("\n")
i += 1
end
i = 0
while (i < size)
self.space(size - i)
self.print_star(size - i)
print("\n")
i += 1
end
end
end
def main()
obj = MyPattern.new()
obj.right_arrow(3)
obj.right_arrow(4)
obj.right_arrow(7)
end
main()```
```

Output

`````` Size  :3

*
**
***
**
*

Size  :4

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

Size  :7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*
``````
``````/*
Scala Program
Print right Arrow Pattern
*/
class MyPattern {
/*Include Space of given size*/
def space(size: Int): Unit = {
var counter: Int = 0;
while (counter < size) {
print(" ");
counter += 1;
}
}
/*Include Space of given size*/
def print_star(size: Int): Unit = {
var counter: Int = 0;
while (counter < size) {
print("*");
counter += 1;
}
}
//Display the right arrow of given size
def right_arrow(size: Int): Unit = {
print("\n Size : " + size + " \n");
var i: Int = 0;
while (i < size) {
this.space(i);
this.print_star(i);
print("\n");
i += 1;
}
i = 0;
while (i < size) {
this.space(size - i);
this.print_star(size - i);
print("\n");
i += 1;
}
}
}
object Main {
def main(args: Array[String]): Unit = {
val obj: MyPattern = new MyPattern();
obj.right_arrow(3);
obj.right_arrow(4);
obj.right_arrow(7);
}
}```
```

Output

`````` Size : 3

*
**
***
**
*

Size : 4

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

Size : 7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````
``````/*
Swift Program
Print right Arrow Pattern
*/
class MyPattern {
/*Include Space of given size*/
func space(_ size: Int) {
var counter = 0;
while (counter < size) {
print(" ", terminator: "");
counter += 1;
}
}
/*Include Space of given size*/
func print_star(_ size: Int) {
var counter = 0;
while (counter < size) {
print("*", terminator: "");
counter += 1;
}
}
//Display the right arrow of given size
func right_arrow(_ size: Int) {
print("\n Size : ", size ," \n", terminator: "");
var i = 0;
while (i < size) {
self.space(i);
self.print_star(i);
print("\n", terminator: "");
i += 1;
}
i = 0;
while (i < size) {
self.space(size - i);
self.print_star(size - i);
print("\n", terminator: "");
i += 1;
}
}
}
func main() {
let obj = MyPattern();
obj.right_arrow(3);
obj.right_arrow(4);
obj.right_arrow(7);
}
main();```
```

Output

`````` Size :  3

*
**
***
**
*

Size :  4

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

Size :  7

*
**
***
****
*****
******
*******
******
*****
****
***
**
*``````

The output matches the expected right arrow patterns for the given sizes. The patterns are centered and consist of asterisks and spaces as defined in the problem statement.

Time Complexity

The time complexity of the program is determined by the loops used to print spaces and asterisks in the right arrow pattern. Both loops iterate from 0 to the given size, so the time complexity is O(size). As the size increases, the time taken to generate the pattern will increase linearly.

Print Variant Right Arrow Patterns

The problem is to design a pattern that represents right arrows of varying sizes using a combination of greater than signs (>) and hyphens (-). Each arrow consists of two parts: the top part and the bottom part. The top part starts with one greater than sign and gradually increases in size. The bottom part starts with the maximum size and gradually decreases. The arrows are centered, and the number of spaces before each line should be equal to its line number.

Examples

Let's examine a few examples to understand the problem better.

Example 1 (Size: 3)

``` >   >
>>  >>
>-> >->
>>  >>
>   >
```

Double right arrow Solution

``````//C Program
//Print Double Right Arrow 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 Symbol*/
void print_symbol(int size) {

int counter = 0;

for (counter = 0; counter < size; counter++) {
if(counter==0 || counter+1 == size)
{
printf(">");
}
else
{
printf("-");
}

}
}
//Display the double right arrow of given size
void double_right_arrow(int size) {

printf("\n Size : %d \n", size);

int i=0;
//Display the result of top half shell
for(i=0;i<size;i++){
space(i);
print_symbol(i);
space(size+(size/2)-i);
print_symbol(i);
printf("\n");
}
//Display the result of bottom half shell
for(i=0;i<size;i++){
space(size-i);
print_symbol(size-i);
space(i+(size/2));
print_symbol(size-i);
printf("\n");
}
}

int main() {
//Test Cases
double_right_arrow(3);
double_right_arrow(6);
double_right_arrow(7);
return 0;
}```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````// C++ Program
// Print Double Right Arrow 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 Symbol*/
void print_symbol(int size) {
int counter = 0;
for (counter = 0; counter < size; counter++) {
if (counter == 0 ||
counter + 1 == size) {
cout << ">";
} else {
cout << "-";
}
}
}
//Display the double right arrow of given size
void double_right_arrow(int size) {
cout << "\n Size : " << size << " \n";
int i = 0;
//Display the result of top half shell

for (i = 0; i < size; i++) {
this->space(i);
this->print_symbol(i);
this->space(size + (size / 2) - i);
this->print_symbol(i);
cout << "\n";
}
//Display the result of bottom half shell

for (i = 0; i < size; i++) {
this->space(size - i);
this->print_symbol(size - i);
this->space(i + (size / 2));
this->print_symbol(size - i);
cout << "\n";
}
}
};
int main() {
MyPattern obj =  MyPattern();
//Test Case
obj.double_right_arrow(3);
obj.double_right_arrow(6);
obj.double_right_arrow(7);
return 0;
}```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````// Java Program
// Print Double Right Arrow Pattern
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 Symbol*/
public void print_symbol(int size)
{
int counter = 0;
for (counter = 0; counter < size; counter++)
{
if (counter == 0 || counter + 1 == size)
{
System.out.print(">");
}
else
{
System.out.print("-");
}
}
}
//Display the double right arrow of given size
public void double_right_arrow(int size)
{
System.out.print("\n Size : "+size+" \n");
int i = 0;
//Display the result of top half shell

for (i = 0; i < size; i++)
{
space(i);
print_symbol(i);
space(size + (size / 2) - i);
print_symbol(i);
System.out.print("\n");
}
//Display the result of bottom half shell
for (i = 0; i < size; i++)
{
space(size - i);
print_symbol(size - i);
space(i + (size / 2));
print_symbol(size - i);
System.out.print("\n");
}
}
public static void main(String[] args) {
MyPattern obj = new MyPattern();
//Test Case

obj.double_right_arrow(3);
obj.double_right_arrow(6);
obj.double_right_arrow(7);

}
}```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````// C# Program
// Print Double Right Arrow 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 Symbol*/
public void print_symbol(int size) {
int counter = 0;
for (counter = 0; counter < size; counter++) {
if (counter == 0 ||
counter + 1 == size) {
Console.Write(">");
} else {
Console.Write("-");
}
}
}
//Display the double right arrow of given size
public void double_right_arrow(int size) {
Console.Write("\n Size : " + size + " \n");
int i = 0;
//Display the result of top half shell

for (i = 0; i < size; i++) {
space(i);
print_symbol(i);
space(size + (size / 2) - i);
print_symbol(i);
Console.Write("\n");
}
//Display the result of bottom half shell

for (i = 0; i < size; i++) {
space(size - i);
print_symbol(size - i);
space(i + (size / 2));
print_symbol(size - i);
Console.Write("\n");
}
}
public static void Main(String[] args) {
MyPattern obj = new MyPattern();
obj.double_right_arrow(3);
obj.double_right_arrow(6);
obj.double_right_arrow(7);
}
}```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````<?php
// Php Program
// Print Double Right Arrow Pattern
class MyPattern {
/*Include Space of given size*/

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

echo(" ");
}
}
/*Include Symbol*/

public 	function print_symbol(\$size) {
\$counter = 0;
for (\$counter = 0; \$counter < \$size; \$counter++) {
if (\$counter == 0 ||
\$counter + 1 == \$size) {
echo(">");
} else {
echo("-");
}
}
}
//Display the double right arrow of given size

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

for (\$i = 0; \$i < \$size; \$i++) {
\$this->space(\$i);
\$this->print_symbol(\$i);
\$this->space(\$size + (intval(\$size / 2)) - \$i);
\$this->print_symbol(\$i);
echo("\n");
}
//Display the result of bottom half shell

for (\$i = 0; \$i < \$size; \$i++) {
\$this->space(\$size - \$i);
\$this->print_symbol(\$size - \$i);
\$this->space(\$i + (intval(\$size / 2)));
\$this->print_symbol(\$size - \$i);
echo("\n");
}
}
}

function main() {
\$obj = new MyPattern();
//Test Case
\$obj->double_right_arrow(3);
\$obj->double_right_arrow(6);
\$obj->double_right_arrow(7);

}
main();```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````// Node Js Program
// Print Double Right Arrow Pattern
class MyPattern {
/*Include Space of given size*/
space(size) {
var counter = 0;
for (counter = 0; counter < size; counter++) {

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

/*Include Symbol*/
print_symbol(size) {
var counter = 0;
for (counter = 0; counter < size; counter++) {
if (counter == 0 ||
counter + 1 == size) {
process.stdout.write(">");
} else {
process.stdout.write("-");
}
}
}

//Display the double right arrow of given size
double_right_arrow(size) {
process.stdout.write("\n Size : " + size + " \n");
var i = 0;
//Display the result of top half shell

for (i = 0; i < size; i++) {
this.space(i);
this.print_symbol(i);
this.space(size + (parseInt(size / 2)) - i);
this.print_symbol(i);
process.stdout.write("\n");
}

//Display the result of bottom half shell

for (i = 0; i < size; i++) {
this.space(size - i);
this.print_symbol(size - i);
this.space(i + (parseInt(size / 2)));
this.print_symbol(size - i);
process.stdout.write("\n");
}
}
}

function main(args) {
var obj = new MyPattern();
//Test Case
obj.double_right_arrow(3);
obj.double_right_arrow(6);
obj.double_right_arrow(7);
}

main();```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````#  Python 3 Program
#  Print Double Right Arrow Pattern
class MyPattern :
# Include Space of given size

def space(self, size) :
counter = 0
counter = 0
while (counter < size) :
print(" ", end = "")
counter += 1

# Include Symbol

def print_symbol(self, size) :
counter = 0
while (counter < size) :
if (counter == 0 or counter + 1 == size) :
print(">", end = "")
else :
print("-", end = "")

counter += 1

# Display the double right arrow of given size
def double_right_arrow(self, size) :
print("\n Size : ", size ," \n", end = "")
i = 0
# Display the result of top half shell
while (i < size) :
self.space(i)
self.print_symbol(i)
self.space(size + (int(size / 2)) - i)
self.print_symbol(i)
print("\n", end = "")
i += 1

# Display the result of bottom half shell
i = 0
while (i < size) :
self.space(size - i)
self.print_symbol(size - i)
self.space(i + (int(size / 2)))
self.print_symbol(size - i)
print("\n", end = "")
i += 1

def main() :
obj = MyPattern()
obj.double_right_arrow(3)
obj.double_right_arrow(6)
obj.double_right_arrow(7)

if __name__ == "__main__":
main()```
```

Output

`````` Size :  3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size :  6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size :  7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````#  Ruby Program
#  Print Double Right Arrow Pattern
class MyPattern
# Include Space of given size
def space(size)
counter = 0
counter = 0
while (counter < size)
print(" ")
counter += 1
end
end
# Include Symbol
def print_symbol(size)
counter = 0
while (counter < size)
if (counter == 0 ||
counter + 1 == size)
print(">")
else
print("-")
end
counter += 1
end
end
# Display the double right arrow of given size
def double_right_arrow(size)
print("\n Size  :", size ," \n")
i = 0
# Display the result of top half shell
while (i < size)
self.space(i)
self.print_symbol(i)
self.space(size + (size / 2) - i)
self.print_symbol(i)
print("\n")
i += 1
end
# Display the result of bottom half shell
i = 0
while (i < size)
self.space(size - i)
self.print_symbol(size - i)
self.space(i + (size / 2))
self.print_symbol(size - i)
print("\n")
i += 1
end
end
end
def main()
obj = MyPattern.new()
obj.double_right_arrow(3)
obj.double_right_arrow(6)
obj.double_right_arrow(7)
end
main()```
```

Output

`````` Size  :3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size  :6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size  :7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >
``````
``````// Scala Program
// Print Double Right Arrow Pattern
class MyPattern {
/*Include Space of given size*/
def space(size: Int): Unit = {
var counter: Int = 0;
counter = 0;
while (counter < size) {
print(" ");
counter += 1;
}
}
/*Include Symbol*/
def print_symbol(size: Int): Unit = {
var counter: Int = 0;
while (counter < size) {
if (counter == 0 ||
counter + 1 == size) {
print(">");
} else {
print("-");
}
counter += 1;
}
}
//Display the double right arrow of given size
def double_right_arrow(size: Int): Unit = {
print("\n Size : " + size + " \n");
var i: Int = 0;

//Display the result of top half shell
while (i < size) {
space(i);
print_symbol(i);
space(size + ((size / 2).toInt) - i);
print_symbol(i);
print("\n");
i += 1;
}
//Display the result of bottom half shell
i = 0;
while (i < size) {
space(size - i);
print_symbol(size - i);
space(i + ((size / 2).toInt));
print_symbol(size - i);
print("\n");
i += 1;
}
}
}
object Main {
def main(args: Array[String]): Unit = {
var obj: MyPattern = new MyPattern();
obj.double_right_arrow(3);
obj.double_right_arrow(6);
obj.double_right_arrow(7);
}
}```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````// Swift Program
// Print Double Right Arrow Pattern
class MyPattern {
/*Include Space of given size*/
func space(_ size: Int) {
var counter: Int = 0;
while (counter < size) {
print(" ", terminator: "");
counter += 1;
}
}
/*Include Symbol*/
func print_symbol(_ size: Int) {
var counter: Int = 0;
while (counter < size) {
if (counter == 0 ||
counter + 1 == size) {
print(">", terminator: "");
} else {
print("-", terminator: "");
}
counter += 1;
}
}
//Display the double right arrow of given size
func double_right_arrow(_ size: Int) {
print("\n Size : ", size ," \n", terminator: "");
var i: Int = 0;
//Display the result of top half shell
while (i < size) {
self.space(i);
self.print_symbol(i);
self.space(size + (size / 2) - i);
self.print_symbol(i);
print("\n", terminator: "");
i += 1;
}
//Display the result of bottom half shell
i = 0;
while (i < size) {
self.space(size - i);
self.print_symbol(size - i);
self.space(i + (size / 2));
self.print_symbol(size - i);
print("\n", terminator: "");
i += 1;
}
}
}
func main() {
let obj: MyPattern = MyPattern();
obj.double_right_arrow(3);
obj.double_right_arrow(6);
obj.double_right_arrow(7);
}
main();```
```

Output

`````` Size :  3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size :  6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size :  7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````
``````fn main() {
//Test Cases
double_right_arrow(3);
double_right_arrow(6);
double_right_arrow(7);
}
fn double_right_arrow(size: i32) {
print!("\n Size : {} \n", size);
let mut i: i32 = 0;
//Display the result of top half shell

while i < size {
space(i);
print_symbol(i);
space(size + (size / 2) - i);
print_symbol(i);
print!("\n");
i += 1;
}
i = 0;
//Display the result of bottom half shell

while i < size {
space(size - i);
print_symbol(size - i);
space(i + (size / 2));
print_symbol(size - i);
print!("\n");
i += 1;
}
}
fn print_symbol(size: i32) {
let mut counter: i32 = 0;
while counter < size {
if counter == 0 || counter + 1 == size {
print!(">");
}
else {
print!("-");
}
counter += 1;
}
}
fn space(size: i32) {
let mut counter: i32 = 0;
while counter < size {

print!(" ");
counter += 1;
}
}```
```

Output

`````` Size : 3

>   >
>>  >>
>-> >->
>>  >>
>   >

Size : 6

>        >
>>       >>
>->      >->
>-->     >-->
>--->    >--->
>---->   >---->
>--->    >--->
>-->     >-->
>->      >->
>>       >>
>        >

Size : 7

>         >
>>        >>
>->       >->
>-->      >-->
>--->     >--->
>---->    >---->
>----->   >----->
>---->    >---->
>--->     >--->
>-->      >-->
>->       >->
>>        >>
>         >``````

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.