Reversible numbers (original) (raw)

Last Updated : 12 Sep, 2023

A number is said to be a reversible if sum of the number and its reverse had only odd digits. The problem is to find out if a number is reversible or not.

Examples:

Input: 36 Output: Reversible number as 36 + 63 = 99 has only odd digits.

Input: 409 Output: Reversible number as 409 + 904 = 1313 has only odd digits.

Input: 35 Output: Not Reversible number as 35 + 53 = 88 has only odd digits

Naive Method

Calculate reverse of each number and add it to the number. If the resultant is reversible increment the value of count. Calculate this for every number from 1 to n.

Time complexity: O(10^n) as it should calculate reverse of each number.

Advance method

• 1 digit number: Any one digit number will add to itself, which always be an even number, And thus there are no solutions.
• 2 digits number: Both digits must be odd.
  • If a+b > 10 ,then we have a carryover and thus the first digit of the result will have a different parity than the second digit.
  • So, Solutions can only be formed where a+b < 10 and a + b is odd. So, total 20 such numbers are possible.
• 3 digits number:
  • The middle digit needs to be added to itself. That means that the third digit must have a carryover and be odd.
  • Since the third digit is odd the first digit is odd as well if the second digit does not have a carryover, which happens when the second digit is less than 5, which gives us 20 choices for the first/third digit set and 5 options for the middle.So, totals 100 pairs.
• 4 digits number: There are two pairs, say the inner and outer pair.
  • If the inner pair has carryover then the outer pair must also have carryover.
  • Otherwise, the two inner pairs will have different parity.
  • If the inner pair has carryover then the outer pair will have different parity since the first digit will end up with a carry over which the last digit would not get.
  • Therefore we have solutions only when none of the pairs have carry over.
  • In total: For the outer pair, this gives us the 20 choices we have seen in the two digit case. And it gives us 30 cases for the inner pair since they can also contain a zero.
    Or in total we get 20*30 = 600 solutions.
• 5, 9, 13.. digits number: No solution as 1-digit number.
• 6, 8, 10.. digits number: Same as 2-digits number i.e. if n = 2*k then total solution = 20*30^(k-1).
• 7, 11, 15.. digits number: Same as 3-digits number i.e if n = 4k + 3 then total solution = 100*500^(k).

Generalizing the Solution:

• All even numbered digits(2, 4, 6, 8..) have the same formula so we can generalize
  that for some integer k such that n = 2k we have 20*30^(k-1) solutions
  which represents the outer pair along with all the inner pairs.
• For n (3, 7, 11..) of form 4k + 3 (k is an integer), we have that the middle digit and
  the outer pair gives us 5 and 20 options, as in the case of 3 digit number.
  Then we have sets of internal pairs which gives us 20 and 25 solutions.
  So that means we can generalize it to 20*5*(20*25)^(k) = 100*500^(k).
• For n of form 4k+ 1 which means 1, 5, 9.. none of these have any solutions.

Program To check if a number is reversible or not

C++ `

// C++ program to check if a given // number is reversible or not #include #include using namespace std;

// Function to check reversible number void checkReversible (int n) { int rev = 0, rem;

// Calculate reverse of n
int flag = n;
while (flag)
{
    rem = flag % 10;
    rev *= 10;
    rev += rem;
    flag /= 10;
}

// Calculate sum of number
// and its reverse
int sum = rev + n;

// Check for reverse number
// reach digit must be odd
while (sum && (rem % 2 != 0))
{
    rem = sum % 10;
    sum /= 10;
}

if (sum == 0)
    cout << "Reversible Number";
else
    cout << "Non-Reversible Number";

}

// Driver function int main() { int n = 36; checkReversible(n); return 0; }

Java

// Java program to check if a given // number is reversible or not import java.io.*;

class GFG {

// Function to check reversible number
static void checkReversible (int n)
{
    int rev = 0, rem = 0;

    // Calculate reverse of n
    int flag = n;
    while (flag>0)
    {
        rem = flag % 10;
        rev *= 10;
        rev += rem;
        flag /= 10;
    }

    // Calculate sum of number
    // and its reverse
    int sum = rev + n;

    // Check for reverse number
    // reach digit must be odd
    while (sum > 0 && (rem % 2 != 0))
    {
        rem = sum % 10;
        sum /= 10;
    }

    if (sum == 0)
        System.out.println("Reversible Number");
    else
        System.out.println("Non-Reversible Number");
}

// Driver function
public static void main (String[] args)
{
    int n = 36;
    checkReversible(n);
    
}

} // This code is contributed by vt_m.

Python3

Python3 program to check if a given

number is reversible or not

Function to check reversible number

def checkReversible (n):

rev = 0

# Calculate reverse of n
flag = n

while (flag != 0):
    rem = flag % 10
    rev *= 10
    rev += rem
    flag //= 10

# Calculate sum of number
# and its reverse
sum = rev + n

# Check for reverse number
# reach digit must be odd
while (sum and ((rem % 2) != 0)):
    rem = sum % 10
    sum //= 10

if (sum == 0):
    print("Reversible Number")
else:
    print("Non-Reversible Number")

Driver Code

n = 36

checkReversible(n)

This code is contributed by sanjoy_62

C#

// C# program to check if a given // number is reversible or not using System;

class GFG {

// Function to check reversible number
static void checkReversible (int n)
{
    int rev = 0, rem = 0;

    // Calculate reverse of n
    int flag = n;
    while (flag > 0)
    {
        rem = flag % 10;
        rev *= 10;
        rev += rem;
        flag /= 10;
    }

    // Calculate sum of number
    // and its reverse
    int sum = rev + n;

    // Check for reverse number
    // reach digit must be odd
    while (sum > 0 && (rem % 2 != 0))
    {
        rem = sum % 10;
        sum /= 10;
    }

    if (sum == 0)
    Console.WriteLine("Reversible Number");
    else
    Console.WriteLine("Non-Reversible Number");
}

// Driver function
public static void Main () 
{
    int n = 36;
      checkReversible(n);
    
}

}

// This code is contributed by vt_m.

JavaScript

// JavaScript program to check if a given // number is reversible or not

// Function to check reversible number function checkReversible (n) {
var rev = 0;

// Calculate reverse of n
var flag = n;

while (flag != 0)
{
    rem = flag % 10
    rev *= 10
    rev += rem
    flag = Math.floor(flag / 10);
} 

// Calculate sum of number
// and its reverse
var sum = rev + n;

// Check for reverse number
// reach digit must be odd
while (sum && ((rem % 2) != 0))
{
    rem = sum % 10
    sum = Math.floor(sum / 10);
}

if (sum == 0)
    console.log("Reversible Number")
else
    console.log("Non-Reversible Number")

}

// Driver Code let n = 36 checkReversible(n);

// This code is contributed by phasing17

`

