Saturday, November 16, 2024
Google search engine
HomeData Modelling & AIPrint Triangle separated pattern

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

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

Dominic Rubhabha-Wardslaus
Dominic Rubhabha-Wardslaushttp://wardslaus.com
infosec,malicious & dos attacks generator, boot rom exploit philanthropist , wild hacker , game developer,
RELATED ARTICLES

Most Popular

Recent Comments