Обратное число с помощью String Builder в Java

Question

Постановка задачи: задано 32-разрядное целое число со знаком, обратные цифры целого числа.

Пример 1:

Ввод: 123 Выход: 321 Пример 2:

Ввод: -123 Выход: -321

Мое решение:

class Solution7{
public int reverse(int x) {
    if(x>Integer.MAX_VALUE || x<Integer.MIN_VALUE) {
        return 0;
    }


    StringBuilder S_rev = new StringBuilder();
    String S_r_v=S_rev.append(Math.abs(x)).reverse().toString();//.toString() String builder to String

   double reverse_no=Double.parseDouble(S_r_v);

    if (x < 0) {
        return -(int)reverse_no;
    }
    return (int)reverse_no;

}

}

Мое решение подходит для большинства тестовых случаев. Но он не может пройти ни одного теста, и я получил ошибку

Error: Строка 10: java.lang.NumberFormatException: для входной строки: «8463847412 -»

Если кто-то знает, что это за ошибка, пожалуйста, обсудите.

Заранее спасибо.

Answer 1

Как насчет этого?

public class ReverseNumber {
    public static void main(String[] args) {
        System.out.println(reverse(123456));
        System.out.println(reverse(0));
        System.out.println(reverse(-987654));
    }

    private static int reverse(int i) {
        final int signum;
        if(i < 0) {
            signum = -1;
        } else {
            signum = +1;
        }

        int reversedNumber = 0;
        int current = Math.abs(i);

        while(0 < current) {
            final int cipher = current % 10;

            reversedNumber = Math.addExact(Math.multiplyExact(reversedNumber, 10), cipher);
            current = current / 10;
        }

        return signum * reversedNumber;
    }
}

Выход:

654321
0
-456789

Это решение позволяет избежать строк и может обрабатывать отрицательные числа. Выдает арифметическое исключение, если происходит целочисленное переполнение.

Answer 2

public class ReverseString {
  public static void main(String args[]) {
    ReverseString rs = new ReverseString();
    System.out.println(rs.reverse(-84638));
    System.out.println(rs.reverse(5464867));
  }

  public long reverse(int number) {

    boolean isNegative = number < 0;

    StringBuilder reverseBuilder = new StringBuilder();
    String reversedString = reverseBuilder.append(Math.abs(number)).reverse().toString();
    long reversedStringValue = Long.parseLong(reversedString);

    if(isNegative) {
      return reversedStringValue * -1;
    } else {
      return reversedStringValue;
    }
  }
}

Этот код обеспечивает вывод, который вы упомянули в требовании. И это также поддерживает целочисленное переполнение. Ваше требование - преобразовать значения int. Можно получить преобразованное значение в более высоком формате, поскольку преобразованное значение может не входить в диапазон int. Я изменил тип возврата обратного метода на long.

Я обнаружил несколько проблем в вашем коде.

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

Над сегментом кода нет смысла проверять, находится ли значение внутри диапазона int, поскольку оно уже получено в параметре в виде строки. Он должен выдать ошибку перед выполнением строк кода, так как он не может соответствовать большему значению переменной int.

Наконец, используемый вами номер int находится вне диапазона int. (-8463847412)

Answer 3

Похоже, вы пытаетесь передать Integer.MIN_VALUE

Когда вы передаете минимальное целочисленное значение, Math.abs, похоже, возвращает отрицательное число, как указано здесь

https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#abs-int-

 Note that if the argument is equal to the value of Integer.MIN_VALUE, the most negative representable int value, the result is that same value, which is negative.

Вы можете либо проверить x<=Integer.MIN_VALUE и вернуть 0, если x равен Integer.MIN_VALUE, или обработать специальный случай для Integer.MIN_VALUE

 if(x== Integer.MIN_VALUE)
      return -8463847412;

Answer 4

Если вы хотите реализовать это с помощью StringBuilder, вот оно:

  public static void main(String[] args) {
    ReverseNum reverseNum = new ReverseNum();
    System.out.println(reverseNum.reverse(-123));
    System.out.println(reverseNum.reverse(123));
    System.out.println(reverseNum.reverse(0));
  }

  public int reverse(int x) {
    int res = 1;
    String xStr = String.valueOf(x);
    StringBuilder builder = null;

    if (xStr.startsWith("-")) {
      builder = new StringBuilder(xStr.substring(1));
      res = -1;
    } else {
      builder = new StringBuilder(xStr);
    }

    return res * Integer.valueOf(builder.reverse().toString());
  }

Выход:

-321
321
0

P.S. Если вы хотите избежать переполнения целых чисел, вы можете просто использовать long вместо int, например:

  public long reverse(int x) {
    long res = 1;
    String xStr = String.valueOf(x);
    StringBuilder builder = null;

    if (xStr.startsWith("-")) {
      builder = new StringBuilder(xStr.substring(1));
      res = -1;
    } else {
      builder = new StringBuilder(xStr);
    }

    return res * Long.valueOf(builder.reverse().toString());
  }

Answer 5

Преобразовав число в String и поменяв знак, он оказался в конце значения. Это делает число недействительным.

Вам не нужно конвертировать в String или double. Вы можете использовать оператор модуля % для извлечения цифр:

public int reverse(int x) {
  long result = 0;
  while (x != 0) {
    result *= 10;
    result += x % 10;
    x /= 10;
  }
  if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
    throw new IllegalArgumentException(); // overflow
  }
  return result;
}