Java инвертирует значение int без использования массива

Question

Может кто-нибудь объяснить мне, как обратить целое число без использования массива или строки.Я получил этот код из сети, но не совсем понимаю, почему + введите% 10 и снова разделите.

while (input != 0) {
    reversedNum = reversedNum * 10 + input % 10;
    input = input / 10;   
}

И как использовать этот пример кода для обращения только нечетного числа.Пример Я получил этот вход 12345, затем он обратит нечетное число к выходу 531.

Answer 1

Java обратное значение типа int - Принципы

1. Модирование (%) ввода int на 10 извлечет крайнюю правую цифру. Пример: (1234% 10) = 4

2. Умножение целого числа на 10 «подтолкнет его влево», обнажая ноль справа от этого числа, например: (5 * 10) = 50

3. Деление целого числа на 10 удалит крайнюю правую цифру. (75/10) = 7

Java инвертирует значение типа int - псевдокод:

а. Извлеките самую правую цифру вашего входного номера. (1234% 10) = 4

б. Возьмите эту цифру (4) и добавьте ее в новое обратное число.

с. Умножьте reversedNum на 10 (4 * 10) = 40, это выставит ноль справа от вашего (4).

* * Д тысячу двадцать восемь. Разделите вход на 10 (удаляя крайнюю правую цифру). (1234/10) = 123

е. Повторите на шаге с 123

Java обратное значение типа int - рабочий код

public int reverseInt(int input) {
    long reversedNum = 0;
    long input_long = input;

    while (input_long != 0) {
        reversedNum = reversedNum * 10 + input_long % 10;
        input_long = input_long / 10;
    }

    if (reversedNum > Integer.MAX_VALUE || reversedNum < Integer.MIN_VALUE) {
        throw new IllegalArgumentException();
    }
    return (int) reversedNum;
}

Вы никогда не будете делать ничего подобного в реальном мире труда. Тем не менее, процесс, с помощью которого вы решаете его без посторонней помощи, - это то, что отделяет людей, которые могут решать проблемы от тех, кто хочет, но не может, если они не получают ложную пищу от хороших людей из блогов.

Answer 2

Мне не понятно ваше нечетное число.Этот код работает (это не специфический алгоритм Java) Например.вход = 2345 первый раз во время цикла оборотов = 5 вход = 234 второй раз об = 5 * 10 + 4 = 54 вход = 23 третий раз об = 54 * 10 + 3 вход = 2 четвертый раз об = 543 * 10 + 2input = 0

Таким образом, обратное число равно 5432. Если вам нужно только нечетные числа в обратном числе, тогда.Код:

while (input != 0) {    
    last_digit = input % 10;
    if (last_digit % 2 != 0) {     
        reversedNum = reversedNum * 10 + last_digit;

    }
    input = input / 10; 
}

Answer 3

Просто вы можете использовать это

public int getReverseInt(int value) {
    int resultNumber = 0;
    for (int i = value; i !=0; i /= 10) {
        resultNumber = resultNumber * 10 + i % 10;
    }
    return resultNumber;        
}

Вы можете использовать этот метод с заданным значением, которое вы хотите изменить.

Answer 4

while (num != 0) {
    rev = rev * 10 + num % 10;
    num /= 10;
}

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

num % 10

Это утверждение даст вам последнюю цифру от исходного числа.

num /= 10

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

rev = rev * 10 + num % 10

Здесь rev * 10 сместит значение влево, а затем добавит последнюю цифру от оригинала.
Если исходное число было 1258, и в середине времени выполнения мы имеем rev = 85, num = 12, поэтому:
число% 10 = 2
rev * 10 = 850
об * 10 + число% 10 = 852

Answer 5

int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());

Answer 6

import java.util.Scanner;

public class Reverse_order_integer {
    private static Scanner scan;

    public static void main(String[] args) {
        System.out.println("\t\t\tEnter Number which you want to reverse.\n");
        scan = new Scanner(System.in);
        int number = scan.nextInt();
        int rev_number = reverse(number);
        System.out.println("\t\t\tYour reverse Number is = \"" + rev_number
                           + "\".\n");
    }

    private static int reverse(int number) {
        int backup = number;
        int count = 0;
        while (number != 0) {
            number = number / 10;
            count++;
        }
        number = backup;
        int sum = 0;
        for (int i = count; i > 0; i--) {
            int sum10 = 1;
            int last = number % 10;
            for (int j = 1; j < i; j++) {
                sum10 = sum10 * 10;
            }
            sum = sum + (last * sum10);
            number = number / 10;
        }
        return sum;
    }
}

Answer 7

См., Чтобы получить последнюю цифру любого числа, которое мы делим на 10, чтобы получить либо ноль, либо цифру, которая ставится на последнюю, и когда мы делаем это непрерывно, мы получаем целое число в виде целого числа в обратном порядке.

    int number=8989,last_num,sum=0;
    while(number>0){
    last_num=number%10; // this will give 8989%10=9
    number/=10;     // now we have 9 in last and now num/ by 10= 898
    sum=sum*10+last_number; //  sum=0*10+9=9;
    }
    // last_num=9.   number= 898. sum=9
    // last_num=8.   number =89.  sum=9*10+8= 98
   // last_num=9.   number=8.    sum=98*10+9=989
   // last_num=8.   number=0.    sum=989*10+8=9898
  // hence completed
   System.out.println("Reverse is"+sum);

Answer 8

Просто добавим, в надежде сделать решение более полным.

Логика @sheki уже дала правильный способ обращения целого числа в Java.Если вы предполагаете, что вход, который вы используете, и результат, который вы получаете, всегда попадают в диапазон [-2147483648, 2147483647], вы можете безопасно использовать коды @sheki.В противном случае это будет хорошая практика, чтобы поймать исключение.

Java 8 представила методы addExact , subtractExact , multiplyExact и toIntExact .Эти методы выдают ArithmeticException при переполнении.Следовательно, вы можете использовать приведенную ниже реализацию для реализации чистого и немного более безопасного метода для обращения целого числа.Как правило, мы можем использовать упомянутые методы для выполнения математических вычислений и явного решения проблемы переполнения, что всегда рекомендуется, если существует вероятность переполнения при фактическом использовании.

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

    while (x != 0){
        try {
            result = Math.multiplyExact(result, 10);
            result = Math.addExact(result, x % 10);
            x /= 10;
        } catch (ArithmeticException e) {
            result = 0; // Exception handling
            break;
        }
    }

    return result;
}

Answer 9

Java решение без цикла.Более быстрый ответ.

int numberToReverse;//your number 
StringBuilder sb=new StringBuilder();
sb.append(numberToReverse);
sb=sb.reverse();
String intermediateString=sb.toString();
int reversedNumber=Integer.parseInt(intermediateString);

Answer 10

public static void main(String args[]) {
    int n = 0, res = 0, n1 = 0, rev = 0;
    int sum = 0;
    Scanner scan = new Scanner(System.in);
    System.out.println("Please Enter No.: ");
    n1 = scan.nextInt(); // String s1=String.valueOf(n1);
    int len = (n1 == 0) ? 1 : (int) Math.log10(n1) + 1;
    while (n1 > 0) {
        rev = res * ((int) Math.pow(10, len));
        res = n1 % 10;
        n1 = n1 / 10;
        // sum+=res; //sum=sum+res;
        sum += rev;
        len--;
    }
    // System.out.println("sum No: " + sum);
    System.out.println("sum No: " + (sum + res));
}

Будет возвращено обратное целое число