# 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:
\*****/
*\***/*
**\*/**
***/***
**/*\**
*/***\*
/*****\
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 value i for rows and j for column, which iterates from (0, 0) to (N-1, N-1) for printing the require 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 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 column:
```// 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++

 `// 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 ` `        ``// forword 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 ` `        ``// forword 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 ` `        ``# forword 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 ` `        ``// forword 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 `

Output:

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.