Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

What is 32-bit integer in JavaScript?

I was doing some coding challenges and encountered something I am not too familiar with. I am more curious to learn what it is and why it is there.

The prompt is pretty straightforward:

Given a 32-bit signed integer, reverse digits of an integer.

Example: Input: -123 Output: -321  Example:     Input: 120 Output: 21  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. 

I came up with this.

var reverse = function(x) {     var isNegative = false;     if(x < 0){         isNegative = true;         x *= -1;     };     var reverseX = parseInt(String(x).split('').reverse((a,b) => a - b).join(''));     if(reverseX > Math.pow(2,32)){       return 0;     }     if(isNegative){         return -1 * reverseX     } else {         return reverseX;     } }; 

However, I am stumped with some of the failing tests:

Input: 1563847412 Output: 2147483651 Expected: 0 

To my understanding, 32 bit integer is 2^32. What is its significance in JS and what happen if I started going over? (2^32 + 1)

My second question, if I may ask two, is I "anticipated" if value of reverseX exceeds 2^32, but it is still failing the test.

if (reverseX > Math.pow(2, 32)) {   return 0; } 

How can I appropriately return 0 when I exceeded 32-bit integer?

like image 959
Iggy Avatar asked Dec 01 '17 19:12

Iggy


People also ask

Is JavaScript a 32-bit?

JavaScript Uses 32 bits Bitwise Operands JavaScript stores numbers as 64 bits floating point numbers, but all bitwise operations are performed on 32 bits binary numbers.

What is a 32-bit integer?

A signed integer is a 32-bit datum that encodes an integer in the range [-2147483648 to 2147483647]. An unsigned integer is a 32-bit datum that encodes a nonnegative integer in the range [0 to 4294967295]. The signed integer is represented in twos complement notation.

How many bits is integer in JS?

The JavaScript Number type is a double-precision 64-bit binary format IEEE 754 value, like double in Java or C#.

What is JavaScript integer?

For the specification, integer only means that the numbers don't have a decimal fraction, and 32-bit means that they are within a certain range. For engines, 32-bit integer means that an actual integer (non-floating-point) representation can usually be introduced or maintained.


1 Answers

The upper bound of a signed integer is not 232 - 1, but 231 - 1, since the first bit is the sign bit.

If you make that comparison, you'll see your test gives the right result.

Be aware that JavaScript uses IEEE-754 floating point representation for numbers, even when they are integers. But the precision of floating point is more than enough to perform exact calculations on 32-bit integers. As you realised, you'll need to make the necessary test to detect 32-bit overflow.

Some notes about your code: it passes an argument to the Array#reverse method, which is a method that does not take an argument. Here is how I would write it -- see comments in code:

// Name argument n instead of x, as that latter is commonly used for decimal numbers   function reverse(n) {      // Array#reverse method takes no argument.      // You can use `Math.abs()` instead of changing the sign if negative.      // Conversion of string to number can be done with unary plus operator.      var reverseN = +String(Math.abs(n)).split('').reverse().join('');      // Use a number constant instead of calculating the power      if (reverseN > 0x7FFFFFFF) {          return 0;      }      // As we did not change the sign, you can do without the boolean isNegative.      // Don't multiply with -1, just use the unary minus operator.      // The ternary operator might interest you as well (you could even use it      //    to combine the above return into one return statement)      return n < 0 ? -reverseN : reverseN;  }    console.log(reverse(-123));  console.log(reverse(1563847412));

More efficient

Conversion to string, splitting and joining are relatively expensive operations in comparison with simple arithmetic operations. And so it will be more time (and memory) efficient to solve the problem like this:

function reverse(n) {      var reverseN = 0;      var sign = n < 0;      n = Math.abs(n);      while (n) {          reverseN = reverseN*10 + (n % 10);          n = Math.floor(n/10);      }      return reverseN > 0x7FFFFFFF ? 0 : sign ? -reverseN : reverseN;  }    console.log(reverse(-123));  console.log(reverse(1563847412));
like image 154
trincot Avatar answered Sep 24 '22 12:09

trincot