Reverse-32bit integer

Ich versuche zu lösen, exercie in leetcode.com die sich mit signed 32bit integers.

Die Aufgabe ist:

Rückkehr der inversen einer signed 32bit integer und gibt 0 zurück, wenn es überläufe des 32-bit signed integer-Bereich.

In Wikipedia:

Einem 32-bit register speichern können 32 verschiedene Werte. Der Bereich der ganzen zahlen
Werte, die gespeichert werden können in 32 bits hängt von der Ganzzahl
Darstellung verwendet. Mit den beiden am meisten verbreiteten Darstellungen, die
Wertebereich ist 0 bis 4,294,967,295 (2^32 − 1) für die Vertretung als
(unsigned) Binärzahl, und zwischen-2.147.483.648 (-2^31) durch
Und 2.147.483.647 (2^31 − 1) für die Darstellung als Zweierkomplement.

So, wenn ich was verstanden wird, ist richtig, ich sollte test zwischen den Intervallen 0 to (2^31)-1 und (-2^31) to 0 andernfalls zurück 0.

Hier ist mein code:

def reverse_int(nums):
    a = str(nums)

    if 0 < nums <= (1 << 31)-1:
        return int(a[::-1])

    elif (-1 << 31) <= nums < 0:
        return -(int(a[:-len(a):-1]))
    else:
        return 0

Hier ist mein problem:
Wenn ich mein test-code auf der website mit:

nums = 1534236469 # Fail
nums = 1463847412 # Success
nums = 9000000    # Success

Warum mein aktuelle code nicht mit 1534236469 ? nicht 1534236469 im Bereich von 32 bit signed integers ? Was mir fehlt ?

  • Welche Ausgabe bekommen Sie für den Fall, dass die ausfällt?
  • Zum Beispiel, für 1534236469 auf der website sollte 0 zurückgegeben werden. Dies bedeutet, dass 1534236469 überläufe der Palette von 32-bit-Ganzzahlen mit Vorzeichen.
  • Aber es nicht überläuft.
  • In wikipedia haben Sie gesagt the two most common representations. Es gibt andere Darstellungen von 32bit-Ganzzahlen ?
  • Sie umkehren müssen dann prüfen, ob es überläuft.
  • Steven hat Recht. Es geht über den Bereich hinaus, nachdem Sie es rückgängig zu machen.
  • fügen Sie Ihren Kommentar als eine Antwort werde ich akzeptieren.

InformationsquelleAutor Chiheb Nexus | 2017-06-16
  1. 15

    Wie bereits erwähnt in den Kommentaren, müssen Sie ersten reverse und dann überprüfen. Aber hier ist eine andere Art von Prüfung.

    Zu überprüfen, können Sie nur & das Ergebnis mit der entsprechenden Maske.

    Also in Ihrem Fall die Grenzen sind −2,147,483,648 und 2,147,483,647 die hex-Werte sind -0x80000000 und 0x7fffffff

    Versuchen, diese im interpreter.

    >>> 0x7fffffff
2147483647
>>> 2147483647 & 0x7fffffff   #within limit
2147483647

    Werte, die den Grenzwert überschreiten, können Sie sehen, einige andere Wert wird angezeigt.

    >>> 2147483648 & 0x7fffffff     #Exceeds limit
0
>>> 98989898989898 & 0x7fffffff  #Exceeds limit
1640235338

    Aber, wenn der Wert innerhalb des Limits. Der Wert wird als Ausgang.

    >>> 1 & 0x7fffffff               #within limit
1
>>> 780 & 0x7fffffff
780

    Für negative Werte

     >>> -0x80000000     #Limit
-2147483648
>>> -2147483648 & -0x80000000
-2147483648

    Wenn der Wert innerhalb des Bereichs. Die limit ist gegeben als Ausgabe.

    >>> -2147483647 & -0x80000000
-2147483648
>>> -2 & -0x80000000          #within limit
-2147483648
>>> -2323 & -0x80000000
-2147483648

    Jedoch, wenn der Wert out of range Sie können sehen, einige andere Wert wird angezeigt.

    >>> -2147483649 & -0x80000000
-4294967296
>>> -999999999999 & -0x80000000
-1000727379968

    Können Sie Gebrauch machen von diesem gut und gut zu bekommen, was Sie wollen!

    Hier ist ein Programm, das tut, was Sie wollen.

    def reverse(x):
    str_x = str(x)
    if x<0:
        str_x = '-'+str_x[::-1][:-1]
        x = int(str_x)
    else:
        str_x = str_x[::-1]
        x = int(str_x)
    neg_limit= -0x80000000
    pos_limit= 0x7fffffff

    if(x<0):
        val=x&neg_limit
        if(val==neg_limit):
            return x
        else:
            return 0
    elif(x==0):
        return x
    else:
        val = x&pos_limit
        if(val==x):
            return x
        else:
            return 0

value = int(input("Enter value: "))
print(reverse(value))

    Den Teil unten einfach kehrt für positive und negative Werte.

    if x<0:
    str_x = '-'+str_x[::-1][:-1]
    x = int(str_x)
    print(x)
else:
    str_x = str_x[::-1]
    x = int(str_x)
    print(x)

    Setzen die Grenzen neg_limit= -0x80000000 und pos_limit= 0x7fffffff und überprüfen für Sie gemäß der erläuterten Logik.

    • Oder, in eine viel einfachere Art und Weise zu vergleichen, die Umgekehrt int von str_x wenn es zwischen (-1 << 31) und (1 << 31)-1. Wenn nicht zurück 0. Übrigens, dein Ansatz ist richtig zu, aber zu langatmig.
    • Ja ist es, aber wollte erwähnen die Verwendung von & und mit einem mask
    InformationsquelleAutor void
  2. 0

    Die Lösung ist schon da, ich bin dieses posting, weil dies hilfreich sein könnte für newbies wie mich. Ich benutzte die nichtig ist Lösung (oben) um es vollständig zu machen. Auf den ersten, ich habe die Prüfung ohne Durchführung der reverse-Methode war es, die zeigen das problem, wie erwähnt, in der ursprünglichen Frage. Dann habe ich den test nach Umkehrung der zahlen in positive und negative Fall und es funktionierte.

    def reverse(self, x: int) -> int:
        neg_limit =-0x80000000 # hex(-2**31-1),see details in accepted answer above
        pos_limit = 0x7fffffff #hex(2**31-1)
        if x >0:
            reverse_num = int(str(x)[::-1])
            if reverse_num & pos_limit==reverse_num: #conditions explained above
                return reverse_num
            else:
                return 0

        elif x <0:
            reverse_num = -int(str(abs(x))[::-1])
            if reverse_num&neg_limit == neg_limit:
                return reverse_num
            else:
                    return 0
        else:
            return 0
    InformationsquelleAutor hemanta
Schreibe einen Kommentar