2
votes

Inverser un entier en java (question sur la méthode)

L'énoncé du problème est un peu basique - si l'entrée est un entier signé 32 bits, la sortie est un entier inversé, sinon la sortie 0.

Voici le code que j'ai trouvé

public class Solution {
    public int reverse(int A) {
        if(A>=2143483647 || A<-2143483647)
        return 0;
        if(A>=0)
            return Integer.parseInt((new StringBuilder(String.valueOf(A))).reverse().toString());
        else
            return -1*Integer.parseInt((new StringBuilder(String.valueOf(-1*A))).reverse().toString());
    }
}

java math

3 commentaires

L'utilisation de Integer.MAX_VALUE et Integer.MIN_VALUE rendra votre code propre. BTW vos plages sont fausses ..... Et c'est une autre raison pour laquelle vous devriez utiliser les constantes ci-dessus.

si l'entrée est un entier signé de 32 bits Cela signifie que l'entrée peut être plus grande que int . Alors, lisez-le comme un entier long ou grand

Supposons que votre code soit correct. Si votre entrée «A» est 2143483646, l'inverser deviendra 6463843412 et elle est clairement hors de la plage entière. De plus, comme l'a dit JavaFan, la valeur de votre plage est incorrecte

4 Réponses :

1
votes

vous pouvez essayer de passer d'abord à un paramètre long (cela garantit qu'il ne débordera pas), puis effectuez la vérification par la suite.

public int reverse(int A) {
        long reversed; 
        if(A>=0)
            reversed=  reverseString(A);
        else
            reversed -1*  reverseString(-A) ;

        //we do the checking only after we have done the reverse.
        if(reversed > Integer.Max_VALUE || reversed < Integer.MIN_VALUE)
            return 0;
        else 
            return (int) reversed; //we do a down cast here.
}

public long reverseString(int A){
    StringBuilder sb = new StringBuilder(""+A).reverse(); 
    String s = sb.reverse().toString(); 
    return Long.parseLong(s);
}

2 commentaires

Je suis désolé si ce n'était pas clair dans la question mais vous n'êtes pas censé sortir le nombre inversé s'il déborde (sortie 0 à la place)

@ DarkLord3 Je vois. ce que vous pouvez faire est de faire l'inverse sur une longue période, puis de faire la vérification après.

3
votes

En supposant que l'entrée est int32, voici une approche possible, y compris la vérification du dépassement de capacité.

public class Solution {
    public int reverse(int A) {
        //if(A < Integer.MIN_VALUE || A > Integer.MAX_VALUE) return 0;
        boolean neg = A < 0;
        A = Math.abs(A);
        long ret = 0;
        while(A != 0){
            ret = ret*10 + A%10;
            A = A/10;
        }
        if(ret > Integer.MAX_VALUE) return 0;
        return neg ? -(int)ret : (int)ret;
    }
}

Veillez à changer int en long si l'entrée est plus grande.

3 commentaires

Merci, cela a fonctionné. Pouvez-vous me dire où vous avez vérifié le débordement?

Ici: if (ret> Integer.MAX_VALUE) return 0;

System.out.println (reverse (Integer.MIN_VALUE)); donne -126087180 qui ne semble pas correct.

3
votes

La réponse acceptée est proche mais manque certains cas extrêmes. Voici une réponse basée sur la réponse acceptée, mais nous espérons qu'elle gère correctement tous les cas.

public static int reverse(int A) {

    long aLong = Math.abs((long)A);
    long ret = 0;
    while (aLong != 0) {
        ret = ret * 10 + aLong % 10;
        aLong = aLong / 10;
    }
    if (A < 0) {
        ret = -ret;
    }

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

0 commentaires

0
votes

Ce code s'occupera des deux nombres positifs et négatifs. Après l'inversion si le résultat est supérieur à Integer.MAX_VALUE, il renverra zéro.

  public static int reverse(int x) {

     boolean positive = true;
     if(x < 0) {
         positive =  false;
         x = x * -1;
     }

     long result = 0;
     while(x > 0) {
         result = (result * 10) + (x % 10);
         x = x / 10;
     }

     if(result > Integer.MAX_VALUE) {
         return 0;
     }

     return positive ? (int)result : (int)(result * -1);
  }

0 commentaires