Related Articles

# 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 ``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

 ` 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

 ``
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