reverse num

Author: rohan-paul

solutions/reverse_integer.js

@@ -2,8 +2,6 @@
 
 Given a 32-bit signed integer, reverse digits of an integer.
 
-Example 1:
-
 Input: 123
 Output:  321
 Example 2:
@@ -15,41 +13,100 @@ Example 3:
 Input: 120
 Output: 21
 Note:
-Assume we are dealing with an environment which could only hold integers within the 32-bit signed integer range. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.*/
+Assume we are dealing with an environment which could only hold integers within the 32-bit signed integer range. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.
+
+'Overflows' here means the resultant number is more than the greatest number that can be handled in JS or less than the min number that can be handled in js
 
-// My solution
+The upper bound of a signed integer is not 2^32 - 1, but 2^31 - 1, since the first bit is the sign bit.
+And lower bound is -(2^31 - 1)
+*/
+
+// SOLUTION-1 My solution
 var reverse = function(x) {
 	var reversedX = +Math.abs(x).toString().split('').reverse().join('');
 	return reversedX > 2147483647 ? 0 : x < 0 ? -reversedX : reversedX;
 }
 
-// console.log(reverse(123));
+// console.log(reverse(123));  // => 321
+
+// console.log(reverse(-123));  // => -321
 
-//Best Performing solution. And also if the Problems asks for not to use any string related methods.
+// // SOLUTION-2 - Best Performing solution. And also if the Problems asks for not to use any string related methods.
 var reverseBest = function(x) {
 	var y = Math.abs(x);
 	var result = 0;
 
-	while (y !== 0) {
-		var result = (result * 10) + y % 10;		
+	while (y) {
+		var result = (result * 10) + y % 10;
 		y = parseInt(y / 10);
 		// console.log(y);
 	}
 
 
 	x > 0 ? result = result : result = -result;
-	if (result > 2147483648 || result < -2147483648) return 0;
-	return result
-
+    if (result > 2147483648 || result < -2147483648) return 0;
+    return result;
 }
 
-console.log(reverseBest(123));
+// console.log(reverseBest(123)); // => 321
+// console.log(reverseBest(-123)); // => -321
+// console.log(reverseBest( 1534236469 )) // => 0
+
+/*My note on the above best solution -
+
+FIRST - I have to pick up the last digit and bring it forward
 
-/*My note on the above best solution - The mod will return the remainder, i.e. the last digit for each iteration, starting with the last digit then the last to last and so on. So, in case of x - 123, after first iteration y % 10 will return 3, then 2, then 1
-And then in the parseInt(y/10) will consecutively return 12, 1 and then 0
+So, I use modulo operator to hook to the last digit. The mod will return the remainder, i.e. the last digit for each iteration, starting with the last digit then the last to last and so on.
+
+So, in case of x = 123, after first iteration y % 10 will return 3, then 2, then 1
+
+SECOND - And then, I need to extract the rest of the digits.
+
+So I do, parseInt(y/10), which will always return an integer leaving out the last decimal positions. So for for my case of 123 ( parseInt(123/10) and then parseInt(12/10) and then parseInt(1/10))  will consecutively return 12, 1 and then 0
 
 So, after the first execution of the iteration, the value of result will be like below
+
 0 + 3
 (3 * 10) + 2
 (32 * 10 ) + 1
-*/
+
+
+****************************************
+The parseInt() function parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems.
+
+parseInt(string, radix);
+
+string - The value to parse. If the string argument is not a string, then it is converted to a string (using the ToString abstract operation). Leading whitespace in the string argument is ignored.
+
+radix  An integer between 2 and 36 that represents the radix (the base in mathematical numeral systems) of the above mentioned string.
+
+Return value - An integer number parsed from the given string. If the first character cannot be converted to a number, NaN is returned.
+
+parseInt(15.99, 10); // => 15
+
+parseInt('15,123', 10); // => 15
+
+*/
+
+// SOLUTION-3 - Almost similar to SOL-1 except using toString() but anyway converting to string with '
+
+const reverseNum = x => {
+
+    let result = 0;
+
+    if (x < 0) {
+        // For this case, slice the string after the first "-" sign. Else I will get a NaN
+        result = -(('' + x).slice(1).split('').reverse().join(''));
+    } else {
+        result = +(('' + x).split('').reverse().join(''));
+    }
+
+    // In split() and join() I have to pass the delimiter of an empty string as '' - Else tit will be an error.
+
+    return (result < (-Math.pow(2,31)) || result > (Math.pow(2,31) -1) )  ? 0 : result
+    // Note the syntax above for the ternary operator above as compared to the SOL-1 and 2. Here, I am using just a single return statement. And
+}
+
+console.log(reverseNum(123)); // => 321
+console.log(reverseNum(-123)); // => -321
+console.log(reverseNum( 1534236469 )) // => 0