Может ли кто-нибудь объяснить мне, как изменить целое число без использования массива или String. Я получил этот код из Интернета, но не понимаю, почему + введите% 10 и снова разделите.
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
И как использовать этот примерный код для обращения только к нечетному числу. Пример: я получил этот вход 12345, затем он изменит нечетное число на вывод 531.
Я не понимаю, что вы нечетное число. Способ работы этого кода (это не специфический для 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;
}
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.
Просто вы можете использовать этот
public int getReverseInt(int value) {
int resultNumber = 0;
for (int i = value; i !=0; i /= 10) {
resultNumber = resultNumber * 10 + i % 10;
}
return resultNumber;
}
Вы можете использовать этот метод с заданным значением, которое вы хотите восстановить.
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
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;
}
}
int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());
Чтобы получить последнюю цифру любого числа, мы делим ее на 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);
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));
}
Это вернет обратное целое число
Просто добавьте, в надежде сделать решение более полным.
Логика @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;
}
int numberToReverse;//your number
StringBuilder sb=new StringBuilder();
sb.append(numberToReverse);
sb=sb.reverse();
String intermediateString=sb.toString();
int reversedNumber=Integer.parseInt(intermediateString);
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;
}
Вот полное решение (возвращает 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;
}
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));
}
Хорошо, что вы выписали свой исходный код. У меня есть другой способ закодировать эту концепцию обращения целого числа. Я могу разрешить до 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");
Метод, позволяющий получить наибольшую степень десяти, меньшую или равную целому числу: (в рекурсии)
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);
}
Даже если отрицательное целое передано, оно даст отрицательное целое число Попробуйте это...
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;
}
Это самый короткий код для изменения integer
int i=5263;
System.out.println(Integer.parseInt(new StringBuffer(String.valueOf(i) ).reverse().toString()));
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);
}
}
Если идея состоит в том, чтобы не использовать массивы или строку, обратное целое число должно выполняться путем считывания цифр числа из конца по одному. Ниже приводится подробное объяснение, чтобы помочь новичку.
псевдокод:
Дополнительная информация о шаге 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;
}
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
пусть число равно 168,
+ input% 10 возвращает последнюю цифру в качестве напоминания, т.е. 8, но в следующий раз он должен вернуть 6, следовательно, число должно быть уменьшено до 16 с 168, как разделить 168 на 10, что приводит к 16 вместо 16.8, поскольку переменный ввод должен быть целым типом в вышеуказанной программе.
Это устаревший вопрос, но как ссылка для других Прежде всего обратныйNum должен быть инициализирован до 0;
input% 10 используется для получения последней цифры с ввода
input/10 используется, чтобы избавиться от последней цифры от ввода, которую вы добавили в reversendNum
Предположим, что ввод был 135
135% 10 - 5 Поскольку обратное число было инициализировано равным 0 теперь reverseedNum будет 5
Тогда мы избавимся от 5, разделив 135 на 10
Теперь ввод будет всего 13
Ваш код проходит эти шаги до тех пор, пока все цифры не будут добавлены к обратному номеру или другими словами, пока вход не станет 0.
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);
}
}
Если вы хотите изменить любое число, например 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);
}
Вы можете использовать рекурсию, чтобы решить эту проблему.
сначала получите длину целого числа, используя следующую рекурсивную функцию.
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();
}
}
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;
}
//Приведенный выше код будет работать и для отрицательных чисел
Реверсивное целое число
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);
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;
}
Я использовал 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);
}
}
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;
}
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, удалив последнюю цифру.