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 <bits/stdc++.h>
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

<script>
// Javascript program to print the triangle
// separated pattern using
// star and slash character

// Function to print pattern recursively
function printPattern(i,j,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) {
            document.write("/");
        }

        // Condition to print
        // backward slash
        else {
            document.write("\\");
        }
    }

    // Else print '*'
    else {
        document.write("*");
    }

    // Recursive call for rows
    if (printPattern(i, j + 1, n)
        == 1) {
        return 1;
    }

    document.write("<br>");

    // Recursive call for changing
    // the rows
    return printPattern(i + 1, 0, n);
}

// Driver Code

let N = 9;
// Function Call
printPattern(0, 0, N);


// This code is contributed by avanitrachhadiya2155
</script>

Output:

\*******/
*\*****/*
**\***/**
***\*/***
****/****
***/*\***
**/***\**
*/*****\*
/*******\

Time Complexity: O(N²), 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.