Reverse Integer leetcode — wie behandeln überlauf

Das problem ist:
Reverse Ziffern einer Ganzzahl.

Beispiel1: x = 123, Rückkehr 321

Beispiel2: x = -123, zurück -321

Haben Sie bemerkt, dass die umgekehrte integer-überlauf könnte? Angenommen, dass die Eingabe einen 32-bit-Ganzzahl, die dann das Gegenteil von 1000000003 überläuft. Wie sollten Sie mit solchen Fällen?

Werfen eine Ausnahme? Gut, aber was ist, wenn eine Ausnahme zu werfen ist keine option? Sie hätten dann ein re-design der Funktion (dh, fügen Sie einen zusätzlichen parameter).

Die Lösung von der website, die ich Suche ist:

public class Solution {

     public static int reverse(int x) {
            int ret = 0;
            boolean zero = false;
            while (!zero) {
                ret = ret * 10 + (x % 10);
                x /= 10;      
                if(x == 0){
                    zero = true;
                }
            }
            return ret;   
        }

    public static void main(String[] args) {
        int s = 1000000003;
        System.out.println(reverse(s));
    }

}

Jedoch, wenn s = 1000000003 die Konsole druckt -1294967295 statt 3000000001. Also ist diese Lösung immer noch nicht behoben ist das overflow-problem, wenn man keine Ausnahme. Jede Hilfe hier?(Obwohl es einen Hinweis: fügen Sie einen zusätzlichen parameter, ich kann immer noch nicht herausfinden, welche parameter sollte ich hinzufügen)

Check out this link.

InformationsquelleAutor CSnerd | 2014-01-12

14

Gibt es keine Notwendigkeit für einen anderen Datentyp als int.
Stellen Sie nur sicher, wenn es eine operation, erhöht eine Zahl, die Umkehrung der operation sollte Ihnen die Vorherige Zahl. Ansonsten gibt es überlauf.
```
public int reverse(int x) {
    int y = 0;

    while(x != 0) {
        int yy = y*10 + x%10;

        if ((yy - x%10)/10 != y) return 0;
        else y = yy;

        x = x/10;   
    }
    return y;
}
```
dies hat nicht 0 zurückgeben, wie erwartet, für x=1534236469

InformationsquelleAutor user3366372

Über die meisten der Antworten haben ein triviales problem ist, dass der int-Variablen möglicherweise könnte überlaufen. Sie können versuchen, diese : x = -2147483648 als parameter.
Gibt es eine einfache Möglichkeit das problem zu lösen. Konvertiert x zu lange, und überprüfen Sie, ob das Ergebnis >= Integer.MAX_VALUE, sonst 0 zurück.
Die Lösung Bestand alle test-Fälle auf https://leetcode.com/problems/reverse-integer/

Dies ist eine java-version.

public int reverse(int x) {
        long k = x;
        boolean isNegtive = false;        
        if(k < 0){
            k = 0 - k;
            isNegtive = true;
        }

        long result = 0;
        while(k != 0){
            result *= 10;
            result += k % 10;
            k /= 10;
        }

        if(result > Integer.MAX_VALUE) return 0;
        return isNegtive  ? 0 - ((int)result) : (int)result;
    }

C# - version

    public int Reverse(int x)
    {
        long value = 0;
        bool negative = x < 0;
        long y = x;
        y = Math.Abs(y);

        while (y > 0)
        {
            value *= 10;
            value += y % 10;
            y /= 10;
        }

        if(value > int.MaxValue)
        {
            return int.MaxValue;
        }

        int ret = (int)value;

        if (negative)
        {
            return 0 - ret;
        }
        else
        {
            return ret;
        }
    }

Python version

def reverse(self, x):                
    isNegative = x < 0
    ret = 0
    x = abs(x)
    while x > 0:
        ret *= 10
        ret += x % 10
        x /= 10
    if ret > 1<<31:
        return 0

    if isNegative:
        return 0 - ret
    else:
        return ret

