Reverse Integer

                                            
class Solution {
public:
    int reverse(int x) {
        long long res = 0;
        
        while (x != 0) {
            res = res * 10 + x % 10;
            x /= 10;
        }
        
        return (res < INT_MIN || res > INT_MAX) ? 0 : (int)res;
    }
};

                                            
int reverse(int x) {
    long reversed = 0;
    
    while (x != 0) {
        int digit = x % 10;
        x /= 10;
        
        reversed = reversed * 10 + digit;
        
        if (reversed > INT_MAX || reversed < INT_MIN) {
            return 0;
        }
    }
    
    return (int)reversed;
}

                                            
public class Solution {
    public int Reverse(int x) {
        int reversed = 0;
        
        while (x != 0) {
            int digit = x % 10;
            x /= 10;
            
            if (reversed > int.MaxValue / 10 || (reversed == int.MaxValue / 10 && digit > 7)) return 0;
            if (reversed < int.MinValue / 10 || (reversed == int.MinValue / 10 && digit < -8)) return 0;
            
            reversed = reversed * 10 + digit;
        }
        
        return reversed;
    }
}

                                            
const reverse = function(x) {
    const reversed = parseInt(Math.abs(x).toString().split('').reverse().join('')) * Math.sign(x);
    if (reversed < Math.pow(-2, 31) || reversed > Math.pow(2, 31) - 1) {
        return 0;
    }
    return reversed;
};

                                            
function reverse(x: number): number {
    const limit = 2 ** 31;
    const reversed = parseInt(x.toString().split('').reverse().join(''));
    
    if (x < 0) {
        return reversed > limit ? 0 : -reversed;
    } else {
        return reversed >= limit ? 0 : reversed;
    }
};

                                            
class Solution {
    func reverse(_ x: Int) -> Int {
        var input = x
        var output = 0
        
        while input != 0 {
            let digit = input % 10
            input /= 10
            
            if output > Int32.max / 10 || (output == Int32.max / 10 && digit > 7) {
                return 0
            }
            if output < Int32.min / 10 || (output == Int32.min / 10 && digit < -8) {
                return 0
            }
            
            output = output * 10 + digit
        }
        
        return output
    }
}

                                            
func reverse(x int) int {
    var reversed int
    for x != 0 {
        digit := x % 10
        x /= 10
        reversed = reversed*10 + digit
        
        if reversed > math.MaxInt32 || reversed < math.MinInt32 {
            return 0
        }
    }
    
    return reversed
}

                                            
def reverse(x)
    reversed = x.abs.to_s.reverse.to_i
    reversed = -reversed if x < 0
    return 0 if reversed.bit_length >= 32
    return reversed
end

                                            
object Solution {
    def reverse(x: Int): Int = {
        var reverseNum = 0
        var tempX = x

        while (tempX != 0) {
            val digit = tempX % 10
            tempX = tempX / 10

            if (reverseNum > Int.MaxValue / 10 || (reverseNum == Int.MaxValue / 10 && digit > 7)) return 0
            if (reverseNum < Int.MinValue / 10 || (reverseNum == Int.MinValue / 10 && digit < -8)) return 0

            reverseNum = reverseNum * 10 + digit
        }

        reverseNum
    }
}

                                            
impl Solution {
    pub fn reverse(x: i32) -> i32 {
        let mut rev = 0;
        let mut num = x.abs();

        while num != 0 {
            let digit = num % 10;
            num /= 10;

            if rev > (i32::MAX - digit) / 10 {
                return 0;
            }

            rev = rev * 10 + digit;
        }

        if x < 0 {
            rev *= -1;
        }

        rev
    }
}

To solve this coding challenge, you need to reverse the digits of a 32-bit signed integer while considering edge cases such as the range limits of a 32-bit signed integer. Here's a detailed explanation of how to approach this problem followed by the pseudocode.

Explanation

Problem Breakdown:

Input and Output : You are given an integer
x

and need to return its digits in reverse order. If reversing the integer causes it to fall out of the 32-bit signed integer range (i.e.,
[-2^31, 2^31 - 1]

), return
0

.
32-bit Signed Integer Range : The range for a signed 32-bit integer is from -2,147,483,648 to 2,147,483,647.
Sign Handling : The integer
x

can be negative. The sign should be preserved after reversing the digits.
Edge Cases : Consider what happens if the reversed integer exceeds the 32-bit signed integer limit.

Steps to Solve:

Check for Boundary Conditions : Ensure the input lies within the valid integer range.
Extract and Reverse Digits :

Convert the absolute value of
x

to a string to handle its digits.
Reverse the string.
Convert the reversed string back to an integer.

Preserve the Sign : Multiply the reversed integer by the sign of the original integer.
Check for Overflow : After reversing, check if the resulting integer lies within the 32-bit signed integer range. If it does not, return
0

.

Pseudocode Explanation:

Below is the detailed pseudocode with comments for each step.

                                            
// Function to reverse the digits of a 32-bit signed integer
function reverseInteger(input_integer):
// Define 32-bit signed integer limits
minimum_32_bit_value = -2^31
maximum_32_bit_value = 2^31 - 1

// Store the sign of the input integer
input_sign = sign(input_integer)

// Get the absolute value of the input integer
absolute_integer = abs(input_integer)

// Convert the integer to a string to manipulate its digits
integer_string = convert_to_string(absolute_integer)

// Reverse the string
reversed_string = reverse_string(integer_string)

// Convert the reversed string back to an integer
reversed_integer = convert_to_integer(reversed_string)

// Restore the original sign to the reversed integer
reversed_integer_with_sign = reversed_integer * input_sign

// Check for overflow beyond 32-bit signed integer limits
if reversed_integer_with_sign < minimum_32_bit_value or reversed_integer_with_sign > maximum_32_bit_value:
// Return 0 if it overflows
return 0

// Return the valid reversed integer
return reversed_integer_with_sign

Detailed Steps in Pseudocode:

Define Limits : Integer limits for 32-bits are defined.
Preserve Sign : Store and preserve the sign of the input integer.
Absolute Value : Work with the absolute value of the integer for manipulation.
String Conversion : Convert the integer to a string to easily reverse its digits.
Reverse Digits : Reverse the string containing the digits.
Restore the Integer : Convert the reversed string back to an integer.
Restore the Sign : Re-apply the original sign to the reversed integer.
Check for Overflow : Ensure the result is within the allowed range of a 32-bit signed integer.
Return Result : Return the appropriately signed reversed integer, or
0

if it overflows.

By following this methodology step-by-step, you can effectively reverse the digits of a 32-bit signed integer and handle any potential overflow issues that may arise.