Skip to content
Related Articles

Related Articles

Improve Article

Recursive program to print all numbers less than N which consist of digits 1 or 3 only

  • Difficulty Level : Easy
  • Last Updated : 01 Jun, 2021

Given an integer N, the task is to print all the numbers ≤ N which have their digits as only 1 or 3.
Examples: 
 

Input: N = 10 
Output: 3 1
Input: N = 20 
Output: 13 11 3 1 
 

 

Approach: 
 

  • First, check if the number is greater than 0. If yes then proceed further, else program is terminated.
  • Check for the presence of digits 1 or 3 at each place of the number.
  • If we find 1 or 3 at every place of the number then print the number. Now, check for the next number by using a recursive call for a number one less than the current number.

Below is the implementation of the above approach: 
 



C++




// C++ implementation of the approach
#include <iostream>
using namespace std;
 
// Recursive function to print the desired numbers
void printNumbers(int N)
{
 
    // Bool variable to track whether each digit of
    // the number fulfills the given condition
    bool flag = 1;
 
    // Creating a copy of the number
    int x = N;
 
    // Checking if the number has a positive value
    if (N > 0) {
 
        // Loop to iterate through digits
        // of the number until every digit
        // fulfills the given condition
        while (x > 0 && flag == 1) {
 
            // Get last digit
            int digit = x % 10;
 
            // Updating value of flag to be 0 if
            // the digit is neither 1 nor 3
            if (digit != 1 && digit != 3)
                flag = 0;
 
            // Eliminate last digit
            x = x / 10;
        }
 
        // If N consists of digits 1 or 3 only
        if (flag == 1)
            cout << N << " ";
 
        // Recursive call for the next number
        printNumbers(N - 1);
    }
}
 
// Driver code
int main()
{
    int N = 20;
    printNumbers(N);
    return 0;
}

Java




// Java implementation of the above approach
 
class GFG
{
     
    // Recursive function to print the desired numbers
    static void printNumbers(int N)
    {
         
        // flag variable to track whether each digit of
        // the number fulfills the given condition
        int flag = 1;
 
        // Creating a copy of the number
        int x = N;
 
        // Checking if the number has a positive value
        if (N > 0)
        {
             
            // Loop to iterate through digits
            // of the number until every digit
            // fulfills the given condition
            while (x > 0 && flag == 1)
            {
                // Get last digit
                int digit = x % 10;
 
                // Updating value of flag to be 0 if
                // the digit is neither 1 nor 3
                if (digit != 1 && digit != 3)
                {
                    flag = 0;
                }
 
                // Eliminate last digit
                x = x / 10;
            }
 
            // If N consists of digits 1 or 3 only
            if (flag == 1) {
                System.out.print(N + " ");
            }
 
            // Recursive call for the next number
            printNumbers(N - 1);
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = 20;
        printNumbers(N);
    }
}
 
// This code is contributed by PrinciRaj1992

Python3




# Python 3 implementation of the approach
 
# Recursive function to print the
# desired numbers
def printNumbers(N):
     
    # Bool variable to track whether each digit
    # of the number fulfills the given condition
    flag = 1
 
    # Creating a copy of the number
    x = N
 
    # Checking if the number has a
    # positive value
    if (N > 0):
         
        # Loop to iterate through digits
        # of the number until every digit
        # fulfills the given condition
        while (x > 0 and flag == 1):
             
            # Get last digit
            digit = x % 10
 
            # Updating value of flag to be 0 if
            # the digit is neither 1 nor 3
            if (digit != 1 and digit != 3):
                flag = 0
 
            # Eliminate last digit
            x = x // 10
 
        # If N consists of digits 1 or 3 only
        if (flag == 1):
            print(N, end = " ")
 
        # Recursive call for the next number
        printNumbers(N - 1)
 
# Driver code
if __name__ == '__main__':
    N = 20
    printNumbers(N)
     
# This code is contributed by
# Surendra_Gangwar

C#




// C# implementation of the above approach
using System;
 
class GFG
{
    // Recursive function to print the desired numbers
    static void printNumbers(int N)
    {
        // flag variable to track whether each digit of
        // the number fulfills the given condition
        int flag = 1;
     
        // Creating a copy of the number
        int x = N;
     
        // Checking if the number has a positive value
        if (N > 0)
        {
            // Loop to iterate through digits
            // of the number until every digit
            // fulfills the given condition
            while (x > 0 && flag == 1)
            {
                // Get last digit
                int digit = x % 10;
     
                // Updating value of flag to be 0 if
                // the digit is neither 1 nor 3
                if (digit != 1 && digit != 3)
                    flag = 0;
     
                // Eliminate last digit
                x = x / 10;
            }
     
            // If N consists of digits 1 or 3 only
            if (flag == 1)
                Console.Write(N + " ");
     
            // Recursive call for the next number
            printNumbers(N - 1);
        }
    }
     
     
    // Driver code
    public static void Main()
    {
            int N = 20;
            printNumbers(N);
    }
}
 
 // This code is contributed by Ryuga

PHP




<?php
// PHP implementation of the above approach
 
// Recursive function to print the
// desired numbers
function printNumbers($N)
{
 
    // Bool variable to track whether each
    // digit of the number fulfills the
    // given condition
    $flag = 1;
 
    // Creating a copy of the number
    $x = $N;
 
    // Checking if the number has a
    // positive value
    if ($N > 0)
    {
 
        // Loop to iterate through digits
        // of the number until every digit
        // fulfills the given condition
        while ((int)$x > 0 && $flag == 1)
        {
 
            // Get last digit
            $digit = $x % 10;
             
            // Updating value of flag to be 0
            // if the digit is neither 1 nor 3
            if ($digit != 1 && $digit != 3)
                $flag = 0;
 
            // Eliminate last digit
            $x = $x / 10;
        }
         
        // If N consists of digits 1 or 3 only
        if ($flag == 1)
        {
            echo $N ;
            echo " ";
        }
 
        // Recursive call for the next number
        printNumbers($N - 1);
    }
}
 
// Driver code
$N = 20;
printNumbers($N);
 
// This code is contributed
// by Arnab Kundu
?>

Javascript




<script>
 
    // JavaScript implementation of the above approach
     
    // Recursive function to print the desired numbers
    function printNumbers(N)
    {
        // flag variable to track whether each digit of
        // the number fulfills the given condition
        let flag = 1;
       
        // Creating a copy of the number
        let x = N;
       
        // Checking if the number has a positive value
        if (N > 0)
        {
            // Loop to iterate through digits
            // of the number until every digit
            // fulfills the given condition
            while (x > 0 && flag == 1)
            {
                // Get last digit
                let digit = x % 10;
       
                // Updating value of flag to be 0 if
                // the digit is neither 1 nor 3
                if (digit != 1 && digit != 3)
                    flag = 0;
       
                // Eliminate last digit
                x = parseInt(x / 10, 10);
            }
       
            // If N consists of digits 1 or 3 only
            if (flag == 1)
                document.write(N + " ");
       
            // Recursive call for the next number
            printNumbers(N - 1);
        }
    }
     
    let N = 20;
      printNumbers(N);
     
</script>
Output: 
13 11 3 1

 

Note that the idea of this post to explain a recursive solution there exist a better approach to solve this problem. We can use queue to solve this efficiently. Please refer Count of Binary Digit numbers smaller than N for details of efficient approach.
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :