Java 反向整数leetcode——如何处理溢出
问题是： 整数的倒数 示例1:x=123，返回321 示例2:x=-123，返回-321 您是否注意到反向整数可能会溢出？假设输入是32位整数，则100000003溢出的相反值。你应该如何处理这些案件 抛出异常？很好，但是如果抛出异常不是一个选项呢？然后必须重新设计函数（即，添加一个额外的参数） 我搜索的网站的解决方案是：Java 反向整数leetcode——如何处理溢出,java,algorithm,integer,reverse,Java,Algorithm,Integer,Reverse,问题是： 整数的倒数 示例1:x=123，返回321 示例2:x=-123，返回-321 您是否注意到反向整数可能会溢出？假设输入是32位整数，则100000003溢出的相反值。你应该如何处理这些案件 抛出异常？很好，但是如果抛出异常不是一个选项呢？然后必须重新设计函数（即，添加一个额外的参数） 我搜索的网站的解决方案是： public class Solution { public static int reverse(int x) { int ret =
public class Solution {
public static int reverse(int x) {
int ret = 0;
boolean zero = false;
while (!zero) {
ret = ret * 10 + (x % 10);
x /= 10;
if(x == 0){
zero = true;
}
}
return ret;
}
public static void main(String[] args) {
int s = 1000000003;
System.out.println(reverse(s));
}
}
s=100000003-1294967295300000001public static String reverse(int x) {
boolean pos = x >= +0;
int y = (pos) ? x : -x;
StringBuilder sb = new StringBuilder(
String.valueOf(y));
sb.reverse();
if (!pos) {
sb.insert(0, '-');
}
return sb.toString();
}
public static void main(String[] args) {
for (int i = -10; i < 11; i++) {
System.out.printf("%d r= '%s'\n", i, reverse(i));
}
}
公共静态字符串反转（int x）{
布尔位置=x>=+0；
int y=（位置）x:-x；
StringBuilder sb=新的StringBuilder(
字符串的值（y））；
使某人倒转；
如果（！pos）{
sb.插入（0，“-”）；
}
使某人返回字符串（）；
}
公共静态void main（字符串[]args）{
对于（int i=-10；i<11；i++）{
System.out.printf（“%dr='%s'\n”，i，反向（i））；
}
}
正如我所期望的那样工作。如果您需要返回32位int，并且仍然需要知道是否存在溢出，那么您可以使用标志作为额外参数。如果使用C或C++，可以使用指针设置标志，或者在java中可以使用数组（因为java对象按值传递）。p> Java示例：
public class Solution {
public static int reverse(int x, Boolean[] overflowed) {
int ret = 0;
boolean zero = false;
boolean inputIsNegative = x < 0;
while (!zero) {
ret = ret * 10 + (x % 10);
x /= 10;
if(x == 0){
zero = true;
}
}
//Set the flag
if ( (inputIsNegative && (ret > 0)) || ((!inputIsNegative) && (ret < 0)))
overflowed[0] = new Boolean(true);
else
overflowed[0] = new Boolean(false);
return ret;
}
public static void main(String[] args) {
int s = 1000000004;
Boolean[] flag = {null};
System.out.println(s);
int n = reverse(s,flag); //reverse() will set the flag.
System.out.println(flag[0].booleanValue() ? "Error: Overflow": n );
}
}
公共类解决方案{
公共静态整数反转（整数x，布尔值[]溢出）{
int-ret=0；
布尔零=假；
布尔输入负性=x<0；
而（！零）{
ret=ret*10+（x%10）；
x/=10；
如果（x==0）{
零=真；
}
}
//立旗
如果（（输入负性和（ret>0））| |（（！输入负性和（ret<0）））
溢出[0]=新布尔值（true）；
其他的
溢出的[0]=新布尔值（false）；
返回ret；
}
公共静态void main（字符串[]args）{
int s=100000004；
布尔[]标志={null}；
系统输出打印项次；
int n=reverse（s，flag）；//reverse（）将设置该标志。
System.out.println（标志[0].booleanValue（）？“错误：溢出”：n）；
}
}
希望这能有所帮助。使用字符串存储反面，然后打印或使用long或BigInt我解决这个问题的方法是将输入的整数转换为c字符串，这样一切都会很简单
class Solution {
public:
int reverse(int x) {
char str[11];
bool isNegative = false;
int i;
int ret = 0;
if ( x < 0 ) {
isNegative = true;
x = -x;
}
i = 0;
while ( x != 0 ) {
str[i++] = x % 10 + '0';
x = x / 10;
}
str[i] = '\0';
if ( (isNegative && strlen(str) == 10 && strcmp(str, "2147483648") > 0) || (!isNegative && strlen(str) == 10 && strcmp(str, "2147483647") > 0) ) {
cout << "Out of range!" << endl;
throw new exception();
}
i = 0;
int strLen = (int)strlen(str);
while ( str[i] != '\0' ) {
ret += ((str[i] - '0') * pow(10.0, strLen - 1 - i));
i++;
}
return (isNegative ? -ret : ret);
}
类解决方案{
公众：
反向整数（整数x）{
char-str[11]；
bool为阴性=假；
int i；
int-ret=0；
if（x<0）{
isNegative=true；
x=-x；
}
i=0；
而（x！=0）{
str[i++]=x%10+'0'；
x=x/10；
}
str[i]='\0'；
如果（（isNegative和strlen（str）==10和strcmp（str，“2147483648”）>0）| |（！isNegative和strlen（str）==10和strcmp（str，“2147483647”）>0））{
cout公共类解决方案{
/**
*溢出
*@param x
*@返回
*/
公共整数反转（整数x）{
整数符号=x>0？1:-1；
x*=符号；
int-ret=0；
而（x>0）{
ret*=10；
if（ret10&&ret*10/10！=ret）//溢出
返回0；
ret+=x%10；
x/=10；
}
返回ret*符号；
}
公共静态void main（字符串[]args）{
断言新解决方案（）。反向（-2147483412）==-2147483412；
}
}
除了int之外，不需要任何数据类型。
只要确保当有一个增加数字的操作时，反转该操作应该会给出上一个数字。否则，就会出现溢出
public int reverse(int x) {
int y = 0;
while(x != 0) {
int yy = y*10 + x%10;
if ((yy - x%10)/10 != y) return 0;
else y = yy;
x = x/10;
}
return y;
}
以上大多数答案都有一个小问题，那就是int变量可能会溢出。
有一种简单的方法可以解决这个问题。将x转换为long，并检查结果是否>=Integer.MAX_值，否则返回0。
该解决方案通过了上的所有测试用例
这是一个java版本
public int reverse(int x) {
long k = x;
boolean isNegtive = false;
if(k < 0){
k = 0 - k;
isNegtive = true;
}
long result = 0;
while(k != 0){
result *= 10;
result += k % 10;
k /= 10;
}
if(result > Integer.MAX_VALUE) return 0;
return isNegtive ? 0 - ((int)result) : (int)result;
}
public int reverse（int x）{
长k=x；
布尔值为负=假；
if（k<0）{
k=0-k；
isnegative=true；
}
长结果=0；
while（k！=0）{
结果*=10；
结果+=k%10；
k/=10；
}
如果（结果>整数.MAX_值）返回0；
返回为负？0-（（int）结果）：（int）结果；
}
C版本
public int Reverse（int x）
{
长值=0；
布尔负=x<0；
长y=x；
y=Math.Abs（y）；
而（y>0）
{
数值*=10；
值+=y%10；
y/=10；
}
如果（值>int.MaxValue）
{
返回int.MaxValue；
}
int-ret=（int）值；
如果（否定）
{
返回0-ret；
}
其他的
{
返回ret；
}
}
Python版本
def reverse(self, x):
isNegative = x < 0
ret = 0
x = abs(x)
while x > 0:
ret *= 10
ret += x % 10
x /= 10
if ret > 1<<31:
return 0
if isNegative:
return 0 - ret
else:
return ret
def反转（自身，x）：
isNegative=x<0
ret=0
x=绝对值（x）
当x>0时：
ret*=10
ret+=x%10
x/=10
如果ret>1此java代码处理溢出情况：
public int reverse(int x) {
long reverse = 0;
while( x != 0 ) {
reverse = reverse * 10 + x % 10;
x = x/10;
}
if(reverse > Integer.MAX_VALUE || reverse < Integer.MIN_VALUE) {
return 0;
} else {
return (int) reverse;
}
}
public int reverse（int x）{
长反转=0；
而（x！=0）{
反向=反向*10+x%10；
x=x/10；
}
如果（反向>整数.MAX|u值|反向<整数.MIN_值）{
public int reverse(int x) {
long k = x;
boolean isNegtive = false;
if(k < 0){
k = 0 - k;
isNegtive = true;
}
long result = 0;
while(k != 0){
result *= 10;
result += k % 10;
k /= 10;
}
if(result > Integer.MAX_VALUE) return 0;
return isNegtive ? 0 - ((int)result) : (int)result;
}
public int Reverse(int x)
{
long value = 0;
bool negative = x < 0;
long y = x;
y = Math.Abs(y);
while (y > 0)
{
value *= 10;
value += y % 10;
y /= 10;
}
if(value > int.MaxValue)
{
return int.MaxValue;
}
int ret = (int)value;
if (negative)
{
return 0 - ret;
}
else
{
return ret;
}
}
def reverse(self, x):
isNegative = x < 0
ret = 0
x = abs(x)
while x > 0:
ret *= 10
ret += x % 10
x /= 10
if ret > 1<<31:
return 0
if isNegative:
return 0 - ret
else:
return ret
public int reverse(int x) {
long reverse = 0;
while( x != 0 ) {
reverse = reverse * 10 + x % 10;
x = x/10;
}
if(reverse > Integer.MAX_VALUE || reverse < Integer.MIN_VALUE) {
return 0;
} else {
return (int) reverse;
}
}
public class Solution {
public int Reverse(int x) {
var sign = x < 0 ? -1 : 1;
var reverse = 0;
if (x == int.MinValue)
{
return 0;
}
x = Math.Abs(x);
while(x > 0)
{
var remainder = x % 10;
if (reverse > ((int.MaxValue - remainder)/10))
{
return 0;
}
reverse = (reverse*10) + remainder;
x = x/10;
}
return sign * Convert.ToInt32(reverse);
}
}
public class Solution {
public int reverse(int x) {
long tmp = Math.abs((long)x);
long res = 0;
while(tmp >= 10){
res += tmp%10;
res*=10;
tmp=tmp/10;
}
res+=tmp;
if(x<0){
res = -res;
}
return (res>Integer.MAX_VALUE||res<Integer.MIN_VALUE)? 0: (int)res;
}
}
public class Solution {
public int reverse(int x) {
long tmp = x;
long res = 0;
if(x>0){
while(tmp >= 10){
res += tmp%10;
res*=10;
tmp=tmp/10;
}
}
else{
while(tmp <= -10){
res += tmp%10;
res*=10;
tmp=tmp/10;
}
}
res+=tmp;
return (res>Integer.MAX_VALUE||res<Integer.MIN_VALUE)? 0: (int)res;
}
}
public class Solution {
public int reverse(int A) {
// use long to monitor Overflow
long result = 0;
while (A != 0) {
result = result * 10 + (A % 10);
A = A / 10;
}
if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
return 0;
} else {
return (int) result;
}
}
}
public class Solution {
public int reverse(int x) {
int r;
long s = 0;
while(x != 0)
{
r = x % 10;
s = (s * 10) + r;
x = x/10;
}
if(s >= Integer.MAX_VALUE || s <= Integer.MIN_VALUE) return 0;
else
return (int)s;
}
}
public class ReverseInteger {
public static void main(String[] args) {
int input = Integer.MAX_VALUE;
int output = reverse(input);
System.out.println(output);
}
public static int reverse(int x) {
int remainder = 0;
int result = 0;
if (x < 10 && x > -10) {
return x;
}
while (x != 0) {
remainder = x % 10;
int absResult = Math.abs(result);
int maxResultMultipliedBy10 = Integer.MAX_VALUE / 10;
if (absResult > maxResultMultipliedBy10) {
return 0;
}
int resultMultipliedBy10 = absResult * 10;
int maxRemainder = Integer.MAX_VALUE - resultMultipliedBy10;
if (remainder > maxRemainder) {
return 0;
}
result = result * 10 + remainder;
x = x / 10;
}
return result;
}
}
func reverse(_ x : Int) -> Int {
var stringConversion = String(x)
var negativeCharacter = false
var finalreversedString = String()
let signedInt = 2147483647 //Max for Int 32
let unSignedInt = -2147483647 // Min for Int 32
if stringConversion.contains("-"){
stringConversion.removeFirst()
negativeCharacter = true
}
var reversedString = String(stringConversion.reversed())
if reversedString.first == "0" {
reversedString.removeFirst()
}
if negativeCharacter {
finalreversedString = "-\(reversedString)"
} else {
finalreversedString = reversedString
}
return (x == 0 || Int(finalreversedString)! > signedInt || Int(finalreversedString)! < unSignedInt) ? 0 : Int(finalreversedString)!
}
public int reverse(int A) {
int reverse=0;
int num=A;
boolean flag=false;
if(A<0)
{
num=(-1)*A;
flag=true;
}
int prevnum=0;
while(num>0)
{
int currDigit=num%10;
reverse=reverse*10+currDigit;
if((reverse-currDigit)/10!=prevnum)
return 0;
num=num/10;
prevnum=reverse;
}
if(flag==true)
reverse= reverse*-1;
return reverse;
}
public int reverse(int x)
{
long result = 0;
int res;
int num = Math.abs(x);
while(num!=0)
{
int rem = num%10;
result = result *10 + rem;
num = num / 10;
}
if(result > Integer.MAX_VALUE || result < Integer.MIN_VALUE)
{
return 0;
}
else
{
res = (int)result;
return x < 0 ? -res : res;
}
}
class Solution {
public int reverse(int x) {
long rev = 0, remainder = 0;
long number = x;
while (number != 0) {
remainder = number % 10;
rev = rev * 10 + remainder;
number = number / 10;
}
if (rev >= Integer.MAX_VALUE || rev <= Integer.MIN_VALUE || x >= Integer.MAX_VALUE || x <= Integer.MIN_VALUE)
return 0;
else
return (int) rev;
}
}
public int reverse(int x) {
int y = 0;
while(x != 0) {
if(y > Integer.MAX_VALUE/10 || y < Integer.MIN_VALUE/10) return 0;
y *= 10;
y += x % 10;
x /= 10;
}
return y;
}
int reverse(int x) {
int y = 0;
while(x != 0) {
if ( (long)y*10 + x%10 > INT_MAX || (long)y*10 + x%10 < INT_MIN) {
std::cout << "overflow occurred" << '\n'
return 0;
}
y = y*10 + x%10;
x = x/10;
}
return y;
}
/**
* @param {number} x
* @return {number}
*/
var reverse = function(x) {
let oldNum = x, newNum = 0, digits = 0, negativeNum = false;
if(oldNum < 0){
negativeNum = true;
}
let absVal = Math.abs(x);
while(absVal != 0){
let r = Math.trunc(absVal % 10);
newNum = (newNum*10) + r; digits++;
absVal = Math.floor(absVal/10);
}
if( !(newNum < Number.MAX_VALUE && newNum >= -2147483648 && newNum <= 2147483647)){
return 0;
}
return negativeNum ? -newNum :newNum;
};
/**
* @param {number} x
* @return {number}
*/
var reverse = function(x) {
let oldNum = x, newNum = 0, digits = 0, negativeNum = false;
if(oldNum < 0){
negativeNum = true;
}
let absVal = Math.abs(x);
while(absVal != 0){
let r = Math.trunc(absVal % 10);
newNum = (newNum*10) + r; digits++;
absVal = Math.floor(absVal/10);
}
if( !(newNum < Number.MAX_VALUE && newNum >= -2147483648 && newNum <= 2147483647)){
return 0;
}
return negativeNum ? -newNum :newNum;
};
class Solution:
def reverse(self, x: int):
reverse = 0
if x > 0:
while x != 0:
remainder = x % 10
if reverse > (2147483647/10):
return 0
reverse = reverse * 10 + remainder
x = int(x / 10)
return reverse
elif x < 0:
x = x * (-1)
while x != 0:
remainder = x % 10
if reverse > ((2147483648)/10):
return 0
reverse = reverse * 10 + remainder
x = int(x / 10)
reverse = reverse * (-1)
return reverse
else:
return 0
const reverse = function (x) {
const strReversed = x.toString().split("").reverse().join("");
rv =
parseInt(strReversed) > Math.pow(2, 31)
? 0
: Math.sign(x) * parseInt(strReversed);
return rv;
};
class Solution {
public int reverse(int x) {
int n = Math.abs(x);
String num = Integer.toString(n);
StringBuilder sb = new StringBuilder(num);
sb.reverse();
String sb1;
sb1 = sb.toString();
int foo;
try {
foo = Integer.parseInt(sb1);
}
catch (NumberFormatException e){
foo = 0;
}
if(x < 0){
foo *= -1;
}
return foo;
}
}