Napisałem następujący kod, aby odwrócić liczbę całkowitą w JavaScript. Działa dobrze, ale zwraca 0, otrzymując wejście -900000. Czy ktoś wie, co może się mylić?

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    var negative_number= false;
    var k;
    var new_string;
    if(x<0){
        negative_number = true;
        x=Math.abs(x);
    }
    var n = x.toString(); // convert from number to string
        // Step 1. Use the split() method to return a new array
    var splitString = n.split(""); // var splitString = "hello".split("");
    // ["h", "e", "l", "l", "o"]
    if (negative_number)
    {
        for (var i=0; i< splitString.length-1; i++)
        {
            splitString[i]=splitString[i+1];
        }
    }
    // Step 2. Use the reverse() method to reverse the new created array
    var reverseArray = splitString.reverse(); // var reverseArray = ["h", "e", "l", "l", "o"].reverse();
    // ["o", "l", "l", "e", "h"]

    // Step 3. Use the join() method to join all elements of the array into a string
    var joinArray = reverseArray.join(""); // var joinArray = ["o", "l", "l", "e", "h"].join("");
    // "olleh"
    //return joinArray;
    var number = Number(joinArray);
    if (negative_number)
        number= -Math.abs(number);
    //Step 4. Return the reversed string
    return number;
};
2
user379888 27 czerwiec 2017, 04:44

5 odpowiedzi

Najlepsza odpowiedź

Nie musisz wyciąć znak - z liczb ujemnych, już podjąłeś wartość bezwzględną jako x. Upuść tę pętlę, która porusza cyfry i niszczy twoje wartości.

2
Bergi 27 czerwiec 2017, 01:50

To jest mój wariant, po graniu na leetCode. Warunki:

Biorąc pod uwagę 32-bitową liczbę całkowitą ze znakiem, odwróć cyfry liczby całkowitej.

Załóżmy, że mamy do czynienia ze środowiskiem, które mogłyby przechowywać tylko liczby całkowite w 32-bitowym zasięgu całkowitym: [-231, 231 - 1]. Do celów tego problemu załóż, że Twoja funkcja zwraca 0, gdy odwrócone przepełnienia całkowitego.

const reverse = function(x) {
  const revInt = parseFloat(x.toString().split('').reverse().join('')) * Math.sign(x);
  const maxInt = (2 ** 31) - 1;
  const minInt = -(2 ** 31);
  return (revInt >= minInt && revInt <= maxInt) ? revInt : 0;
};
0
Asylbek 29 styczeń 2020, 01:29

Wygląda zbyt skomplikowane. Powinno to być wystarczające:

function reverse(n) {  
  return Number(Array.from(String(Math.abs(n))).reverse().join('')) * Math.sign(n);
}

console.log(reverse(144));
console.log(reverse(-90000));
2
Robby Cornelissen 27 czerwiec 2017, 01:53

Jedną rzeczą, która jest jasna, jest to, że jest to znacznie bardziej skomplikowane niż to konieczne. Myślę, że to zrobi to, co chcesz:

const rev = (i) => Math.sign(i) * Number(('' + Math.abs(i)).split('').reverse().join(''))
2
Scott Sauyet 27 czerwiec 2017, 01:52

Niektóre doskonałe odpowiedzi już opublikowane.

Postanowiłem pokazać nieco inną zmienność:

  • Użyj "Recursion", aby obsługiwać obudowę negatywną
  • Reszta funkcji skup się na pozytywnym przypadku
  • Złamał każde obliczenie pośrednie do własnej linii

Oto fragment kodu z komentarzami ilustrujący sposób -123 staje się -321:

function reverse(x) {
  if (x < 0) return -reverse(-x); // reverse(-123) === -reverse(123)
  var str = x.toString(); // "123"
  var strArray = str.split(""); // [ "1", "2", "3" ]
  var revArray = strArray.reverse(); // [ "3", "2", "1" ]
  var rev = revArray.join(""); // "321"
  return Number(rev);
}

console.log(reverse(-123)); // Outputs: -321
console.log(reverse(0)); // Outputs: 0
console.log(reverse(-900000)); // Outputs: -9
3
Stephen Quan 27 czerwiec 2017, 02:04