bisher ist dies die beste Lösung.
Gut, es könnte funktionieren, für Java, aber es ist nicht Sinn machen - keine ganze Zahl mehr sein soll als Integer.MAX_VALUE - das ist der springende Punkt, der MAX_VALUE. Also, der Vergleich ( Ergebnis > Ganzzahl.MAX_VALUE) ist immer false.
Ergebnis ist eine lange, nicht eine int.
Das ist smart, aber ich fühle mich wie Sie behandeln. Was, wenn Sie wurden aufgefordert, umzukehren lange? Wird Sie versuchen, um den Wert zu speichern in BigInteger in diesem Fall?
Aktuelle version das problem Staaten, dass Sie nicht verwenden können long: Assume we are dealing with an environment which could only hold integers within the 32-bit signed integer range.

InformationsquelleAutor Jiaji Li

Dieser java-code verarbeitet die overflow-Bedingung:

public int reverse(int x) {

    long reverse = 0;
    while( x != 0 ) {
       reverse = reverse * 10 + x % 10;
       x = x/10;
    }

    if(reverse > Integer.MAX_VALUE || reverse < Integer.MIN_VALUE) {
        return 0;
    } else {
        return (int) reverse;
    }
}

InformationsquelleAutor Apurva Kumar Sinha

Meine Lösung für dieses problem ist das konvertieren von integer eingegeben, c-string, dann wird alles leicht sein wird.

class Solution {
public:
  int reverse(int x) {
    char str[11];
    bool isNegative = false;
    int i;
    int ret = 0;

    if ( x < 0 ) {
        isNegative = true;
        x = -x;
    }

    i = 0;
    while ( x != 0 ) {
        str[i++] = x % 10 + '0';
        x = x / 10;
    }
    str[i] = '\0';

    if ( (isNegative && strlen(str) == 10 && strcmp(str, "2147483648") > 0) || (!isNegative && strlen(str) == 10 && strcmp(str, "2147483647") > 0) ) {
        cout << "Out of range!" << endl;
        throw new exception();
    }

    i = 0;
    int strLen = (int)strlen(str);
    while ( str[i] != '\0' ) {
        ret += ((str[i] - '0') * pow(10.0, strLen - 1 - i));
        i++;
    }

    return (isNegative ? -ret : ret);
}

};

Ich denke, die Frage war, wie die Signatur der Methode und implementieren Sie es vielleicht ändern es, indem Sie einfach nur einen zusätzlichen parameter

InformationsquelleAutor Charles Wang

Dies funktioniert:

public class Solution {
    public int reverse(int x) {
        long tmp = Math.abs((long)x);
        long res = 0;

        while(tmp >= 10){
            res += tmp%10;
            res*=10;
            tmp=tmp/10;          
        }  

        res+=tmp;

        if(x<0){
            res = -res;
        }

        return (res>Integer.MAX_VALUE||res<Integer.MIN_VALUE)? 0: (int)res; 
    }
}

Habe ich versucht, die Leistung zu verbessern ein wenig, aber alle die ich gefunden habe, war diese:

public class Solution {
    public int reverse(int x) {

        long tmp = x;
        long res = 0;

        if(x>0){
            while(tmp >= 10){
                res += tmp%10;
                res*=10;
                tmp=tmp/10;          
            }  
        }
        else{
            while(tmp <= -10){
                res += tmp%10;
                res*=10;
                tmp=tmp/10;          
            }  
        }

        res+=tmp;

        return (res>Integer.MAX_VALUE||res<Integer.MIN_VALUE)? 0: (int)res; 
    }
}

Seine C# - Entsprechung ausgeführt wird 5% schneller als die 1. version auf meinem Rechner, aber deren server sagt, es ist langsamer, das kann nicht sein - ich losgeworden zusätzliche Funktion, die hier anrufen, sonst ist es im wesentlichen die gleichen. Er legt mich zwischen 60-30%, je nach Sprache (C# oder Java). Vielleicht hat sich Ihre benchmarking-code ist nicht sehr gut - wenn Sie uns mehrere mal - was-Zeiten variieren sehr.

