Count even length binary sequences with same sum of first and second half bits

Print a pattern without using any loop

Last Updated : 24 Feb, 2025

Given a number n, print the following pattern without using any loop.

n, n-5, n-10, …, 0, 5, 10, …, n+5, n

Examples :

Input: n = 16
Output: 16, 11, 6, 1, -4, 1, 6, 11, 16

Input: n = 10
Output: 10, 5, 0, 5, 10

We strongly recommend that you click here and practice it, before moving on to the solution.

Print a pattern without using any loop (using recursion):

Follow the given steps to solve the problem:

Create a recursive function with parameters as n and m and flag variable set as true
Print m and if the flag is false and the value of m is equal to n then return from the function
If the flag is true then check
- If m-5 is greater than zero then recur for m-5
- Else recur for m-5 and set the flag to false, as now we will be moving backward
Else recur for m+5

Below is the implementation of the above approach:

C++

// C++ program to print pattern that first reduces 5 one
// by one, then adds 5. Without any loop
#include <bits/stdc++.h>
using namespace std;

// Recursive function to print the pattern.
// n indicates input value
// m indicates current value to be printed
// flag indicates whether we need to add 5 or
// subtract 5. Initially flag is true.
void printPattern(int n, int m, bool flag)
{
    // Print m.
    cout << m << " ";

    // If we are moving back toward the n and
    // we have reached there, then we are done
    if (flag == false && n == m)
        return;

    // If we are moving toward 0 or negative.
    if (flag) {
        // If m is greater, than 5, recur with true flag
        if (m - 5 > 0)
            printPattern(n, m - 5, true);
        else // recur with false flag
            printPattern(n, m - 5, false);
    }
    else // If flag is false.
        printPattern(n, m + 5, false);
}

// Recursive function to print the pattern
// variance where m is the input int32 value
void PrintPattern(int m)
{
    if (m > 0) {
        cout << m << '\n';
        PrintPattern(m - 5);
    }

    cout << m << '\n';
}

// Driver code
int main()
{
    int n = 16;
    
      // Function call
    PrintPattern(n);
    return 0;
}

Java

// Java program to print pattern that first reduces 5 one
// by one, then adds 5. Without any loop
import java.io.*;

class GFG {

    // Recursive function to print the pattern.
    // n indicates input value
    // m indicates current value to be printed
    // flag indicates whether we need to add 5 or
    // subtract 5. Initially flag is true.
    static void printPattern(int n, int m, boolean flag)
    {

        // Print m.
        System.out.print(m + " ");

        // If we are moving back toward the n and
        // we have reached there, then we are done
        if (flag == false && n == m)
            return;

        // If we are moving toward 0 or negative.
        if (flag) {

            // If m is greater, than 5, recur with
            // true flag
            if (m - 5 > 0)
                printPattern(n, m - 5, true);

            else // recur with false flag
                printPattern(n, m - 5, false);
        }

        else // If flag is false.
            printPattern(n, m + 5, false);
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 16;
      
          // Function call
        printPattern(n, n, true);
    }
}
// This code is contributed by vt_m

Python3

# Python program to print pattern
# that first reduces 5 one by one,
# then adds 5. Without any loop.

# Recursive function to print
# the pattern.n indicates
# input value m indicates
# current value to be printed
# flag indicates whether we
# need to add 5 or subtract 5.
# Initially flag is True.


def printPattern(n, m, flag):

    # Print m.
    print(m)

    # If we are moving back
    # toward the n and we
    # have reached there,
    # then we are done
    if flag == False and n == m:
        return
    # If we are moving
    # toward 0 or negative.
    if flag:
        # If m is greater, than 5,
        # recur with true flag
        if m - 5 > 0:
            printPattern(n, m - 5, True)
        else:  # recur with false flag
            printPattern(n, m - 5, False)
    else:  # If flag is false.
        printPattern(n, m + 5, False)


# Driver Code
if __name__ == "__main__":
  n = 16

  # Function call
  printPattern(n, n, True)

# This code is contributed
# by HrushikeshChoudhary

C#

// C# program to print pattern that first reduces 5 one
// by one, then adds 5. Without any loop
using System;

class GFG {

    // Recursive function to print the pattern.
    // n indicates input value
    // m indicates current value to be printed
    // flag indicates whether we need to add 5 or
    // subtract 5. Initially flag is true.
    static void printPattern(int n, int m, bool flag)
    {

        // Print m.
        Console.Write(m + " ");

        // If we are moving back toward the n and
        // we have reached there, then we are done
        if (flag == false && n == m)
            return;

        // If we are moving toward 0 or negative.
        if (flag) {

            // If m is greater, then 5, recur with
            // true flag
            if (m - 5 > 0)
                printPattern(n, m - 5, true);

            else // recur with false flag
                printPattern(n, m - 5, false);
        }

        else // If flag is false.
            printPattern(n, m + 5, false);
    }

