 Open in App
Not now

# Print Triangle separated pattern

• Last Updated : 04 Aug, 2022

Given a number N, the task is to print the triangle-separated pattern.

Triangle Separated Pattern: Pattern in which four triangles (left, down, right, up) are separated by forward and backward slash, see this below:
\*****/
*\***/*
**\*/**
***/***
**/*\**
*/***\*
/*****\

Note: N should be an odd number and the value of N should be more than 4.
Examples:

```Input: N = 5
Output:
\***/
*\*/*
**/**
*/*\*
/***\

Input: N = 7
Output:
\*****/
*\***/*
**\*/**
***/***
**/*\**
*/***\*
/*****\```

Approach: By observing the above pattern, when the indexes of rows and columns are equal, then is printed and when the sum of indexes of rows and columns is N, then ‘/’ is printed. Below is the recursive approach:

1. Use two values i for rows and j for columns, which iterates from (0, 0) to (N-1, N-1) for printing the required pattern.
2. Recursively iterates from (0, 0) to (N-1, N-1)
• Base Case: If indexes of rows and columns are greater than or equal to N is the termination condition for the given pattern.
```if(i >= N) {
return 0;
}
if(j >= N) {
return 1;
}
```
• Print Statement: If the base case condition is not met, then print ‘/’, and ‘*’ on the basis of the below conditions:
```if(i==j) {
print('')
}
else if(i + j == N-1) {
print('/')
}
else {
print('*')
}
```
• Recursive Call: At each recursive call(except the base case), return the recursive function for next iteration for rows and columns:
```// Recursive call for rows
recursive_function(i, j+1, N)

// Recursive call for changing rows
recursive_function(i+1, j, N)
```

Below is the implementation of the above approach:

## C++

 `// C++ program to print the triangle ` `// separated pattern using ` `// star and slash character `   `#include ` `using` `namespace` `std; `   `// Function to print pattern recursively ` `int` `printPattern( ` `    ``int` `i, ``int` `j, ``int` `n) ` `{ ` `    ``// Base Case ` `    ``if` `(j >= n) { ` `        ``return` `0; ` `    ``} ` `    ``if` `(i >= n) { ` `        ``return` `1; ` `    ``} `   `    ``// Conditions to print slash ` `    ``if` `(j == i || j == n - 1 - i) { `   `        ``// Condition to print ` `        ``// forward slash ` `        ``if` `(i == n - 1 - j) { ` `            ``cout << ``"/"``; ` `        ``} `   `        ``// Condition to print ` `        ``// backward slash ` `        ``else` `{ ` `            ``cout << ``"\\"``; ` `        ``} ` `    ``} `   `    ``// Else print '*' ` `    ``else` `{ ` `        ``cout << ``"*"``; ` `    ``} `   `    ``// Recursive call for rows ` `    ``if` `(printPattern(i, j + 1, n) ` `        ``== 1) { ` `        ``return` `1; ` `    ``} `   `    ``cout << endl; `   `    ``// Recursive call for changing ` `    ``// the rows ` `    ``return` `printPattern(i + 1, 0, n); ` `} `   `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 9; `   `    ``// Function Call ` `    ``printPattern(0, 0, N); `   `    ``return` `0; ` `} `

## Java

 `// Java program to print the triangle` `// separated pattern using` `// star and slash character` `class` `GFG{` ` `  `// Function to print pattern recursively` `static` `int` `printPattern(` `    ``int` `i, ``int` `j, ``int` `n)` `{` `    ``// Base Case` `    ``if` `(j >= n) {` `        ``return` `0``;` `    ``}` `    ``if` `(i >= n) {` `        ``return` `1``;` `    ``}` ` `  `    ``// Conditions to print slash` `    ``if` `(j == i || j == n - ``1` `- i) {` ` `  `        ``// Condition to print` `        ``// forward slash` `        ``if` `(i == n - ``1` `- j) {` `            ``System.out.print(``"/"``);` `        ``}` ` `  `        ``// Condition to print` `        ``// backward slash` `        ``else` `{` `            ``System.out.print(``"\\"``);` `        ``}` `    ``}` ` `  `    ``// Else print '*'` `    ``else` `{` `        ``System.out.print(``"*"``);` `    ``}` ` `  `    ``// Recursive call for rows` `    ``if` `(printPattern(i, j + ``1``, n)` `        ``== ``1``) {` `        ``return` `1``;` `    ``}` ` `  `    ``System.out.println();` ` `  `    ``// Recursive call for changing` `    ``// the rows` `    ``return` `printPattern(i + ``1``, ``0``, n);` `}` ` `  `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``9``;` ` `  `    ``// Function Call` `    ``printPattern(``0``, ``0``, N);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python 3 program to print the triangle` `# separated pattern using` `# star and slash character`   `# Function to print pattern recursively` `def` `printPattern(i,j, n):`   `    ``# Base Case` `    ``if` `(j >``=` `n) :` `        ``return` `0` `    ``if` `(i >``=` `n):` `        ``return` `1`   `    ``# Conditions to print slash` `    ``if` `(j ``=``=` `i ``or` `j ``=``=` `n ``-` `1` `-` `i):`   `        ``# Condition to print` `        ``# forward slash` `        ``if` `(i ``=``=` `n ``-` `1` `-` `j):` `            ``print``(``"/"``,end``=``"")`   `        ``# Condition to print` `        ``# backward slash` `        ``else``:` `            ``print``(``"\\",end="``")`   `    ``# Else print '*'` `    ``else``:` `        ``print``(``"*"``,end``=``"")`   `    ``# Recursive call for rows` `    ``if` `(printPattern(i, j ``+` `1``, n)` `        ``=``=` `1``):` `        ``return` `1`   `    ``print``()`   `    ``# Recursive call for changing` `    ``# the rows` `    ``return` `printPattern(i ``+` `1``, ``0``, n)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``N ``=` `9`   `    ``# Function Call` `    ``printPattern(``0``, ``0``, N)`   `# This code is contributed by chitranayal`

## C#

 `// C# program to print the triangle` `// separated pattern using` `// star and slash character` `using` `System;`   `class` `GFG{` `  `  `// Function to print pattern recursively` `static` `int` `printPattern(` `    ``int` `i, ``int` `j, ``int` `n)` `{` `    ``// Base Case` `    ``if` `(j >= n) {` `        ``return` `0;` `    ``}` `    ``if` `(i >= n) {` `        ``return` `1;` `    ``}` `  `  `    ``// Conditions to print slash` `    ``if` `(j == i || j == n - 1 - i) {` `  `  `        ``// Condition to print` `        ``// forward slash` `        ``if` `(i == n - 1 - j) {` `            ``Console.Write(``"/"``);` `        ``}` `  `  `        ``// Condition to print` `        ``// backward slash` `        ``else` `{` `            ``Console.Write(``"\\"``);` `        ``}` `    ``}` `  `  `    ``// Else print '*'` `    ``else` `{` `        ``Console.Write(``"*"``);` `    ``}` `  `  `    ``// Recursive call for rows` `    ``if` `(printPattern(i, j + 1, n)` `        ``== 1) {` `        ``return` `1;` `    ``}` `  `  `    ``Console.WriteLine();` `  `  `    ``// Recursive call for changing` `    ``// the rows` `    ``return` `printPattern(i + 1, 0, n);` `}` `  `  `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `N = 9;` `  `  `    ``// Function Call` `    ``printPattern(0, 0, N);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

```\*******/
*\*****/*
**\***/**
***\*/***
****/****
***/*\***
**/***\**
*/*****\*
/*******\```

Time Complexity: O(N2), as we are making recursive calls for n times, and each time the loop is executed for n times.
Auxiliary Space: 0(1), as no extra space is used.

My Personal Notes arrow_drop_up
Related Articles