Sum Palindrome: Reverse and Add Until Palindrome

Given a positive integer n, repeatedly reverse its digits and add the reversed number to the original number. If the resulting number becomes a palindrome within 5 iterations, return that palindrome. Otherwise, return -1.

Examples: 

Input: n = 23
Output: 55
Explanation: reverse(23) = 32, then 32+23 = 55 which is a palindrome.

Input: n = 73
Output: 121
Explanation: reverse(73) = 37, then 37+73 = 110 which is not a palindrome, again reverse(110)= 011, then 110+11 = 121 which is a palindrome.

[Expected Approach] Reverse and Add Until Palindrome - O(log n) Time and O(1) Space

The idea is to repeatedly reverse the digits of the current number and add the reversed value to it.

After each addition, check whether the resulting number is a palindrome.

If a palindrome is found within 5 iterations, return it; otherwise, return -1.

Working of the Approach:

• First, check if the given number is already a palindrome. If yes, return it.
• Repeat the process for at most 5 iterations.
• Reverse the digits of the current number using arithmetic operations.
• Add the reversed number to the current number.
• Check whether the resulting number is a palindrome by reversing it and comparing both values.
• If it is a palindrome, return the number immediately.
• If no palindrome is obtained after 5 iterations, return -1.

#include <bits/stdc++.h>
using namespace std;

long long reverseNumber(long long n) {
    long long rev = 0;

    while (n > 0) {
        rev = rev * 10 + n % 10;
        n /= 10;
    }

    return rev;
}

bool isPalindrome(long long n) {
    return n == reverseNumber(n);
}

long long isSumPalindrome(long long n) {
    if (isPalindrome(n))
        return n;

    for (int i = 0; i < 5; i++) {
        n += reverseNumber(n);

        if (isPalindrome(n))
            return n;
    }

    return -1;
}

int main() {
    long long n = 73;

    cout << isSumPalindrome(n);

    return 0;
}

class GFG {

    static long reverseNumber(long n) {
        long rev = 0;

        while (n > 0) {
            rev = rev * 10 + n % 10;
            n /= 10;
        }

        return rev;
    }

    static boolean isPalindrome(long n) {
        return n == reverseNumber(n);
    }

    static long isSumPalindrome(long n) {
        if (isPalindrome(n))
            return n;

        for (int i = 0; i < 5; i++) {
            n += reverseNumber(n);

            if (isPalindrome(n))
                return n;
        }

        return -1;
    }

    public static void main(String[] args) {
        long n = 73;

        System.out.println(isSumPalindrome(n));
    }
}

def reverseNumber(n):
    rev = 0

    while n > 0:
        rev = rev * 10 + n % 10
        n //= 10

    return rev


def isPalindrome(n):
    return n == reverseNumber(n)


def isSumPalindrome(n):
    if isPalindrome(n):
        return n

    for _ in range(5):
        n += reverseNumber(n)

        if isPalindrome(n):
            return n

    return -1


if __name__ == "__main__":
    n = 73

    print(isSumPalindrome(n))

using System;

class GFG
{
    static int reverseNumber(int n)
    {
        int rev = 0;

        while (n > 0)
        {
            rev = rev * 10 + n % 10;
            n /= 10;
        }

        return rev;
    }

    static bool isPalindrome(int n)
    {
        return n == reverseNumber(n);
    }

    static int isSumPalindrome(int n)
    {
        if (isPalindrome(n))
            return n;

        for (int i = 0; i < 5; i++)
        {
            n += reverseNumber(n);

            if (isPalindrome(n))
                return n;
        }

        return -1;
    }

    static void Main()
    {
        int n = 73;

        Console.WriteLine(isSumPalindrome(n));
    }
}

function reverseNumber(n) {
    let rev = 0;

    while (n > 0) {
        rev = rev * 10 + n % 10;
        n = Math.floor(n / 10);
    }

    return rev;
}

function isPalindrome(n) {
    return n === reverseNumber(n);
}

function isSumPalindrome(n) {
    if (isPalindrome(n))
        return n;

    for (let i = 0; i < 5; i++) {
        n += reverseNumber(n);

        if (isPalindrome(n))
            return n;
    }

    return -1;
}

let n = 73;

console.log(isSumPalindrome(n));

121