    // Driver code
    public static void Main()
    {
        int n = 16;
          
          // Function call
        printPattern(n, n, true);
    }
}
// This code is contributed by vt_m

JavaScript

<script>

// Javascript program to print pattern that
// first reduces 5 one by one, then adds 5. 
// Without any loop

// Recursive function to print the pattern.
// n indicates input value m indicates current
// value to be printed flag indicates whether
// we need to add 5 or subtract 5. Initially
// flag is true.
function printPattern(n, m, flag)
{
    
    // Print m.
    document.write(m + " ");

    // If we are moving back toward the n and
    // we have reached there, then we are done
    if (flag == false && n == m)
        return;

    // If we are moving toward 0 or negative.
    if (flag)
    {
        
        // If m is greater, than 5, recur with 
        // true flag
        if (m - 5 > 0)
            printPattern(n, m - 5, true);
            
        // Recur with false flag
        else 
            printPattern(n, m - 5, false);
    }
    
    // If flag is false.
    else
        printPattern(n, m + 5, false);
}

// Driver code 
let n = 16;
printPattern(n, n, true);

// This code is contributed by divyeshrabadiya07

</script>

PHP

<?php 
// PHP program to print pattern 
// that first reduces 5 one by one, 
// then adds 5. Without any loop 

// Recursive function to print 
// the pattern. n indicates input 
// value m indicates current value 
// to be printed flag indicates whether 
// we need to add 5 or subtract 5. 
// Initially flag is true. 
function printPattern($n, $m, $flag) 
{ 
    // Print m. 
    echo $m ," "; 
    
    // If we are moving back 
    // toward the n and we 
    // have reached there, 
    // then we are done 
    if ($flag == false && $n == $m) 
        return; 
    
    // If we are moving 
    // toward 0 or negative. 
    if ($flag) 
    { 
    // If m is greater, than 5, 
    // recur with true flag 
    if ($m - 5 > 0) 
        printPattern($n, $m - 5, true); 
    
    // recur with false flag 
    else
        printPattern($n, $m - 5, false); 
    } 
    
    // If flag is false. 
    else
        printPattern($n, $m + 5, false); 
} 

// Driver Code 
$n = 16;

// Function call
printPattern($n, $n, true); 

// This code is contributed by m_kit 
?>

Output

Time Complexity: O(N)
Auxiliary Space: O(N), stack space for the recursion

Print a pattern without using any loop and extra variable:

To solve the problem follow the below idea:

The above program works fine and prints the desired out but uses extra variables. We can use two print statements. The first one before the recursive call prints all decreasing sequences. The second one after the recursive call to print the increasing sequence

Below is the implementation of the above approach:

C++

// C++ program to print pattern that first reduces 5 one
// by one, then adds 5. Without any loop an extra variable.
#include <iostream>
using namespace std;

// Recursive function to print the pattern without any extra
// variable
void printPattern(int n)
{
    // Base case (When n becomes 0 or negative)
    if (n == 0 || n < 0) {
        cout << n << " ";
        return;
    }

    // First print decreasing order
    cout << n << " ";
    printPattern(n - 5);

    // Then print increasing order
    cout << n << " ";
}

// Driver code
int main()
{
    int n = 16;
  
      // Function call
    printPattern(n);
    return 0;
}

Java

// Java program to print pattern that first
// reduces 5 one by one, then adds 5.
// Without any loop an extra variable.

import java.io.*;

class GFG {

    // Recursive function to print the
    // pattern without any extra variable
    static void printPattern(int n)
    {

        // Base case (When n becomes 0 or
        // negative)
        if (n == 0 || n < 0) {

            System.out.print(n + " ");

            return;
        }

        // First print decreasing order
        System.out.print(n + " ");

        printPattern(n - 5);

        // Then print increasing order
        System.out.print(n + " ");
    }

    // Driver code
    public static void main(String[] args)
    {

        int n = 16;

          // Function call
        printPattern(n);
    }
}

// This code is contributed by vt_m

Python3

# Python3 program to print pattern that
# first reduces 5 one by one, then adds 5.
# Without any loop an extra variable.

# Recursive function to print the pattern
# without any extra variable


def printPattern(n):

    # Base case (When n becomes 0 or negative)
    if (n == 0 or n < 0):
        print(n, end=", ")
        return

    # First print decreasing order
    print(n, end=", ")
    printPattern(n - 5)

    # Then print increasing order
    print(n, end=", ")


# Driver Code
if __name__ == "__main__":
  n = 16

  # Function call
  printPattern(n)

# This code is contributed by
# Mohit kumar 29

C#

// C# program to print pattern that first
// reduces 5 one by one, then adds 5.
// Without any loop an extra variable.

using System;

class GFG {

    // Recursive function to print the
    // pattern without any extra variable
    static void printPattern(int n)
    {

        // Base case (When n becomes 0 or
        // negative)
        if (n == 0 || n < 0) {

            Console.Write(n + " ");

            return;
        }

        // First print decreasing order
        Console.Write(n + " ");

        printPattern(n - 5);

        // Then print increasing order
        Console.Write(n + " ");
    }

