Loading…

easyBasicsSometimes asked

Reverse a Number

Basics · 6 min

Given an integer n, return the number formed by reversing its digits. Keep the sign; assume the reversed value fits in a 32-bit integer.

In plain English

Build the reversed number digit by digit: each step shifts the accumulator left by one decimal place and appends the next last digit.

Examples

Example 1

Input: n = 1234
Output: 4321
Note: Digits reversed.

Example 2

Input: n = -120
Output: -21
Note: Sign kept; leading zero of 021 drops.

Example 3

Input: n = 5
Output: 5
Note: Single digit unchanged.

Constraints

-2^31 ≤ n ≤ 2^31 − 1

Clarifying questions2First question: Should I preserve the sign?Explore questions

Q1.Should I preserve the sign?
Yes — reverse the magnitude and reapply the sign.
Q2.What if the reversed number overflows?
LC7 says return 0; I'd guard `rev` before each ×10.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Track the sign, work with the absolute value, and repeatedly do `rev = rev * 10 + n % 10; n /= 10`. Reapply the sign at the end.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can construct a number with the ×10+digit idiom and reason about sign and overflow.

Where candidates slip

Dropping the sign, or overflowing on a reverse that exceeds int range.

How to stand out

Add the pre-multiply overflow check (the LC7 detail) even if the prompt says it fits.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Build reversed via *10

TimeO(d)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Build the result one digit at a time from the input's last digit.

2Hint 2Explore hint

`rev = rev * 10 + n % 10` appends a digit; `n /= 10` advances.

3Hint 3Explore hint

Track the sign separately and think about whether the reversed value can overflow.

A · Core idea

Build the reversed number digit by digit: rev = rev * 10 + n % 10 pulls the current last digit of n and appends it to rev, while n /= 10 advances. Repeat until n is gone.

Why `rev * 10 + digit` builds a number. Multiplying by 10 shifts every existing digit one place left (opening a units slot), and adding the new digit fills that slot. Feeding digits from the right of n appends them to the right of rev — which reverses the order. This 'accumulator × base + digit' is the universal way to construct a number left-to-right.

Why trailing zeros vanish. For 120, the digits fed in are 0, 2, 1. The leading 0 contributes 0*10 + 0 = 0, so it never becomes a stored leading zero — you get 21, which is the conventional answer.

Sign and overflow. Save the sign, reverse the absolute value, reapply the sign. In production, reversing can overflow (reverse of 2,000,000,003 exceeds int), so a robust version checks rev against the limit before each rev*10. Mentioning that guard earns credit even when the prompt promises it fits.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

n = 1234

digit 4

rev = 0*10 + 4

Staterev = 4, n = 123

Final result4321

C · Code with teaching comments

solution.javaJava

Build reversed via *10 — optimal

2 teaching notes

