A Number After a Double Reversal - Practice Coding Problems

A Number After a Double Reversal - Problem

Math Easy

Imagine you have a number and you decide to reverse its digits twice. Will you get back to the original number?

When we reverse an integer, we flip all its digits from right to left. For example:

Reversing 2021 gives us 1202
Reversing 12300 gives us 321 (leading zeros disappear!)

The Challenge: Given an integer num, perform these operations:

Reverse num to get reversed1
Reverse reversed1 to get reversed2
Check if reversed2 equals the original num

Return true if they're equal, false otherwise.

This problem tests your understanding of number manipulation and the behavior of leading zeros!

Input & Output

example_1.py — Basic Case

$ Input: num = 526

› Output: true

💡 Note: 526 → 625 → 526. The number returns to its original form because it doesn't end with zero, so no digits are lost during reversal.

example_2.py — Trailing Zero Case

$ Input: num = 1800

› Output: false

💡 Note: 1800 → 0081 → 81. The trailing zeros become leading zeros in the first reversal and disappear, so we get 81 ≠ 1800.

example_3.py — Special Case Zero

$ Input: num = 0

› Output: true

💡 Note: 0 → 0 → 0. Zero remains zero after any number of reversals, so it always returns true.

Visualization

Tap to expand

Understanding the Visualization

Normal Number

Numbers without trailing zeros (like 123) reverse cleanly: 123 → 321 → 123

Trailing Zero Issue

Numbers with trailing zeros (like 120) lose digits: 120 → 021 → 21

Pattern Recognition

Only need to check if the last digit is zero to determine the result

Key Takeaway

🎯 Key Insight: A number survives double reversal if and only if it doesn't end with zero (except 0 itself), because trailing zeros become leading zeros and disappear!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process each digit of the number twice, where the number of digits is log₁₀(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra variables

✓ Linear Space

Constraints

0 ≤ num ≤ 10⁶
Leading zeros are dropped during reversal
The input is always a valid non-negative integer

Asked in

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

The optimal solution recognizes that a number survives double reversal if and only if it doesn't end with zero (except zero itself). This is because trailing zeros become leading zeros during the first reversal and disappear, making it impossible to recover the original number. The solution runs in O(1) time by simply checking num == 0 || num % 10 != 0.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Actually Reverse Twice)	O(log n)	O(1)	Actually perform both reversals and compare with original
Mathematical Pattern Recognition (Optimal)	O(1)	O(1)	Recognize that only numbers ending in zero (except zero itself) fail the double reversal test

Brute Force (Actually Reverse Twice) — Algorithm Steps

Create a function to reverse a number by extracting digits
Reverse the original number to get reversed1
Reverse reversed1 to get reversed2
Compare reversed2 with the original number

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Number

Start with the input number

First Reversal

Extract digits and build reversed number

Second Reversal

Reverse the already reversed number

Comparison

Compare final result with original

Code -

solution.c — C

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

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

bool isSameAfterReversals(int num) {
    if (num == 0) return true;
    
    int reversed1 = reverseNumber(num);
    int reversed2 = reverseNumber(reversed1);
    return reversed2 == num;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process each digit of the number twice, where the number of digits is log₁₀(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra variables

✓ Linear Space

Constraints

0 ≤ num ≤ 10⁶
Leading zeros are dropped during reversal
The input is always a valid non-negative integer

28.7K Views

Medium Frequency

~8 min Avg. Time

892 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 (Actually Reverse Twice) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler