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

Question

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

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

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

Answer 1

Это устаревший вопрос, но как справка для других Прежде всего reversedNum должен быть инициализирован в 0;

вход% 10 используется для получения последней цифры от входа

input / 10 используется, чтобы избавиться от последней цифры с входа, которую вы добавили к reversedNum

Допустим, вход был 135

135% 10 - 5 Поскольку обратное число было инициализировано в 0 теперь reversedNum будет 5

Затем мы избавляемся от 5, деля 135 на 10

Теперь ввод будет всего 13

Ваш код выполняет эти шаги до тех пор, пока все цифры не будут добавлены к обратному номеру или другими словами, пока ввод не станет 0.

Answer 2

Метод, позволяющий получить наибольшую степень из десяти, меньшую или равную целому числу: (в рекурсии)

public static int powerOfTen(int n) {
    if ( n < 10)
        return 1;
    else
        return 10 * powerOfTen(n/10); 
}

Метод, позволяющий изменить действительное целое число: (в рекурсии)

public static int reverseInteger(int i) {
    if (i / 10 < 1)
        return i ;
    else
        return i%10*powerOfTen(i) + reverseInteger(i/10);
}

Answer 3

Если идея не в том, чтобы использовать массивы или строки, то обращение целого числа должно быть сделано путем чтения цифр числа с конца по одному за раз. Ниже приводится подробное объяснение, чтобы помочь новичку.

псевдокод:

1. давайте начнем с reversed_number = 0 и некоторого значения для original_number, которое необходимо поменять местами.
2. the_last_digit = original_number% 10 (то есть напоминание после деления на 10)
3. original_number = original_number / 10 (поскольку у нас уже есть последняя цифра, удалите последнюю цифру из original_number)
4. reversed_number = reversed_number * 10 + last_digit (умножьте reversed_number на 10, чтобы добавить к нему last_digit)
5. повторяйте шаги со 2 по 4, пока исходный номер не станет 0. Когда исходный номер = 0, обратный номер будет иметь обратную сторону исходного номера.

Дополнительная информация о шаге 4: если вам предоставляется цифра за раз, и вас попросили добавить ее в конце числа, как бы вы это сделали - переместив исходное число на одно место влево так, чтобы разместить новую цифру. Если число 23 должно стать 234, умножьте 23 на 10, а затем добавьте 4.

234 = 23x10 + 4;

Код:

public static int reverseInt(int original_number) {
        int reversed_number = 0;
        while (original_number > 0) {
            int last_digit = original_number % 10;
            original_number = original_number / 10;
            reversed_number = reversed_number * 10 + last_digit;    
        }
        return reversed_number;
    }

Answer 4

123 соответствует 321, что можно рассчитать как 3 * (10 ^ 2) + 2 * (10 ^ 1) +1 Две функции используются для расчета (10 ^ N). Первая функция вычисляет значение N. Вторая функция вычисляет значение от десяти до степени N.

Function<Integer, Integer> powerN = x -> Double.valueOf(Math.log10(x)).intValue();
Function<Integer, Integer> ten2powerN = y -> Double.valueOf(Math.pow(10, y)).intValue();

// 123 => 321= 3*10^2 + 2*10 + 1
public int reverse(int number) {
    if (number < 10) {
        return number;
    } else {
        return (number % 10) * powerN.andThen(ten2powerN).apply(number) + reverse(number / 10);
    }
}

Answer 5

public static double reverse(int num)
{
    double num1 = num;
    double ret = 0;
    double counter = 0;

    while (num1 > 1)
    {   
        counter++;
        num1 = num1/10;
    }
    while(counter >= 0)
    {
        int lastdigit = num%10;
        ret += Math.pow(10, counter-1) * lastdigit;
        num = num/10;
        counter--;  
    }
    return ret;
}

Answer 6

Это самый короткий код, чтобы повернуть integer

int i=5263; 
System.out.println(Integer.parseInt(new StringBuffer(String.valueOf(i) ).reverse().toString()));

Answer 7

Обратное целое число

  int n, reverse = 0;
  Scanner in = new Scanner(System.in);
  n = in.nextInt();

  while(n != 0)
  {
      reverse = reverse * 10;
      reverse = reverse + n%10;
      n = n/10;
  }

  System.out.println("Reverse of the number is " + reverse);

Answer 8

import java.io.BufferedReader;
import java.io.InputStreamReader;
public class intreverse
{
public static void main(String...a)throws Exception
{
    int no;
    int rev = 0;
    System.out.println("Enter The no to be reversed");
    InputStreamReader str=new InputStreamReader(System.in);
    BufferedReader br =new BufferedReader(str);
    no=Integer.parseInt(br.readLine().toString());
    while(no!=0)
    {
        rev=rev*10+no%10;
        no=no/10;

    }
    System.out.println(rev);
}
}

Answer 9

import java.util.Scanner;

public class ReverseOfInteger {
    static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        int x = input.nextInt();
        System.out.print(helpermethod(x));
    }

    public static String helpermethod(int x) {
        if (x == 0)
            return "";
        String a = String.valueOf(x % 10);
        return a + helpermethod(x / 10);

    }
}

Answer 10

Даже если передано отрицательное целое число, оно даст отрицательное целое число. Попробуйте это ...

public int reverse(int result) {

    long newNum=0,old=result;
    result=(result>0) ? result:(0-result);

    while(result!=0){
        newNum*=10;
        newNum+=result%10;
        result/=10;
        if(newNum>Integer.MAX_VALUE||newNum<Integer.MIN_VALUE)
            return 0;
    }
    if(old > 0)
        return (int)newNum;
    else if(old < 0)
        return (int)(newNum*-1);
    else 
        return 0;
}