# Reverse Integer solution using TypeScript

Below is my TypeScript solution to the LeetCode "Reverse Integer" question.

Time Complexity: Because each iteration divides the input by 10, the time complexity is O(log10(n)) where n is the inputted value.

Space Complexity: The following approach uses a constant amount of space, making the space complexity O(1).

``````/**
* Given a 32-bit signed integer, reverse digits of an integer.
* If the given number overflows, return 0.
*
* Time Complexity: O(log10(n))
* Space Complexity: O(1)
*
* Input: 123
* Output: 321
*
* Input: -123
* Output: -321
*/
function reverse(x: number): number {
let result = 0;

// if input is negative, make result negative
const multiplier = x < 0 ? -1 : 1;

// number of digits: 6789 = 4
const digits = Math.floor(Math.log10(Math.abs(x)));

for (let i = 0; i <= digits; i++) {
// create a mask: 2345 = 1000, 345 = 100
const mask = Math.floor(Math.pow(10, digits - i));

// get the last digit: 1234 = 4
const last = Math.abs(x) % 10;

// multiple the last digit by most significant place

// trim the last digit: 1234 = 123
x = Math.floor(Math.abs(x) / 10);
}

// 32-bit signed integer overflow results in 0
if (result > 2**31) {
return 0;
} else {
return result * multiplier;
}
}
``````