Open In App

Print Triangle separated pattern

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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(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.



Last Updated : 04 Aug, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads