Reverse decimal digits in javascript

How do I reverse the digits of a number using bitwise?

input:

x = 123; 

o开发者_如何学编程utput:

x = 321; 

How Do this?

That's not inverting bits; that's reversing the order of decimal digits, which is completely different. Here's one way:

var x = 123;
var y = 0;
for(; x; x = Math.floor(x / 10)) {
    y *= 10;
    y += x % 10;
}
x = y;

If you actually want to invert bits, it's:

x = ~x;

As a function:

function reverse(n) {
    for(var r = 0; n; n = Math.floor(n / 10)) {
        r *= 10;
        r += n % 10;
    }
    return r;
}

If you wanted to make a simple reversal:

var x = 123;
var y = x.toString();
var z = y.split("").reverse().join("");
var aa = Number(z);
document.write(aa);

http://jsfiddle.net/jasongennaro/gV39e/

Here is another way...

var reversed = num.toString().split('').reverse().join('');

jsFiddle.

If you wanted it again as a Number, use parseInt(reversed, 10). Keep in mind though, leading 0s are not significant in a decimal number, and you will lose them if you convert to Number.

you also use this function

function myfunction(a){
   var x=a.toString();
   var y= x.split("");
   var z=y.reverse();
   var result=z.join("");
     return result;

} myfunction(123);

Simple and quick solution: Let's assume that you want to reverse a number 4546. You will take the reminder from each division by 10 and append it to the result until the number is > 0. And simultaneously updating the num variable by dividing it by 10.

var x = '';
var num = 4546;
while(num>0){
 x = x + (num%10);
 num = parseInt(num/10);
}
console.log(x);

Reversing The Positive/ Negative Integer Number

function reverseInt(n) {
 return parseInt(n.toString().split('').reverse().join()) * Math.sign(n)
}

If n is -5, then Math.sign(n)==> will return -1

If n is 5, then Math.sign(n)==> will return 1

Here are reversible array functions in JavaScript that handle integers or strings:

function reverse(array)
{
    var left = null;
    var right = null;
    var length = array.length;
    for (left = 0, right = length - 1; left < right; left += 1, right -= 1)
    {
        var temporary = array[left];
        array[left] = array[right];
        array[right] = temporary;
    }
    return array;
}

function toDigitsArrayFromInteger(integer, isReverse)
{
    var digits = [];

    if (integer > 0)
    {
        var floor = window.Math.floor;
        while (integer > 0)
        {
            digits.push(floor(integer % 10));
            integer = floor(integer / 10);
        }

        // Array is populated in reverse order. Un-reverse it to make it normal.
        if (!isReverse)
        {
            digits = reverse(digits);
        }
    }
    else if (integer < 0)
    {
        digits = toDigitsArrayFromInteger(-integer, isReverse);
    }
    else if (integer === 0)
    {
        digits.push(0);
    }

    return digits;
}

function toDigitsArrayFromString(string, isReverse)
{
    var digits = [];

    string += ""; // Coerce to string.

    var i = null;
    var length = string.length;
    for (i = 0; i < length; i += 1)
    {
        var integer = parseInt(string.charAt(i), 10);
        if (isFinite(integer))
        {
            digits.push(integer);
        }
    }

    if (isReverse)
    {
        digits = reverse(digits);
    }

    return digits;
}

Once you have the digits as an array, you can reverse the array easily to get the digits starting from the left or from the right.

The string function is more versatile because it can find any digit in a string, whereas the integer function is limited to integers.

Benchmarks: http://jsperf.com/todigitsarray

The benchmarks between the two functions show that in Firefox 10 and Chrome 12, the string function is 30% to 60% faster than the integer function. In Opera 12, the integer function is slightly faster by about 10%.

//reverse integer
const revInt = (num)=>{
  //turn into string
  if(Math.sign(num)===1)
    return parseInt(num.toString().split('').reverse().join(''));
  else return -1*parseInt(num.toString().split('').reverse().join(''));
}

console.log(revInt(-501));

<html>
<script>

function reverseInt(n){

        var r=0;
    while(n!=0){
        r*=10;
        r+=n%10;
        n=Math.floor(n/10);
}
return r;
}


</script>
</html>

try this

var n = 352;
function loop(n, r){
    if(!n) return r;
    r = (r ? r * 10 : 0) + n % 10;
    return loop(Math.floor( n / 10), r);
}
console.log(loop(n));

OK, how about using and chaining these popular tricks in JavaScript in one-line function as below...

const reverseNum = num => +("" + ~~num.split("").reverse().join(""));

And call it like these:

reverseNum(123); //321
reverseNum(423.09); //324
reverseNum(23305.1); //50332
reverseNum(89112); //21198
reverseNum(568434.2389); //434865

This takes Number x as a parameter and returns the reversed number.

const reverse = (x) => Number(x.toString().split("").reverse().join(""));

Memory Usage: 35.3 MB, less than 100.00% of JavaScript online submissions for Reverse Integer on leetcode.com. Runtime: 80 ms, faster than 61.48% of JavaScript online submissions for Reverse Integer.

Time complexity is O(log10(n)).

function reverse(x) {
  let rev = 0;
  const isNegative = Math.sign(x) === -1;
  const isOverflow = n => n > 2**31;
  x = Math.abs(x);

  while (x) {
    let pop = x % 10;
    x = Math.floor(x / 10);
    rev = rev * 10 + pop;

    if (isOverflow(rev)) {
      return 0;
    } 
  }

  return isNegative ? rev * -1 : rev;
}

The code block below should do the trick

<script type = "text/javascript">

var input;

input=window.prompt ("Please enter a number to be reversed.");
x=input.length;

while(x > 0)
{

x=x-1;
document.write(input[x]);

}

</script>