1
public int reverse(int n) {
2
    int sign = n < 0 ? -1 : 1;
3
    n = Math.abs(n);
4
    int rev = 0;
5
    while (n > 0) {
6
        // Shift the accumulator and append the next digit.
7
        rev = rev * 10 + n % 10;
8
        n /= 10;
9
    }
10
    // Reapply the original sign.
11
    return sign * rev;
12
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.12 lines

D · Why it works and complexityO(d) timeO(1) spaceOpen the invariant and proofExplore the proof

In production you'd also guard against overflow before rev * 10 + digit; mentioning that earns credit even if the prompt promises it fits.

ComplexityO(d) time, O(1) space — one multiply/add per digit, with a single accumulator — proportional to the digit count.

E · Edge cases and pitfalls5n = -120 — Sign saved; reverse of 120 is 21; result -21 (trailing zero dropped).Explore edge cases

Edge cases handled

n = -120Sign saved; reverse of 120 is 21; result -21 (trailing zero dropped).
n = 5Single digit reverses to itself.
n = 1000Reverses to 1; leading zeros never stored.

Pitfalls

Losing the sign on negative inputs.
Ignoring overflow when the reversed value can exceed the type's range.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int reverse(int n) { int sign = n < 0 ? -1 : 1; n = Math.abs(n); int rev = 0; while (n > 0) {Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Losing the sign on negative inputs.
Ignoring overflow when the reversed value can exceed int range.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Digit build-up (`rev*10 + d`)

Code pattern to memorize

rev = rev*10 + n%10;  n /= 10

Rules to remember

1Save sign, use abs.
2rev = rev*10 + n%10.
3Trailing zeros disappear.

Use this pattern when

Reversing digits
Building any number left-to-right from a digit stream

Interview takeaway

`acc * 10 + digit` is how you build any number left-to-right.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Digit build-up (`rev*10 + d`). Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Reverse Integer (with overflow)
Coming soon
Same idiom but return 0 on 32-bit overflow.
Palindrome Number
Reverse and compare to the original.

Same pattern

easyBasicsSometimes asked

Reverse a Number

Basics · 6 min

Given an integer n, return the number formed by reversing its digits. Keep the sign; assume the reversed value fits in a 32-bit integer.

In plain English

Build the reversed number digit by digit: each step shifts the accumulator left by one decimal place and appends the next last digit.

Examples

Example 1

Input: n = 1234
Output: 4321
Note: Digits reversed.

Example 2

Input: n = -120
Output: -21
Note: Sign kept; leading zero of 021 drops.

Example 3

Input: n = 5
Output: 5
Note: Single digit unchanged.

Constraints

-2^31 ≤ n ≤ 2^31 − 1

Clarifying questions2First question: Should I preserve the sign?Explore questions

Q1.Should I preserve the sign?
Yes — reverse the magnitude and reapply the sign.
Q2.What if the reversed number overflows?
LC7 says return 0; I'd guard `rev` before each ×10.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Track the sign, work with the absolute value, and repeatedly do `rev = rev * 10 + n % 10; n /= 10`. Reapply the sign at the end.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can construct a number with the ×10+digit idiom and reason about sign and overflow.

Where candidates slip

Dropping the sign, or overflowing on a reverse that exceeds int range.

How to stand out

Add the pre-multiply overflow check (the LC7 detail) even if the prompt says it fits.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Build reversed via *10

TimeO(d)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Build the result one digit at a time from the input's last digit.

2Hint 2Explore hint

`rev = rev * 10 + n % 10` appends a digit; `n /= 10` advances.

3Hint 3Explore hint

Track the sign separately and think about whether the reversed value can overflow.

A · Core idea

Build the reversed number digit by digit: rev = rev * 10 + n % 10 pulls the current last digit of n and appends it to rev, while n /= 10 advances. Repeat until n is gone.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

n = 1234

digit 4

rev = 0*10 + 4

Staterev = 4, n = 123

Final result4321

C · Code with teaching comments

solution.javaJava

Build reversed via *10 — optimal

2 teaching notes

1
public int reverse(int n) {
2
    int sign = n < 0 ? -1 : 1;
3
    n = Math.abs(n);
4
    int rev = 0;
5
    while (n > 0) {
6
        // Shift the accumulator and append the next digit.
7
        rev = rev * 10 + n % 10;
8
        n /= 10;
9
    }
10
    // Reapply the original sign.
11
    return sign * rev;
12
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.12 lines

D · Why it works and complexityO(d) timeO(1) spaceOpen the invariant and proofExplore the proof

In production you'd also guard against overflow before rev * 10 + digit; mentioning that earns credit even if the prompt promises it fits.

ComplexityO(d) time, O(1) space — one multiply/add per digit, with a single accumulator — proportional to the digit count.

E · Edge cases and pitfalls5n = -120 — Sign saved; reverse of 120 is 21; result -21 (trailing zero dropped).Explore edge cases

Edge cases handled

n = -120Sign saved; reverse of 120 is 21; result -21 (trailing zero dropped).
n = 5Single digit reverses to itself.
n = 1000Reverses to 1; leading zeros never stored.

Pitfalls

Losing the sign on negative inputs.
Ignoring overflow when the reversed value can exceed the type's range.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int reverse(int n) { int sign = n < 0 ? -1 : 1; n = Math.abs(n); int rev = 0; while (n > 0) {Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Losing the sign on negative inputs.
Ignoring overflow when the reversed value can exceed int range.

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Digit build-up (`rev*10 + d`)

Code pattern to memorize

rev = rev*10 + n%10;  n /= 10

Rules to remember

1Save sign, use abs.
2rev = rev*10 + n%10.
3Trailing zeros disappear.

Use this pattern when

Reversing digits
Building any number left-to-right from a digit stream

Interview takeaway

`acc * 10 + digit` is how you build any number left-to-right.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Digit build-up (`rev*10 + d`). Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Reverse Integer (with overflow)
Coming soon
Same idiom but return 0 on 32-bit overflow.
Palindrome Number
Reverse and compare to the original.

Same pattern