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

My Personal Notes arrow_drop_up