Open In App

# Print Triangle separated pattern

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.