InformationsquelleAutor Zar Shardan

public static int reverse(int x) {
  boolean pos = x >= +0;
  int y = (pos) ? x : -x;
  StringBuilder sb = new StringBuilder(
      String.valueOf(y));
  sb.reverse();
  int z = Integer.parseInt(sb.toString());
  return pos ? z : -z;
}

public static void main(String[] args) {
  for (int i = -10; i < 11; i++) {
    System.out.printf("%d r= '%d'\n", i, reverse(i));
  }
}

Ausgänge

-10 r= '-1'
-9 r= '-9'
-8 r= '-8'
-7 r= '-7'
-6 r= '-6'
-5 r= '-5'
-4 r= '-4'
-3 r= '-3'
-2 r= '-2'
-1 r= '-1'
0 r= '0'
1 r= '1'
2 r= '2'
3 r= '3'
4 r= '4'
5 r= '5'
6 r= '6'
7 r= '7'
8 r= '8'
9 r= '9'
10 r= '1'

Haben Sie bemerkt, die rückwärts von 10 und -10? Oder 20? Sie konnte nur ein String zurückgegeben, zum Beispiel

public static String reverse(int x) {
  boolean pos = x >= +0;
  int y = (pos) ? x : -x;
  StringBuilder sb = new StringBuilder(
      String.valueOf(y));
  sb.reverse();
  if (!pos) {
    sb.insert(0, '-');
  }
  return sb.toString();
}

public static void main(String[] args) {
  for (int i = -10; i < 11; i++) {
    System.out.printf("%d r= '%s'\n", i, reverse(i));
  }
}

Funktioniert wie ich es erwarten würde.

InformationsquelleAutor Elliott Frisch

Wenn Sie erforderlich sind, um wieder eine 32 bit int, und müssen noch wissen, ob es ein überlauf-vielleicht könnte man eine Flagge als zusätzlichen parameter. Wenn Sie mit c oder c++ könnte man Zeiger verwenden, um die Flagge, oder in Java kann man ein array verwenden (da Java-Objekte als Wert übergeben).

Java-Beispiel:

public class Solution {

     public static int reverse(int x, Boolean[] overflowed) {
            int ret = 0;
            boolean zero = false;
            boolean inputIsNegative = x < 0;
            while (!zero) {
                ret = ret * 10 + (x % 10);
                x /= 10;
                if(x == 0){
                    zero = true;
                }
            }
            //Set the flag
            if ( (inputIsNegative && (ret > 0)) || ((!inputIsNegative) && (ret < 0)))
                overflowed[0] = new Boolean(true);
            else
                overflowed[0] = new Boolean(false);
            return ret;
        }

    public static void main(String[] args) {
        int s = 1000000004;
        Boolean[]  flag = {null};
        System.out.println(s);
        int n = reverse(s,flag); //reverse() will set the flag.
        System.out.println(flag[0].booleanValue() ? "Error: Overflow": n );

    }
}

Kündigen, wenn die umgekehrte Zahl ist zu groß für eine 32-bit-Ganzzahl, wird das flag.
Hoffe, das hilft.

InformationsquelleAutor suh

0

Verwendung von string zu speichern, die Rückseite und drucken Sie dann oder verwenden Sie lange oder BigInt

InformationsquelleAutor Vikram Bhat

public class Solution {
    /**
     * OVERFLOW
     * @param x
     * @return
     */
    public int reverse(int x) {
        int sign = x>0? 1: -1;
        x *= sign;
        int ret = 0;
        while(x>0) {
            ret *= 10;
            if(ret<0 || x>10&&ret*10/10!=ret) //overflow
                return 0;

            ret += x%10;
            x /= 10;
        }
        return ret*sign;
    }

    public static void main(String[] args) {
        assert new Solution().reverse(-2147483412)==-2147483412;
    }
}

InformationsquelleAutor Daniel

