Programs to print Triangle and Diamond patterns using recursion
Last Updated :
03 May, 2023
This article is aimed at giving a recursive implementation for pattern printing.
- Pattern 1: Example:
Input: 5
Output:
* * * * * * * * * *
* * * * * * * *
* * * * * *
* * * *
* *
- Implementation:
C++
#include <iostream>
using namespace std;
void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
cout << "* ";
print_asterisk(asterisk - 1);
}
void print_space(int space)
{
if (space == 0)
return;
cout << " "
<< " ";
print_space(space - 1);
}
void pattern(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
cout << endl;
pattern(n - 1, num);
}
int main()
{
int n = 5;
pattern(n, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
System.out.print("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
System.out.print(" ");
System.out.print(" ");
print_space(space - 1);
}
static void pattern(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
System.out.print("\n");
pattern(n - 1, num);
}
public static void main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
Python3
def print_asterisk(asterisk):
if (asterisk == 0):
return;
print("* ", end = "");
print_asterisk(asterisk - 1);
def print_space(space):
if (space == 0):
return;
print(" ", end = "");
print(" ", end = "");
print_space(space - 1);
def pattern(n, num):
if (n == 0):
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
print("");
pattern(n - 1, num);
if __name__ == '__main__':
n = 5;
pattern(n, n);
|
C#
using System;
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
Console.Write("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
Console.Write(" ");
Console.Write(" ");
print_space(space - 1);
}
static void pattern(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
Console.Write("\n");
pattern(n - 1, num);
}
public static void Main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
JavaScript
<script>
function print_asterisk(asterisk)
{
if (asterisk === 0) return;
document.write("*");
print_asterisk(asterisk - 1);
}
function print_space(space)
{
if (space === 0) return;
document.write("" + "");
print_space(space - 1);
}
function pattern(n, num)
{
if (n === 0) return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
document.write("<br>");
pattern(n - 1, num);
}
var n = 5;
pattern(n, n);
</script>
|
- Output:
* * * * * * * * * *
* * * * * * * *
* * * * * *
* * * *
* *
Time Complexity: O(n),The time complexity of the above code is O(n) as the function is called n times.
Space Complexity: O(n),The space complexity of the above code is O(n) as the recursive call stack is of size n.
- Pattern 2: Example:
Input: 5
Output:
* *
* * * *
* * * * * *
* * * * * * * *
* * * * * * * * * *
- Implementation:
C++
#include <iostream>
using namespace std;
void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
cout << "* ";
print_asterisk(asterisk - 1);
}
void print_space(int space)
{
if (space == 0)
return;
cout << " "
<< " ";
print_space(space - 1);
}
void pattern(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
cout << endl;
pattern(n - 1, num);
}
int main()
{
int n = 5;
pattern(n, n);
return 0;
}
|
Java
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
System.out.print("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
System.out.print(" ");
System.out.print(" ");
print_space(space - 1);
}
static void pattern(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
System.out.println();
pattern(n - 1, num);
}
public static void main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
Python3
def print_asterisk(asterisk):
if (asterisk == 0):
return;
print("*", end = " ");
print_asterisk(asterisk - 1);
def print_space(space):
if (space == 0):
return;
print(" ", end = "");
print(" ", end = "");
print_space(space - 1);
def pattern(n, num):
if (n == 0):
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
print();
pattern(n - 1, num);
if __name__ == '__main__':
n = 5;
pattern(n, n);
|
C#
using System;
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
Console.Write("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
Console.Write(" ");
Console.Write(" ");
print_space(space - 1);
}
static void pattern(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
Console.WriteLine();
pattern(n - 1, num);
}
public static void Main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
JavaScript
<script>
function print_asterisk(asterisk)
{
if (asterisk == 0)
return;
document.write("* ");
print_asterisk(asterisk - 1);
}
function print_space(space)
{
if (space == 0)
return;
document.write("", "", "");
print_space(space - 1);
}
function pattern(n, num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n + 1);
print_asterisk(num - n + 1);
document.write("<br>");
pattern(n - 1, num);
}
var n = 5;
pattern(n, n);
</script>
|
- Output:
* *
* * * *
* * * * * *
* * * * * * * *
* * * * * * * * * *
Time complexity: O(n),The time complexity of the above program is O(n) where n is the number of asterisks in the pattern.
Space complexity: O(n),The space complexity of the above program is O(n) because of the recursive stack that is used for the recursive calls.
- Pattern 3: Example:
Input: 5
Output:
* * * * *
* * * *
* * *
* *
*
*
* *
* * *
* * * *
* * * * *
- Implementation:
C++
#include <iostream>
using namespace std;
void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
cout << "* ";
print_asterisk(asterisk - 1);
}
void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
cout << endl;
pattern_upper(n - 1, num);
}
void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
cout << endl;
pattern_lower(n - 1, num);
}
void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
int main()
{
int n = 5;
pattern(n, n);
return 0;
}
|
Java
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
System.out.print("* ");
print_asterisk(asterisk - 1);
}
static void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
System.out.println();
pattern_upper(n - 1, num);
}
static void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
System.out.println();
pattern_lower(n - 1, num);
}
static void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
public static void main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
Python3
def print_asterisk(asterisk):
if (asterisk == 0):
return;
print("*", end = " ");
print_asterisk(asterisk - 1);
def pattern_upper(n, num):
if (n == 0):
return;
print_asterisk(n);
print();
pattern_upper(n - 1, num);
def pattern_lower(n, num):
if (n == 0):
return;
print_asterisk(num - n + 1);
print();
pattern_lower(n - 1, num);
def pattern(n, num):
pattern_upper(n, num);
pattern_lower(n - 1, num);
if __name__ == '__main__':
n = 5;
pattern(n, n);
|
C#
using System;
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
Console.Write("* ");
print_asterisk(asterisk - 1);
}
static void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
Console.WriteLine();
pattern_upper(n - 1, num);
}
static void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
Console.WriteLine();
pattern_lower(n - 1, num);
}
static void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
public static void Main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
JavaScript
<script>
function print_asterisk(asterisk) {
if (asterisk == 0)
return;
document.write("* ");
print_asterisk(asterisk - 1);
}
function pattern_upper(n , num) {
if (n == 0)
return;
print_asterisk(n);
document.write("<br/>");
pattern_upper(n - 1, num);
}
function pattern_lower(n , num) {
if (n == 0)
return;
print_asterisk(num - n + 1);
document.write("<br/>");
pattern_lower(n - 1, num);
}
function pattern(n , num) {
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
var n = 5;
pattern(n, n);
</script>
|
- Output:
* * * * *
* * * *
* * *
* *
*
*
* *
* * *
* * * *
* * * * *
Time complexity: O(n^2), where n is the input size.
Space complexity: O(n), where n is the input size.
- Pattern 4: Example:
Input: 5
Output:
* * * * * * * * * *
* * * * * * * *
* * * * * *
* * * *
* *
* * * *
* * * * * *
* * * * * * * *
* * * * * * * * * *
- Implementation:
C++
#include <iostream>
using namespace std;
void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
cout << "* ";
print_asterisk(asterisk - 1);
}
void print_space(int space)
{
if (space == 0)
return;
cout << " "
<< " ";
print_space(space - 1);
}
void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
cout << endl;
pattern_upper(n - 1, num);
}
void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
cout << endl;
pattern_lower(n - 1, num);
}
void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
int main()
{
int n = 5;
pattern(n, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
System.out.print("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
System.out.print(" ");
System.out.print(" ");
print_space(space - 1);
}
static void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
System.out.print("\n");
pattern_upper(n - 1, num);
}
static void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
System.out.print("\n");
pattern_lower(n - 1, num);
}
static void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
public static void main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
Python3
def print_asterisk(asterisk):
if (asterisk == 0):
return;
print("* ", end = "");
print_asterisk(asterisk - 1);
def print_space(space):
if (space == 0):
return;
print(" ", end = "");
print(" ", end = "");
print_space(space - 1);
def pattern_upper(n, num):
if (n == 0):
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
print();
pattern_upper(n - 1, num);
def pattern_lower(n, num):
if (n == 0):
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
print();
pattern_lower(n - 1, num);
def pattern(n, num):
pattern_upper(n, num);
pattern_lower(n - 1, num);
if __name__ == '__main__':
n = 5;
pattern(n, n);
|
C#
using System;
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
Console.Write("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
Console.Write(" ");
Console.Write(" ");
print_space(space - 1);
}
static void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
Console.Write("\n");
pattern_upper(n - 1, num);
}
static void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
Console.Write("\n");
pattern_lower(n - 1, num);
}
static void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
public static void Main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
JavaScript
<script>
function print_asterisk(asterisk)
{
if (asterisk == 0)
return;
document.write("* ");
print_asterisk(asterisk - 1);
}
function print_space(space)
{
if (space == 0)
return;
document.write("", "", "");
print_space(space - 1);
}
function pattern_upper( n, num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
document.write("<br>");
pattern_upper(n - 1, num);
}
function pattern_lower(n, num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
document.write("<br>");
pattern_lower(n - 1, num);
}
function pattern(n, num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
n = 5;
pattern(n, n);
</script>
|
- Output:
* * * * * * * * * *
* * * * * * * *
* * * * * *
* * * *
* *
* * * *
* * * * * *
* * * * * * * *
* * * * * * * * * *
- Pattern 5: Example:
Input: 5
Output:
* *
* * * *
* * * * * *
* * * * * * * *
* * * * * * * * * *
* * * * * * * *
* * * * * *
* * * *
* *
- Implementation:
C++
#include <iostream>
using namespace std;
void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
cout << "* ";
print_asterisk(asterisk - 1);
}
void print_space(int space)
{
if (space == 0)
return;
cout << " "
<< " ";
print_space(space - 1);
}
void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
cout << endl;
pattern_upper(n - 1, num);
}
void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
cout << endl;
pattern_lower(n - 1, num);
}
void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
int main()
{
int n = 5;
pattern(n, n);
return 0;
}
|
Java
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
System.out.print("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
System.out.print(" ");
System.out.print(" ");
print_space(space - 1);
}
static void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
System.out.println();
pattern_upper(n - 1, num);
}
static void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
System.out.println();
pattern_lower(n - 1, num);
}
static void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
public static void main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
Python3
def print_asterisk(asterisk):
if (asterisk == 0):
return;
print("* ", end = "");
print_asterisk(asterisk - 1);
def print_space(space):
if (space == 0):
return;
print(" ", end = "");
print(" ", end = "");
print_space(space - 1);
def pattern_upper(n, num):
if (n == 0):
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
print();
pattern_upper(n - 1, num);
def pattern_lower(n, num):
if (n == 0):
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
print();
pattern_lower(n - 1, num);
def pattern(n, num):
pattern_upper(n, num);
pattern_lower(n - 1, num);
if __name__ == '__main__':
n = 5;
pattern(n, n);
|
C#
using System;
class GFG
{
static void print_asterisk(int asterisk)
{
if (asterisk == 0)
return;
Console.Write("* ");
print_asterisk(asterisk - 1);
}
static void print_space(int space)
{
if (space == 0)
return;
Console.Write(" ");
Console.Write(" ");
print_space(space - 1);
}
static void pattern_upper(int n, int num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
Console.WriteLine();
pattern_upper(n - 1, num);
}
static void pattern_lower(int n, int num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
Console.WriteLine();
pattern_lower(n - 1, num);
}
static void pattern(int n, int num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
public static void Main(String[] args)
{
int n = 5;
pattern(n, n);
}
}
|
JavaScript
<script>
function print_asterisk(asterisk)
{
if (asterisk == 0)
return;
document.write("* ");
print_asterisk(asterisk - 1);
}
function print_space(space)
{
if (space == 0)
return;
document.write(" ");
document.write(" ");
print_space(space - 1);
}
function pattern_upper(n,num)
{
if (n == 0)
return;
print_asterisk(num - n + 1);
print_space(2 * n - 1);
print_asterisk(num - n + 1);
document.write("<br>");
pattern_upper(n - 1, num);
}
function pattern_lower(n,num)
{
if (n == 0)
return;
print_asterisk(n);
print_space(2 * (num - n) + 1);
print_asterisk(n);
document.write("<br>");
pattern_lower(n - 1, num);
}
function pattern(n,num)
{
pattern_upper(n, num);
pattern_lower(n - 1, num);
}
let n = 5;
pattern(n, n);
</script>
|
- Output:
* *
* * * *
* * * * * *
* * * * * * * *
* * * * * * * * * *
* * * * * * * *
* * * * * *
* * * *
* *
Similar Reads
Program to print diamond pattern using numbers and stars
Program to print the following pattern of a half diamond for N. Example: Input: N = 5Output: 1 2*3 4*5*6 7*8*9*10 11*12*13*14*15 11*12*13*14*15 7*8*9*10 4*5*6 2*3 1 This program is divided into four parts. C/C++ Code // C++ program to print the half diamond // pattern using numbers and stars #includ
5 min read
Recursive program to print triangular patterns
We have discussed iterative pattern printing in previous post. Examples: Input : 7 Output : * * * * * * * * * * * * * * * * * * * * * * * * * * * * Algorithm:- step 1:- first think for the base condition i.e. number less than 0 step 2:-do the recursive calls till number less than 0 i.e:- printPartte
8 min read
Program to print modified Binary triangle pattern
Given an integer N, the task is to print the modified binary tree pattern. In Modified Binary Triangle Pattern, the first and last element of a Nth row are 1 and the middle (N - 2) elements are 0. Examples: Input: N = 6 Output: 1 11 101 1001 10001 100001Input: N = 3 Output: 1 11 101 Approach: From t
5 min read
Printing the Triangle Pattern using last term N
Given a number N which represents the last term of the Triangle Pattern. The task is to print the Triangle Pattern from 1 to N, such that each row is complete.Triangle Pattern is given as: 1 2 3 4 5 6 7 8 9 10 . . Examples: Input: N = 3 Output: 1 2 3 Input: N = 7 Output: 1 2 3 4 5 6 7 will not be pr
7 min read
Printing triangle star pattern using a single loop
Given a number N, the task is to print the star pattern in single loop. Examples:Â Input: N = 9Output: * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Input: N = 5Output: * * * * * * * * * * * * * * * Please Refer article for printing the pattern in two loop
10 min read
Program to print a rectangle pattern
Given height h and width w, print a rectangular pattern as shown in the example below. Examples: Input : h = 4, w = 5 Output : @@@@@ @ @ @ @ @@@@@ Input : h = 7, w = 9 Output : @@@@@@@@ @ @ @ @ @ @ @ @ @ @ @@@@@@@@ The idea is to run two loops. One for the number of rows to be printed and the other
4 min read
Program to print the pattern with two hollow Triangles
Given a number n, the task is to write a program to draw the following pattern using '$'. $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ Approach: The above pattern is printed by breaking it into smaller patterns: The abo
15+ min read
Program to print binary right angle triangle
Binary right angle triangle consists of only 0's and 1's in alternate positions. Examples : Input : 4 Output : 0 1 0 0 1 0 1 0 1 0 Input : 3 Output : 0 1 0 0 1 0 C/C++ Code // C program to print binary right angle // triangle. #include <stdio.h> // function to print binary right angle // trian
4 min read
Program to print half Diamond star pattern
Given an integer N, the task is to print half-diamond-star pattern. ************************************ Examples: Input: N = 3 Output: * ** *** ** * Input: N = 6 Output: * ** *** **** ***** ****** ***** **** *** ** * Approach: The idea is to break the pattern into two halves that is upper half and
4 min read
Printing pattern with Recursion using Python Turtle
Pre-requisites: Turtle Programming in Python In this article, we are going to display the following pattern using Python Turtle with recursion. In this pattern, the first circle should start with 100-pixel radius, and each subsequent circle is 5 pixels smaller until it reaches radius 10 when the las
2 min read