    // Driver code
    public static void Main()
    {

        int n = 16;

          // Function call
        printPattern(n);
    }
}

// This code is contributed by vt_m

JavaScript

<script>
    // Javascript program to print pattern that first reduces 5 one
    // by one, then adds 5. Without any loop an extra variable.
    
    // Recursive function to print the pattern without any extra
    // variable
    function printPattern(n)
    {
    
        // Base case (When n becomes 0 or negative)
        if (n == 0 || n < 0)
        {
            document.write(n + ", ");
            return;
        }

        // First print decreasing order
        document.write(n + ", ");
        printPattern(n - 5);

        // Then print increasing order
        document.write(n + ", ");
    }
    
    let n = 16;
    printPattern(n);
    
    // This code is contributed by suresh07.
</script>

PHP

<?php 
// PHP program to print pattern 
// that first reduces 5 one 
// by one, then adds 5. Without 
// any loop an extra variable. 

// Recursive function to print the 
// pattern without any extra variable 
function printPattern( $n) 
{ 
    
    // Base case (When n becomes 
    // 0 or negative) 
    if ($n == 0 or $n < 0) 
    { 
        echo $n , " "; 
        return; 
    } 
    
    // First print decreasing order 
    echo $n , " "; 
    printPattern($n-5); 

    // Then print increasing order 
    echo $n , " "; 
} 

    // Driver Code 
    $n = 16; 

    // Function call
    printPattern($n); 

// This code is contributed by anuj_67. 
?>

Output

16 11 6 1 -4 1 6 11 16

Time Complexity: O(N)
Auxiliary Space: O(N), stack space for the recursion

Thanks to AKSHAY RATHORE for suggesting the above solution.

Count even length binary sequences with same sum of first and second half bits

G

Gautham

Improve

Article Tags :

Practice Tags :

Similar Reads

Print 1 to n without using loops

You are given an integer n. Print numbers from 1 to n without the help of loops. Examples: Input: N = 5Output: 1 2 3 4 5Explanation: We have to print numbers from 1 to 5. Input: N = 10Output: 1 2 3 4 5 6 7 8 9 10Explanation: We have to print numbers from 1 to 10. Approach: Using RecursionTo solve th

Print a String in wave pattern

Given a string, you need to transform this string in the form of a wave pattern Examples: Input : GeeksforGeeks, 2 Output : G e s o G e s e k f r e k Input : GeeksforGeeks, 4 Output : G o s e f r k e s G e k e C/C++ Code // CPP program to print wave pattern // of a given string // This is a modified

Print N to 1 without loop

You are given an integer N. Print numbers from N to 1 without the help of loops. Examples: Input: N = 5Output: 5 4 3 2 1Explanation: We have to print numbers from 5 to 1. Input: N = 10Output: 10 9 8 7 6 5 4 3 2 1Explanation: We have to print numbers from 10 to 1. Approach: If we take a look at this

How to learn Pattern printing easily?

The task is to print a pattern as shown in the example for a given integer value.The goal is not to print just this one pattern, it is to learn the best approach to solve this kind of problems as these questions are frequently asked in coding exams and in job interviews.Examples: Input: N = 4 Output

Program to Print a Pattern of Numbers

The idea of pattern based programs is to understand the concept of nesting of for loops and how and where to place the alphabets / numbers / stars to make the desired pattern.Write to program to print the pattern of numbers in the following manner using for loop 1 232 34543 4567654567898765In almost

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

Print 1 to 100 in C++ Without Loops and Recursion

We can print 1 to 100 without using loops and recursion using three approaches discussed below: 1) Template Metaprogramming: Templates in C++ allow non-datatypes also as parameters. Non-datatype means a value, not a datatype. Example: C/C++ Code // CPP Program to print 1 to 100 // without loops and

Printing Heart Pattern in C

How to print below heart pattern in C? AAAAAAA AAAAAA AAAAAAAAA AAAAAAAA AAAAAAAAAAA AAAAAAAAAA AAAAAAAAAAAAA AAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAA BBBBBBBBBBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBBBBBB BBBBBBBBBBBBBBBBB

Print lower triangle with alternate '*' and '#'

Given a number N which denotes the number of rows, the task is to follow the below pattern to print the first N rows of it. Pattern: **#*#**#*#*#*#* Examples: Input: N = 2Output:**# Input: N = 6Output: **#*#**#*#*#*#**#*#*# Approach: Follow the below steps to implement the above pattern: Initialize

Print the Alphabets A to Z in Star Pattern

Given any alphabet between A to Z, the task is to print the pattern of the given alphabet using star. Examples: Input: A Output: ** * * ****** * * * * Input: P Output: ***** * * ***** * * Approach: The code to print each alphabet is created in a separate function. Use switch statement to call the de