谁能向我解释如何在不使用数组或字符串的情况下反转整数。我从网上得到了这段代码，但不是很明白为什么 + 输入 % 10 并再次划分。
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
以及如何使用此示例代码仅反转奇数。例子我得到这个输入12345，然后它会将奇数反转输出531。
【问题讨论】：
Java 反转 int 值 - 原理
将输入 int 修改 (%) 10 将提取最右边的数字。示例：(1234 % 10) = 4
将一个整数乘以 10 将“向左推”，在该数字的右侧显示一个零，例如：(5 * 10) = 50
将整数除以 10 将删除最右边的数字。 (75 / 10) = 7
Java 反转一个 int 值 - 伪代码：
一个。提取输入数字的最右边的数字。 (1234 % 10) = 4
b.取那个数字 (4) 并将其添加到一个新的 reversedNum 中。
c。将 reversedNum 乘以 10 (4 * 10) = 40，这会在 (4) 的右侧显示一个零。
d。将输入除以 10，（删除最右边的数字）。 (1234 / 10) = 123
e。在步骤 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;
}
在现实工作世界中，你永远不会做这样的事情。但是，您在没有帮助的情况下解决问题的过程将能够解决问题的人与想要解决问题的人区分开来，但除非他们被博客上的好人用勺子喂饱，否则无法解决问题。
【讨论】：
long，只是为了返回一个int？跟划分精度有关系吗？
我不清楚你的奇数。 这段代码的工作方式是（它不是 Java 特定的算法） 例如。 输入=2345 第一次在while循环中 转=5 输入=234 第二次 转速=5*10+4=54 输入=23 第三次 转速=54*10+3 输入=2 第四次 rev=543*10+2 输入=0
所以倒过来的数字是 5432。 如果您只想要反转数字中的奇数，那么。 代码是：
while (input != 0) {
last_digit = input % 10;
if (last_digit % 2 != 0) {
reversedNum = reversedNum * 10 + last_digit;
}
input = input / 10;
}
【讨论】：
reversedNum = reversedNum * 10 + input % 10;
你可以用这个
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 所以：
num%10 = 2
转 *10 = 850
rev*10 + num%10 = 852
【讨论】：
int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());
【讨论】：
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;
}
}
【讨论】：
看到得到任何数字的最后一位，我们将它除以 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;
}
【讨论】：
2147483647 会导致输出7463847412，溢出。实际允许/不允许的数字集要复杂得多。
int numberToReverse;//your number
StringBuilder sb=new StringBuilder();
sb.append(numberToReverse);
sb=sb.reverse();
String intermediateString=sb.toString();
int reversedNumber=Integer.parseInt(intermediateString);
【讨论】：
sb.reverse()内部有一个循环
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);
}
}
【讨论】：
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;
}
【讨论】：
Scanner input = new Scanner(System.in);
System.out.print("Enter number :");
int num = input.nextInt();
System.out.print("Reverse number :");
int value;
while( num > 0){
value = num % 10;
num /= 10;
System.out.print(value); //value = Reverse
}
【讨论】：
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 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 的值。第二个函数计算 10 的 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;
}
【讨论】：
这是一个过时的问题，但作为其他人的参考 首先reversedNum必须初始化为0；
input%10 用于获取输入的最后一位数字
input/10 用于删除输入中的最后一个数字，您已将其添加到 reversedNum
假设输入是 135
135 % 10 是 5 由于反转的数字被初始化为 0 现在 reversedNum 将是 5
然后我们通过将 135 除以 10 来消除 5
现在输入将只有 13
您的代码循环执行这些步骤，直到所有数字都添加到反转的数字中，或者换句话说，直到输入变为 0。
【讨论】：
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
设一个数为 168，
+ input % 10 返回最后一个数字作为提醒，即 8 但下次它应该返回 6，因此数字必须从 168 减少到 16，因为将 168 除以 10 得到 16 而不是 16.8，因为变量输入应该是整数类型在上述程序中。
【讨论】：
如果你想反转任何像 1234 这样的数字并且你想反转这个数字让它看起来像 4321。首先，初始化 3 个变量 int org ; int 反向 = 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);
}
【讨论】：
求小于或等于整数的十次方的最大幂的方法：（递归）
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);
}
【讨论】：
你可以使用递归来解决这个问题。
先用下面的递归函数得到一个整数的长度。
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 reverseInt(int i) {
int reservedInt = 0;
try{
String s = String.valueOf(i);
String reversed = reverseWithStringBuilder(s);
reservedInt = Integer.parseInt(reversed);
}catch (NumberFormatException e){
System.out.println("exception caught was " + e.getMessage());
}
return reservedInt;
}
public static String reverseWithStringBuilder(String str) {
System.out.println(str);
StringBuilder sb = new StringBuilder(str);
StringBuilder reversed = sb.reverse();
return reversed.toString();
}
【讨论】：
public static int reverse(int x) {
int tmp = x;
int oct = 0;
int res = 0;
while (true) {
oct = tmp % 10;
tmp = tmp / 10;
res = (res+oct)*10;
if ((tmp/10) == 0) {
res = res+tmp;
return res;
}
}
}
【讨论】：
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;
}
【讨论】：