public class Solution {
    public int Reverse(int x) {

            var sign = x < 0 ? -1 : 1;

            var reverse = 0;

            if (x == int.MinValue)
            {
                return 0;
            }
            x = Math.Abs(x);

            while(x > 0)
            {
                var remainder = x % 10;

                if (reverse > ((int.MaxValue - remainder)/10))
                {
                    return 0;
                }

                reverse = (reverse*10) + remainder;

                x = x/10;
            }

            return sign * Convert.ToInt32(reverse);

    }
}

InformationsquelleAutor nimmi chhabra

Hier werden wir lange zu behandeln, die die over-flow:

public class Solution {
 public int reverse(int A) {
    //use long to monitor Overflow
    long result = 0;
    while (A != 0) {
        result = result * 10 + (A % 10);
        A = A / 10;
    }
    if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
        return 0;
    } else {
        return (int) result;
    }
 }
}

InformationsquelleAutor Aakarsh Gupta

Gut Das Passenden Code in Java Können sein:-

public class Solution {
    public int reverse(int x) {

        int r;
        long s = 0;

        while(x != 0)
       {
            r = x % 10;

            s = (s * 10) + r;

            x = x/10;
        }
        if(s >= Integer.MAX_VALUE || s <= Integer.MIN_VALUE) return 0;
        else
            return (int)s;  
    }
}

InformationsquelleAutor Abhisek Mazumdar

Meine Lösung ohne Verwendung von lange:

public class ReverseInteger {

    public static void main(String[] args) {
        int input = Integer.MAX_VALUE;
        int output = reverse(input);
        System.out.println(output);
    }

    public static int reverse(int x) {
        int remainder = 0;
        int result = 0;

        if (x < 10 && x > -10) {
            return x;
        }

        while (x != 0) {
            remainder = x % 10;

            int absResult = Math.abs(result);
            int maxResultMultipliedBy10 = Integer.MAX_VALUE / 10;
            if (absResult > maxResultMultipliedBy10) {
                return 0;
            }

            int resultMultipliedBy10 = absResult * 10;

            int maxRemainder = Integer.MAX_VALUE - resultMultipliedBy10;
            if (remainder > maxRemainder) {
                return 0;
            }

            result = result * 10 + remainder;
            x = x / 10;
        }

        return result;
    }

}

InformationsquelleAutor Gemini Jain

Lösung In Swift 4.0 (in Bezug auf problem von https://leetcode.com/problems/reverse-integer/description/)

func reverse(_ x : Int) -> Int {

    var stringConversion = String(x)
    var negativeCharacter = false
    var finalreversedString = String()
    let signedInt = 2147483647 //Max for Int 32
    let unSignedInt = -2147483647 //Min for Int 32

    if stringConversion.contains("-"){
        stringConversion.removeFirst()
        negativeCharacter = true
    }

    var reversedString = String(stringConversion.reversed())
    if reversedString.first == "0" {
        reversedString.removeFirst()
    }
    if negativeCharacter {
        finalreversedString = "-\(reversedString)"
    } else {
        finalreversedString = reversedString
    }

    return  (x == 0 || Int(finalreversedString)! > signedInt || Int(finalreversedString)! < unSignedInt) ?  0 :  Int(finalreversedString)!

}

InformationsquelleAutor redEyeProgrammer

-2

Beachten Sie, dass es zu früheren Lösungen, die funktionieren nicht für die Eingabe: 1000000045
versuchen Sie dies:

public int reverse(int A) {
    int reverse=0;
    int num=A;
    boolean flag=false;
    if(A<0)
    {
    num=(-1)*A;
    flag=true;
    }

    int prevnum=0;
    while(num>0)
    {
        int currDigit=num%10;
        reverse=reverse*10+currDigit;

    if((reverse-currDigit)/10!=prevnum)
            return 0;
        num=num/10;  
        prevnum=reverse;
    }

    if(flag==true)
   reverse= reverse*-1;
return reverse;
}

InformationsquelleAutor Noy Miran

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.