Output:

Reversible Number

Time complexity: O(log N) where N is no of digits of number n

Program To count total reversible numbers upto n

C++ `

// C++ program to find the count of // reversible numbers upto a given number n #include #include using namespace std;

// Function to calculate the count of reversible number void countReversible (int n) { int count = 0;

// Calculate counts of
// reversible number of 1 to n-digits
for ( int i = 1; i <= n; i++)
{
    // All four possible cases and their formula
    switch (i % 4)
    {

    // for i of form 2k
    case 0:
    case 2:
        count += 20 * pow( 30, ( i / 2 - 1));
        break;

    // for i of form 4k + 3
    case 3:
        count += 100 * pow ( 500, i / 4 );
        break;

    // for i of form 4k + 1 no solution
    case 1:
        break;
    }
}
cout << count;

}

// Driver function int main() { // count up-to 9 digit numbers (1 billion) int n = 9; countReversible(n); return 0; }

Java

// Java program to find the count of // reversible numbers upto a given number n import java.io.*;

class GFG {

// Function to calculate the count 
// of reversible number
static void countReversible (int n)
{
    int count = 0;

    // Calculate counts of
    // reversible number of 1 to n-digits
    for ( int i = 1; i <= n; i++)
    {
        // All four possible cases 
        // and their formula
        switch (i % 4)
        {

        // for i of form 2k
        case 0:
        case 2:
            count += 20 * Math.pow( 30, ( i / 2 - 1));
            break;

        // for i of form 4k + 3
        case 3:
            count += 100 * Math.pow ( 500, i / 4 );
            break;

        // for i of form 4k + 1 no solution
        case 1:
            break;
        }
    }
    System.out.println(count);
}

// Driver function
public static void main (String[] args)
{
    // count up-to 9 digit numbers (1 billion)
    int n = 9;
    countReversible(n);
    
}

} // This code is contributed by vt_m.

Python3

Python3 program to find the count of

reversible numbers upto a given number n

Function to calculate the count of reversible number

def countReversible (n): count = 0;

# Calculate counts of
# reversible number of 1 to n-digits
for i in range(1, n + 1):

    # All four possible cases and their formula
    case =  i % 4
    

    # for i of form 2k
    if case == 0 or case == 2:
        count += 20 * pow( 30, ( i // 2 - 1));

    # for i of form 4k + 3
    elif case == 3:
        count += 100 * pow ( 500, (i // 4) );

    # for i of form 4k + 1 no solution
    elif case == 1:
        pass;
    
print(count);

Driver function

count up-to 9 digit numbers (1 billion)

n = 9; countReversible(n);

This code is contributed by phasing17

C#

// C# program to find the count of // reversible numbers upto a given number n using System;

class GFG {

// Function to calculate the 
// count of reversible number
static void countReversible (int n)
{
    int count = 0;

    // Calculate counts of
    // reversible number of 1 to n-digits
    for ( int i = 1; i <= n; i++)
    {
        // All four possible cases 
        // and their formula
        switch (i % 4)
        {

        // for i of form 2k
        case 0:
        case 2:
            count += 20 * (int)Math.Pow( 30, ( i / 2 - 1));
            break;

        // for i of form 4k + 3
        case 3:
            count += 100 * (int)Math.Pow ( 500, i / 4 );
            break;

        // for i of form 4k + 1 no solution
        case 1:
            break;
        }
    }
    Console.WriteLine(count);
}

// Driver function
public static void Main () 
{
    // count up-to 9 digit numbers (1 billion)
    int n = 9;
    countReversible(n);
    
}

}

// This code is contributed by vt_m.

JavaScript

// JavaScript program to find the count of // reversible numbers upto a given number n

// Function to calculate the count of reversible number function countReversible (n) { let count = 0;

// Calculate counts of
// reversible number of 1 to n-digits
for (let i = 1; i <= n; i++)
{
    // All four possible cases and their formula
    switch (i % 4)
    {

    // for i of form 2k
    case 0:
    case 2:
        count += 20 * Math.pow( 30, Math.floor( i / 2 - 1));
        break;

    // for i of form 4k + 3
    case 3:
        count += 100 * Math.pow ( 500, Math.floor(i / 4) );
        break;

    // for i of form 4k + 1 no solution
    case 1:
        break;
    }
}
console.log (count);

}

// Driver function

// count up-to 9 digit numbers (1 billion) let n = 9; countReversible(n);

// This code is contributed by phasing17

`

Output:

608720

Time complexity : O(nlogn)
Auxiliary Space : O(1)

Reference : Project Euler 145: How many reversible numbers are there below one-billion?