Sum of Number and Its Reverse - Practice Coding Problems

Sum of Number and Its Reverse - Problem

Math Enumeration Medium

Sum of Number and Its Reverse presents an intriguing mathematical puzzle. Given a non-negative integer num, you need to determine if num can be expressed as the sum of any non-negative integer and its reverse.

For example, consider num = 443. We can express this as 181 + 181 (where 181 reversed is also 181), or as 205 + 238 (where 238 reversed is 832, but let's check: 205 reversed is 502, and 205 + 502 = 707, not 443). The key insight is that we need to find any number x such that x + reverse(x) = num.

Your task is to return true if such a number exists, false otherwise. This problem tests your understanding of number manipulation and mathematical reasoning.

Input & Output

example_1.py — Basic Case

$ Input: num = 443

› Output: true

💡 Note: We can express 443 as 218 + 812, where 812 is 218 reversed (wait, that's 1030, let me recalculate). Actually, 443 = 181 + 262, where 262 is close but not exactly 181 reversed. Let me find the correct pair: 443 can be written as 218 + 225, but 225 ≠ reverse(218). The correct answer: 443 = 234 + 209, where reverse(234) = 432, so 234 + 432 = 666 ≠ 443. Actually, let's verify: 181 + reverse(181) = 181 + 181 = 362. We need to find x such that x + reverse(x) = 443.

example_2.py — Palindrome Case

$ Input: num = 181

› Output: true

💡 Note: 181 can be expressed as the sum of any palindromic number that when added to itself equals 181. However, since 181 is odd, we need 90.5 + 90.5, but we need integers. Let's check: we can have 90 + 91 = 181, and reverse(90) = 09 = 9, reverse(91) = 19. So 90 + 9 = 99 ≠ 181. Actually, we can verify that 163 + reverse(163) = 163 + 361 = 524 ≠ 181. The correct approach is to find that 108 + reverse(108) = 108 + 801 = 909 ≠ 181. Let me recalculate: we need to systematically check.

example_3.py — Small Number

$ Input: num = 0

› Output: true

💡 Note: 0 can be expressed as 0 + reverse(0) = 0 + 0 = 0. This is trivially true.

Visualization

Tap to expand

Understanding the Visualization

Set Up Investigation

We have our target number and need to find if any number plus its reverse equals it

Check Each Suspect

Starting from 0, we test each number as a potential candidate

Mirror Test

For each candidate, we create its mirror image (reverse digits)

Solve the Case

If candidate + mirror = target, we found our answer!

Key Takeaway

🎯 Key Insight: We can solve this systematically by checking each number from 0 to our target. The search space is bounded, making brute force feasible for reasonable input sizes.

Time & Space Complexity

Time Complexity

⏱️

O(n × log n)

We iterate through n numbers, and for each number, reversing takes O(log n) time

⚡ Linearithmic

Space Complexity

O(1)

We only use a constant amount of extra space for variables

✓ Linear Space

Constraints

0 ≤ num ≤ 10⁵
The input is always a non-negative integer
You need to find if any non-negative integer x exists such that x + reverse(x) = num

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses brute force enumeration with a key insight: we only need to check numbers from 0 to num. For each candidate x, we calculate reverse(x) and check if x + reverse(x) = num. The time complexity is O(n × log n) where the log factor comes from digit reversal operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(n × log n)	O(1)	Check every possible number from 0 to num to see if it plus its reverse equals num

Brute Force Enumeration — Algorithm Steps

Iterate through all numbers from 0 to num
For each number x, calculate reverse(x)
Check if x + reverse(x) equals num
If found, return true; if no number works, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Search

Begin checking from x = 0

Calculate Reverse

For each x, compute reverse(x)

Check Sum

Test if x + reverse(x) equals target

Found or Continue

Return true if found, continue otherwise

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int reverseNumber(int n) {
    int reversed = 0;
    while (n > 0) {
        reversed = reversed * 10 + n % 10;
        n /= 10;
    }
    return reversed;
}

bool sumOfNumberAndReverse(int num) {
    for (int x = 0; x <= num; x++) {
        if (x + reverseNumber(x) == num) {
            return true;
        }
    }
    return false;
}

int main() {
    int num;
    scanf("%d", &num);
    printf("%s\n", sumOfNumberAndReverse(num) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log n)

We iterate through n numbers, and for each number, reversing takes O(log n) time

⚡ Linearithmic

Space Complexity

O(1)

We only use a constant amount of extra space for variables

✓ Linear Space

Constraints

0 ≤ num ≤ 10⁵
The input is always a non-negative integer
You need to find if any non-negative integer x exists such that x + reverse(x) = num

28.5K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler