Inverser les chiffres décimaux en javascript

Comment puis-je inverser les chiffres d'un nombre à l'aide de bit-à-bit?

d'entrée:

x = 123;

de sortie:

x = 321;

Comment Faire?

Voulez-vous dire inverser les bits ou inverser une chaîne de caractères? En inversant les bits de changer de 1 à 0 et vice-versa (valeur binaire).
Tu veux dire "inverser les chiffres après la virgule", pas "inverser les bits"...
Qu'entendez-vous par "bits", bien sûr, tu ne veux pas bits.
Pourquoi il être opérateurs au niveau du bit? Est-ce devoirs?
Reverse digits using bitwise? Vous n'avez pas. Au niveau du bit bascule bits, l'inversion de chiffres réordonne les collections de bits (octets). Elles sont différentes opérations.

OriginalL'auteur The Mask | 2011-06-15

javascript

14

Si vous voulais faire une simple inversion:
```
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/

Donc 1000 et 1 inversé pour le même nombre?
Bon point, @kennebc. Je devrais l'avoir laissé à var z, comme un string mais j'ai été de le convertir en une # à nouveau. N'a pas prévu le 1000. @alex a une solution pour que ci-dessus.
Cela pourrait échouer. E. g ce qui se passe si l'entrée conduit à un dépassement de capacité si vous revers??
si x est entier négatif? si x est -123 résultat devrait être -321. mais dans votre cas, c'est NaN.

OriginalL'auteur Jason Gennaro
19

Ce n'est pas l'inversion de bits; c'est l'inversion de l'ordre de chiffres après la virgule, ce qui est complètement différent. Voici un moyen:
```
var x = 123;
var y = 0;
for(; x; x = Math.floor(x / 10)) {
    y *= 10;
    y += x % 10;
}
x = y;
```
Si vous voulez inverser les bits, c'est:
```
x = ~x;
```
En fonction:
```
function reverse(n) {
    for(var r = 0; n; n = Math.floor(n / 10)) {
        r *= 10;
        r += n % 10;
    }
    return r;
}
```
habituellement, lorsque cette question revient (presque toujours dans une interview) ils attendent que vous pour répondre à cette voie sans avoir à convertir le nombre en une chaîne
Cela ne fonctionne pas pour les décimales.
La plupart des gens ont besoin de le faire avec des nombres entiers. Quelque chose avec une partie décimale est probablement fait mieux (et peut-être même mieux représenté) comme une chaîne de caractères.
Semble à peu près juste, mais j'espérais trouver une solution mathématique pour mon décimal mathématique. Je suis en utilisant un grand nombre de décimales. C'est pour une bonne raison. 🙂

OriginalL'auteur Ry-
6

Ici est d'une autre façon...
```
var reversed = num.toString().split('').reverse().join('');
```
jsFiddle.

Si vous le voulais à nouveau comme un Number, utilisez parseInt(reversed, 10). Gardez à l'esprit, conduisant 0s ne sont pas significatives dans un nombre décimal, et vous allez les perdre si vous vous convertissez à Number.

OriginalL'auteur alex

vous pouvez également utiliser cette fonction

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

}
myfunction(123);

OriginalL'auteur Naresh Kumar

2

Solution Simple et rapide: supposons que vous souhaitez inverser un nombre 4546. Vous pourrez prendre le rappel de chaque division par 10 et l'ajouter à la suite jusqu'à ce que le nombre > 0. Et, simultanément, la mise à jour de la variable num en le divisant par 10.
```
var x = '';
var num = 4546;
while(num>0){
 x = x + (num%10);
 num = parseInt(num/10);
}
console.log(x);
```
OriginalL'auteur Nikhil.Hmath
2

Inversion Positif/Négatif Nombre Entier
```
function reverseInt(n) {
 return parseInt(n.toString().split('').reverse().join()) * Math.sign(n)
}
```
Si n est de 5, puis de Mathématiques.signe(n)==> sera de retour -1

Si n est de 5, puis de Mathématiques.signe(n)==> sera de retour le 1er

OriginalL'auteur bajran

Ici sont réversibles tableau des fonctions en JavaScript qui gèrent des entiers ou des chaînes de caractères:

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;
}

Une fois que vous avez les chiffres dans un tableau, vous pouvez inverser la matrice facilement pour obtenir les chiffres en partant de la gauche ou de la droite.

La fonction de chaîne est plus polyvalent car il peut trouver tous les chiffres dans une chaîne de caractères, alors que l'entier de la fonction est limitée à des entiers.

De référence:
http://jsperf.com/todigitsarray

Les critères de comparaison entre les deux fonctions de montrer que dans Firefox 10 et Chrome 12, la chaîne de caractères la fonction est de 30% à 60% plus rapide que l'entier de la fonction. Dans Opera 12, l'entier de la fonction est un peu plus rapide que d'environ 10%.

OriginalL'auteur XP1

//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));

OriginalL'auteur Kunle Babatunde

<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>

Pourriez-vous ajouter quelques explications?

OriginalL'auteur Romel jaudian

essayer cette

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));

OriginalL'auteur raksa eng

OK, comment sur l'utilisation et le chaînage de ces trucs populaires en JavaScript dans une ligne comme ci-dessous...

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

Et de l'appeler comme celles-ci:

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

OriginalL'auteur Alireza

0

Cela prend Number x comme paramètre et retourne la inversée nombre.

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

OriginalL'auteur Ozan

-1

Le bloc de code ci-dessous devrait faire l'affaire

<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>

OriginalL'auteur Jayaseelan Vejayon

Vous devez vous connecter pour publier un commentaire.