Обратное целочисленное значение в пределах предела int

Question

Я хочу перевернуть целое число. Я пытался с помощью следующего кода, проблемы возникают, когда число настолько велико, что его обратное становится больше, чем предел int (например, 1534236469), поэтому в этом случае он возвращает некоторое целое число мусора.

Как можно использовать Integer.MIN_VALUE и Integer.MAX_VALUE, чтобы проверить, находится ли обратное число в допустимых пределах?

Примечание: оно должно использовать int только тип переменной.

int num = 1534236469;

int reverseInt = 0;
int multiplier = 1;

if ( num < 0 ) {
    multiplier *= -1;
}

while ( num != 0 ) {

    //get the last digit
    int digit = num % 10;

    //multiply the reverseInt by 10 and then add the last digit
    reverseInt = (reverseInt * multiplier) + digit;

    multiplier = 10;
    num /= 10;
}

//how to fix this.
if (reverseInt < Integer.MIN_VALUE || reverseInt > Integer.MAX_VALUE ) {
    System.out.println("Invalid number");
} else {
    System.out.println("Reversed integer is " + reverseInt);
        }

Answer 1

Вам просто нужно выполнить проверку, прежде чем добавить следующий ди git, чтобы вы могли просто перенести свою проверку до фактического расчета. Если ваше текущее обратное положительное число больше Integer.MAX_VALUE/10, то вы не можете добавить еще один ди git. Аналогично с отрицательными числами.

Единственное, что я сделал, это переместил эту часть вашего кода вверх:

if (reverseInt < Integer.MIN_VALUE || reverseInt > Integer.MAX_VALUE ) {
    System.out.println("Invalid number");
} else {

, затем я добавил операторы /10 и return, так как программа должна завершиться при переполнении:

public class StackOverflowTest {
  public static void main(String[] args) {
    int num = -1534236469;

    int reverseInt = 0;
    int multiplier = 1;

    if ( num < 0 ) {
        multiplier *= -1;
    }

    while ( num != 0 ) {

        // if this next step will push is into overflow, then stop:
        if (reverseInt < Integer.MIN_VALUE/10 || reverseInt > Integer.MAX_VALUE/10) {
          System.out.println("Invalid number");
          return;

        } else {

          //get the last digit
          int digit = num % 10;

          // multiply the reverseInt by 10 and then add the last digit
          reverseInt = (reverseInt * multiplier) + digit;
        }

        multiplier = 10;
        num /= 10;
    }

    System.out.println("Reversed integer is " + reverseInt);
  }
}

---

В качестве альтернативы вы можете трактовать ее как строку, а затем просто повернуть строку в обратном направлении (вместе со скрипкой со знаком):

public class StackOverflowTest {
  public static void main(String[] args) {

    reverse(1534236469);
    System.out.println();
    reverse(-153423646);
  }

  public static void reverse(int num) { 
    System.out.println("int = " + num);
    int number = num < 0 ? -num : num;           // remove the sign

    String reverse = new StringBuilder(String.valueOf(number)).reverse().toString();
    System.out.println("reverse String: " + reverse);

    try {
      int reversed = Integer.parseInt(reverse);
      reversed = num < 0 ? -reversed : reversed;  // get back the sign
      System.out.println("Reversed integer is " + reversed);
    } catch (NumberFormatException ex) {
      System.out.println("Invalid number");
    }
  }
}

Отпечатки:

int = 1534236469
reverse String: 9646324351
Invalid number

int = -153423646
reverse String: 646324351
Reversed integer is -646324351

Answer 2

В Java 8+, измените на:

reverseInt = Math.addExact(Math.multiplyExact(reverseInt, multiplier), digit);

Код теперь выдаст ArithmeticException, если результат переполнится.

Answer 3

Всякий раз, когда значение Integer.MAX_VALUE превышено, оно начинается с Integer.MIN_VALUE, т. Е. Integer.MAX_VALUE + 1 оценивается до Integer.MIN_VALUE. Вы можете использовать эту функцию, чтобы получить решение, которое вы ищете.

Просто умножьте reverseInt на все oop с 1 до 10, и если значение станет отрицательным, это означает, что следующее значение (reverseInt * multiplier) превысит Integer.MAX_VALUE. Кроме того, вам нужно добавить reverseInt * multiplier в al oop к значению от 0 до 9, и если значение станет отрицательным, это означает, что следующее значение (reverseInt * multiplier + digit) превысит Integer.MAX_VALUE.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int num = 1534236469;
        boolean valid = true;
        int reverseInt = 0;
        int multiplier = 1;

        if (num < 0) {
            multiplier *= -1;
        }

        while (num != 0) {
            // get the last digit
            int digit = num % 10;

            for (int i = 1; i <= multiplier; i++) {
                for (int j = 0; j <= 9; j++) {
                    if (reverseInt * i < 0 || (reverseInt * i + j) < 0) {
                        System.out.println("Invalid number");
                        valid = false;
                        break;
                    }
                }
                if (!valid) {
                    break;
                }
            }
            if (!valid) {
                break;
            }

            // multiply the reverseInt by 10 and then add the last digit
            reverseInt = reverseInt * multiplier + digit;

            multiplier = 10;
            num /= 10;
        }
        if (valid) {
            System.out.println("Reversed integer is " + reverseInt);
        }
    }
}

Выход:

Invalid number