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

Ответ 1

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

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

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

    }
    input = input / 10; 
}

Ответ 2

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

• Modding (%) вход int на 10 будет извлекать самую правую цифру. пример: (1234% 10) = 4

• Умножение целого числа на 10 будет "нажимать налево", показывая нуль справа от этого числа, например: (5 * 10) = 50

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

Java обратное значение int - Pseudocode:

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

б. Возьмите эту цифру (4) и добавьте ее в новый reverseedNum.

с. Multiply reversedNum на 10 (4 * 10) = 40, это предоставляет нуль справа от вашего (4).

д. Разделите вход на 10, (удаляя самую правую цифру). (1234/10) = 123

е. Повторите на шаге a с 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;
}

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

Ответ 3

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

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

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

Ответ 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
об * 10 = 850
об * 10 + число% 10 = 852

Ответ 5

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;
    }
}

Ответ 6

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

Ответ 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);

Ответ 8

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));
}

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

Ответ 9

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

Логика @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;
}

Ответ 10

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

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

Ответ 11

public static int reverse(int x) {
    boolean negetive = false;
    if (x < 0) {
        x = Math.abs(x);
        negative = true;
    }

    int y = 0, i = 0;
    while (x > 0) {
        if (i > 0) {
            y *= 10;
        }

        y += x % 10;
        x = x / 10;
        i++;
    }
    return negative ? -y : y;
}

Ответ 12

Вот полное решение (возвращает 0, если число переполнено):

public int reverse(int x) {
    boolean flag = false;

    // Helpful to check if int is within range of "int"
    long num = x;

    // if the number is negative then turn the flag on.
    if(x < 0) {
        flag = true;
        num = 0 - num;
    }

    // used for the result.
    long result = 0;

    // continue dividing till number is greater than 0
    while(num > 0) {
        result = result*10 + num%10;
        num= num/10;
    }

    if(flag) {
        result = 0 - result;
    }

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

Ответ 13

int convert (int n)
{
        long val = 0;

        if(n==0)
            return 0;

        for(int i = 1; n > exponent(10,  (i-1)); i++)
        {
            int mod = n%( (exponent(10, i))) ;
            int index = mod / (exponent(10, i-1));

            val *= 10;
            val += index;
        }

        if (val < Integer.MIN_VALUE || val > Integer.MAX_VALUE) 
        {
            throw new IllegalArgumentException
                (val + " cannot be cast to int without changing its value.");
        }
        return (int) val;

    }


static int exponent(int m, int n)
    {
        if(n < 0) 
            return 0;
        if(0 == n) 
            return 1;

        return (m * exponent(m, n-1));

    }

Ответ 14

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

if((inputNum <= 999999999)&&(inputNum > 0 ))
{
   System.out.print("Your number reversed is: ");

   do
   {
      endInt = inputNum % 10; //to get the last digit of the number
      inputNum /= 10;
      system.out.print(endInt);
   }
   While(inputNum != 0);
 System.out.println("");

}
 else
   System.out.println("You used an incorrect number of integers.\n");

System.out.println("Program end");

Ответ 15

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

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);
}

Ответ 16

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

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;
}

Ответ 17

Это самый короткий код для изменения integer

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

Ответ 18

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);
    }
}

Ответ 19

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

псевдокод:

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

Дополнительная информация о шаге 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;
    }

Ответ 20

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

пусть число равно 168,
+ input% 10 возвращает последнюю цифру в качестве напоминания, т.е. 8, но в следующий раз он должен вернуть 6, следовательно, число должно быть уменьшено до 16 с 168, как разделить 168 на 10, что приводит к 16 вместо 16.8, поскольку переменный ввод должен быть целым типом в вышеуказанной программе.

Ответ 21

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

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

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

Предположим, что ввод был 135

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

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

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

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

Ответ 22

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);
}
}

Ответ 23

Если вы хотите изменить любое число, например 1234, и хотите изменить это число, чтобы оно выглядело как 4321. Прежде всего, инициализируйте 3 переменные int org; int reverse = 0; и int напоминание; тогда поставь свою логику как

    Scanner input = new Scanner (System.in);
    System.out.println("Enter number to reverse ");
    int org = input.nextInt();
    int getReminder;
    int r = 0;
    int count = 0;

    while (org !=0){
        getReminder = org%10;
         r = 10 * r + getReminder;
         org = org/10;



    }
        System.out.println(r);

    }

Ответ 24

Вы можете использовать рекурсию, чтобы решить эту проблему.

сначала получите длину целого числа, используя следующую рекурсивную функцию.

int Length(int num,int count){
    if(num==0){
        return count;
    }
    else{
        count++;
        return Lenght(num/10,count);
    }
}

и затем вы можете просто умножить остаток числа на 10 ^ (длина целого числа - 1).

int ReturnReverse(int num,int Length,int reverse){
    if(Length!=0){
        reverse = reverse + ((num%10) * (int)(Math.pow(10,Length-1)));
        return ReturnReverse(num/10,Length-1,reverse);
    }
    return reverse;
}

Весь исходный код:

import java.util.Scanner;

public class ReverseNumbers {

    int Length(int num, int count) {
        if (num == 0) {
            return count;
        } else {
            return Length(num / 10, count + 1);
        }
    }

    int ReturnReverse(int num, int Length, int reverse) {
        if (Length != 0) {
            reverse = reverse + ((num % 10) * (int) (Math.pow(10, Length - 1)));
            return ReturnReverse(num / 10, Length - 1, reverse);
        }
        return reverse;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt();

        ReverseNumbers reverseNumbers = new ReverseNumbers();
        reverseNumbers.ReturnReverse(N, reverseNumbers.Length(N, 0), reverseNumbers.ReturnReverse(N, reverseNumbers.Length(N, 0), 0));

        scanner.close();
    }
}

Ответ 25

public int getReverseNumber(int number)
{
    int reminder = 0, result = 0;
    while (number !=0)
    {
        if (number >= 10 || number <= -10)
        {
            reminder = number % 10;
            result = result + reminder;
            result = result * 10;
            number = number / 10;
        }
        else
        {
            result = result + number;
            number /= 10;
        }
    }
    return result;

}

//Приведенный выше код будет работать и для отрицательных чисел

Ответ 26

Реверсивное целое число

  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);

Ответ 27

public static int reverse(int number) {
    int reverse = 0;
    while (number != 0) {
        int reminder = number % 10;
        reverse = reverse * 10 + reminder;
        number = number / 10;
    }

    return reverse;

}

Ответ 28

Я использовал String, и я сначала преобразовал int в String. Затем я использовал обратный метод. Я нашел обратное число в String, а затем я преобразовал строку обратно в int. Вот программа.

import java.util.*;

public class Panathinaikos {
    public static void my_try()
    {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the number you want to be reversed");
        int number = input.nextInt();
        String sReverse = Integer.toString(number);
        String reverse = new StringBuffer(sReverse).reverse().toString();
        int Reversed = Integer.parseInt(reverse);
        System.out.print("The number " + number+ " reversed is " + Reversed);
    }
}

Ответ 29

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;
}

Ответ 30

public static void reverse(int number) {
    while (number != 0) {
        int remainder = number % 10;
        System.out.print(remainder);
        number = number / 10;
    }

    System.out.println();
}

Что это такое, разделите последнюю цифру (в пределах 10-ти мест) и добавьте ее на передний план, а затем разделите число на 10, удалив последнюю цифру.