Python Programs to Reverse an Integer Number

This article discussed several ways to reverse an integer number in Python. It is helpful to check if the number is a palindrome.

Let’s discuss each of them in detail with examples using Python.

1. How to reverse an integer number in Python

Code Example

num = 123456
# Convert the integer to string and reverse it using slicing
reversed_str = str(num)[::-1]

# Handle negative numbers
if num < 0:
    reversed_int = int('-' + reversed_str[:-1])  # Exclude the last character which is '-'
else:
    reversed_int = int(reversed_str)

print('Reversed Integer:', reversed_int)Code language: Python (python)

Output:

Reversed Integer: 654321Code language: Python (python)

2. Using a Mathematical Approach

The mathematical approach to reversing an integer involves extracting each digit from the number and building a new reversed number. This method does not rely on converting the number into a string but instead uses modulus (%) and division (//) operations.

Understanding how digits are extracted:
Consider a number 1234. To extract the last digit, we use:

• Modulus operator (% 10): 1234 % 10 = 4 (Extract the last digit)
• Floor division (// 10): 1234 // 10 = 123 (Remove the last digit)

Using this approach, we can extract each digit one by one.

Constructing the reversed number:

We initialize a variable reversed_num = 0. To build the reversed number, we follow this pattern:

• Multiply reversed_num by 10 to shift digits to the left.
• Add the extracted digit.

Handling Negative Numbers: If the number is negative, we can:

• Reverse it using the same logic.
• Restore the negative sign at the end.

For example, let’s reverse 1234:

Code Example

num = 123456
reversed_int = 0
negative = num < 0
num = abs(num)

while num != 0:
    reversed_int = reversed_int * 10 + num % 10 # Extract the last digit and append it to the reversed number
    num //= 10     # Remove the last digit

if negative:
    reversed_int = -reversed_int    # Restore sign if negative

print('Reversed Integer:', reversed_int)

# Output: 
# Reversed Integer: 654321Code language: Python (python)

3. Using Recursion

Recursion is a method where a function calls itself to break down a problem into smaller subproblems. To reverse an integer recursively, we use the same mathematical formula discussed in the above approach, where we extract digits one by one and construct the reversed number in each recursive call.

Understanding the Recursive Approach:

To reverse a number n, we need to:

1. Extract the last digit (n % 10).
2. Reduce the number (n // 10).
3. Accumulate the extracted digits in reverse order.

For example, reversing 1234 using recursion follows this pattern:

The recursion stops when n == 0 (base case).

Code Example

def reverse_int(n, rev=0):
    if n == 0:
        return rev
    else:
        return reverse_int(n // 10, rev * 10 + n % 10)

print('Reversed Integer:', reverse_int(123456))

# Output: 
# Reversed Integer: 654321Code language: Python (python)

4. Using List Reversal

A list reversal approach involves converting the integer into a list of its digits, reversing the order of the list, and then converting it back to an integer. This method utilizes Python’s built-in list manipulation capabilities, such as list() and reverse(), to efficiently reverse the digits.

num = 123456
sign = -1 if num < 0 else 1
n = abs(num)

digits = list(str(num))   # Convert string to list
digits.reverse()      # Reverse the list

reverse_int = sign * int(''.join(digits))   # Convert list to string and then convert string to integer

print('Reversed Integer:', reverse_int)

# Output: 
# Reversed Integer: 654321Code language: Python (python)

Explanation

• Handle negative number: check if num is negative:
  • If num < 0, sign = -1 (negative number).
  • Otherwise, sign = 1 (positive number).
  • Since num = 123456 (positive), sign = 1.
• Convert the Number to a List of Characters:
  • str(num) converts 123456 into the string ‘123456’.
  • list(str(num)) converts ‘123456’ into a list: digits = ['1', '2', '3', '4', '5', '6']
• Reverse the List:
  • The reverse() method reverses the list in place, modifying digits = ['6', '5', '4', '3', '2', '1']
• Convert the Reversed List Back to an Integer:
  • ''.join(digits) joins the list back into a string: ‘654321’
  • int('654321') converts the string back to an integer: 654321
• Adjust the sign: Multiply by sign: reverse_int = 1 * 654321. Since sign = 1

Summary

Each of these methods can reverse an integer in Python. The choice of method may depend on your specific needs, such as readability, performance, etc.

• Using String Slicing ([::-1])
  • Advantage: Simple and concise.
  • Time Complexity: O(d), where d is the number of digits.
  • Space Complexity: O(d), since a new string is created, where d = number of digits
• Using a Mathematical Approach
  • Advantage: Most efficient approach. No string conversion, reducing memory usage.
  • Time Complexity: O(log n), since each loop iteration removes one digit.
  • Space Complexity: O(1), as no extra storage is needed.
• Using List Reversal
  • Advantage: Uses Python’s built-in list operations. Easy to understand.
  • Time Complexity: O(d), due to list reversal.
  • Space Complexity: O(d), since the list stores digits.
• Using Recursion
  • Advantage: A structured and elegant solution.
  • Time Complexity: O(log n), since each recursive call removes one digit.
  • Space Complexity: O(log n), due to the recursive call stack.