任何人都可以向我解释如何在不使用数组或字符串的情况下反转整数。我从网上得到了这个代码，但不是很明白为什么+输入％10并再次划分。
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
以及如何使用此示例代码仅反转奇数。示例我得到了此输入12345，然后它将奇数反转为输出531。
我不清楚你的奇数。此代码的工作方式是（它不是Java特定的算法）例如。输入= 2345第一次在while循环中rev = 5输入= 234第二次rev = 5 * 10 + 4 = 54输入= 23第三次rev = 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;
}
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");
即使传递负整数，它也会给出负整数Try This ...
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现在reversNum将是5
然后我们通过将135除以10来摆脱5
现在输入只有13
您的代码循环执行这些步骤，直到所有数字都添加到反转的数字或换句话说，直到输入变为0。
Java反转int值 - 原则
Java反转一个int值 - 伪代码：
一个。提取输入数字的最右边数字。 （1234％10）= 4
湾取该数字（4）并将其添加到新的reversedNum中。
C。将reversedNum乘以10（4 * 10）= 40，这会在您的（4）右侧显示零。
d。将输入除以10，（删除最右边的数字）。 （1234/10）= 123
即用步骤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;
}
在真实的工作环境中，你永远不会做这样的事情。然而，你在没有帮助的情况下使用它来解决问题的过程将能够解决问题的人与那些想要解决问题的人区分开来，但除非他们被博客上的好人用勺子喂食，否则就不能分开。
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);
}
}
while (input != 0) {
reversedNum = reversedNum * 10 + input % 10;
input = input / 10;
}
让一个数字是168， +输入％10返回最后一位数作为提醒，即8，但下一次应该返回6，因此数字必须从168减少到16，因为168除以10导致16而不是16.8，因为变量输入应该是整数类型在上面的程序中。
如果你想反转任何数字，如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);
}
获得10的最大幂或小于整数的最大幂的方法:(在递归中）
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 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;
}
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);
}
}
我使用了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 int getReverseInt(int value) {
int resultNumber = 0;
for (int i = value; i !=0; i /= 10) {
resultNumber = resultNumber * 10 + i % 10;
}
return resultNumber;
}
您可以将此方法与您想要反转的给定值一起使用。
public static void reverse(int number) {
while (number != 0) {
int remainder = number % 10;
System.out.print(remainder);
number = number / 10;
}
System.out.println();
}
这样做，剥去最后一个数字（在10s内）并将其添加到前面然后将数字除以10，删除最后一位数。
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 rev * 10 = 850 rev * 10 + num％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;
}
}
看到获取任何数字的最后一位数字，我们将它除以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);
int aa=456;
int rev=Integer.parseInt(new StringBuilder(aa+"").reverse());
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;
}