Reversible numbers

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 <iostream>
#include <cmath>
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 <iostream>
#include <cmath>
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?