C# Program to Reverse a Number

Reversing a number is a fundamental programming problem where we reverse the digits of an integer. For example, reversing 12345 gives 54321. This article explores different approaches to reverse a number in C#.

Problem Description

Given an integer, we need to reverse its digits and return the reversed number. The process involves extracting digits from right to left and reconstructing them from left to right.

Examples

Input: 12345
Output: 54321
Explanation: The digits are reversed from their original order.

Input: 8299
Output: 9928
Explanation: The digits 8, 2, 9, 9 become 9, 9, 2, 8.

Using While Loop (Iterative Approach)

This approach uses the modulo operator to extract digits and mathematical operations to build the reversed number

using System;

class Program {
    static int ReverseNumber(int number) {
        int reversed = 0;
        bool isNegative = number < 0;
        number = Math.Abs(number);
        
        while (number != 0) {
            int lastDigit = number % 10;
            reversed = (reversed * 10) + lastDigit;
            number /= 10;
        }
        
        return isNegative ? -reversed : reversed;
    }
    
    static void Main() {
        int number = 12345;
        int result = ReverseNumber(number);
        Console.WriteLine("Original Number: " + number);
        Console.WriteLine("Reversed Number: " + result);
        
        // Test with negative number
        int negativeNum = -8299;
        int negativeResult = ReverseNumber(negativeNum);
        Console.WriteLine("Original Number: " + negativeNum);
        Console.WriteLine("Reversed Number: " + negativeResult);
    }
}

The output of the above code is

Original Number: 12345
Reversed Number: 54321
Original Number: -8299
Reversed Number: -9928

Using Stack Data Structure

A stack follows LIFO (Last In First Out) principle, making it perfect for reversing sequences. We push digits onto the stack and pop them to construct the reversed number

using System;
using System.Collections.Generic;

class Program {
    static int ReverseUsingStack(int number) {
        bool isNegative = number < 0;
        number = Math.Abs(number);
        
        Stack<int> stack = new Stack<int>();
        
        // Push all digits onto stack
        while (number > 0) {
            stack.Push(number % 10);
            number /= 10;
        }
        
        // Pop digits and build reversed number
        int reversed = 0;
        int multiplier = 1;
        
        while (stack.Count > 0) {
            reversed += stack.Pop() * multiplier;
            multiplier *= 10;
        }
        
        return isNegative ? -reversed : reversed;
    }
    
    static void Main() {
        int number = 54321;
        int result = ReverseUsingStack(number);
        Console.WriteLine("Original: " + number);
        Console.WriteLine("Reversed: " + result);
        
        // Test with zero
        Console.WriteLine("Reverse of 0: " + ReverseUsingStack(0));
    }
}

The output of the above code is

Original: 54321
Reversed: 12345
Reverse of 0: 0

Using String Conversion

This approach converts the number to a string, reverses the string, and converts back to integer

using System;

class Program {
    static int ReverseUsingString(int number) {
        bool isNegative = number < 0;
        string numStr = Math.Abs(number).ToString();
        
        // Reverse the string
        char[] charArray = numStr.ToCharArray();
        Array.Reverse(charArray);
        string reversedStr = new string(charArray);
        
        int reversed = int.Parse(reversedStr);
        return isNegative ? -reversed : reversed;
    }
    
    static void Main() {
        int[] testNumbers = { 123, 7890, -456 };
        
        foreach (int num in testNumbers) {
            int reversed = ReverseUsingString(num);
            Console.WriteLine($"Original: {num}, Reversed: {reversed}");
        }
    }
}

The output of the above code is

Original: 123, Reversed: 321
Original: 7890, Reversed: 987
Original: -456, Reversed: -654

Comparison of Approaches

where d is the number of digits in the input number

Conclusion

The while loop approach is most efficient with O(1) space complexity, while the stack method demonstrates LIFO principles clearly. String conversion offers the simplest implementation but uses additional memory for string operations.