首页 > 试题广场 >

反转数字

[编程题]反转数字

热度指数：61797 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 256M，其他语言512M
算法知识视频讲解

给定一个32位的有符号整数num，将num中的数字部分反转，最后返回反转的结果

1.只反转数字部分，符号位部分不反转

2.反转后整数num超过 32 位的有符号整数的范围 [−2³¹, 2³¹ − 1] ，返回 0

3.假设本题不允许存储 64 位整数(有符号或无符号，即C++不能使用long long ，Java不能使用long等)

数据范围:

-2³¹ <= x <= 2³¹-1

示例1

输入

输出

示例2

输入

-123

输出

-321

示例3

输入

输出

示例4

输入

1147483649

输出

算法知识视频讲解

Howie59

class Solution {
    public int reverse(int x) {
        int result = 0;
        while (x != 0) {
            int mod = x % 10;
            x = x / 10;
            if (result > Integer.MAX_VALUE / 10 || result < Integer.MIN_VALUE / 10) return 0;
            result = result * 10 + mod;
        }
        return result;
    }
}

发表于 2018-10-02 18:27:33 回复(2)

Java

牛客慧

import java.util.*;

//最好借助数学思想(L*10+x%10),不要想用字符串反转方法，
//因为字符串反转还需要考虑1000这种情况,反而变得复杂了
public class Solution {
    /**
     * 
     * @param x int整型 
     * @return int整型
     */
    public int reverse (int x) {
        // write code here
        long l=0;
        int flag=1;
        if(x<0){
            x=-x;
            flag=-1;
        }
        while(x!=0){
            l=l*10+x%10;
            x=x/10;
        }
        if(l>=Integer.MIN_VALUE && l<=Integer.MAX_VALUE){
            return flag*(int)l;
        }else{
            return 0;
        }
    }
}

发表于 2021-07-26 15:47:56 回复(0)

元气の悟空

class Solution {
public:
    int reverse(int x) {
        int flag=0;
        if(x<0) flag=1,x=-x;
        char t[100],tmp;
        sprintf(t,"%d",x);
        int len=strlen(t),i,j;
        for(i=0,j=len-1;i<j;i++,j--){
            tmp=t[i];
            t[i]=t[j];
            t[j]=tmp;
        }
        int res=atoi(t);
        if(flag==1) res=-res;
        return res;
    }
};

发表于 2017-10-24 20:04:28 回复(1)

C/C++

武汉孙一峰

//须要考虑益处的情况，int类型能表示的最大和最小的数分别是2^32-1,-2^31
class Solution {
public:
    int reverse(int x) {
        vector<int> v;
        long long ans=0;
        bool tag=true;
        const int max32 = 0x7fffffff;  
        const int min32 = 0x80000000; 
        
        if(x<0)
        {
             tag=false;
             x=0-x;
        }
        
        while(x)
        {
            v.push_back(x%10);
            x/=10;
        }
        
        for(int i=0;i<v.size();i++)
        {
            ans=ans*10+v[i];
        }
        if(ans<min32||ans>max32) 
            return 0;
        
        if(tag)
            return ans;
        else
            return 0-ans;
    }
};

发表于 2017-04-08 00:30:23 回复(0)

Boolean布尔

public class Solution {
    public int reverse(int x) {
        if(x == 0){
            return x;
        }
        StringBuffer buffer = new StringBuffer();
        boolean isFu = x<0?true:false;
        if(isFu) buffer.append("-");
        int y = Math.abs(x);
        while(y%10 == 0){// 去掉末尾的0
            y = y/10;
        }
        while(y/10 != 0){
            buffer.append(y%10);
            y= y/10;
        }
  
        buffer.append(y);
        return Integer.parseInt(buffer.toString());
    }
}

发表于 2016-06-14 13:49:22 回复(3)

Fool_one

无需 long long 的做法，在计算的时候判溢出：

class Solution {
public:
    /**
     * 
     * @param x int整型 
     * @return int整型
     */
    int reverse(int x) {
        int r = 0;
        while (x) {
            // 判溢出
            if (r > 0 && r > (INT_MAX - x % 10) / 10) return 0;
            if (r < 0 && r < (INT_MIN - x % 10) / 10) return 0;
            r = r * 10 + x % 10;
            x /= 10;
        }
        return r;
    }
};

注意：负数取模仍为负数。

发表于 2021-05-31 21:27:37 回复(0)

Python

wengJJ

Python

实际上Python3之后，int类型已是无界类型，一旦int溢出情况出现则会转成long类型

所以Python3可以不用做任何边界判断

http://docs.python.org/3.1/whatsnew/3.0.html#integers

#
# 
# @param x int整型 
# @return int整型
#
import sys
class Solution:
    def reverse(self , x ):
        # 判断值是否越界，对于Python3可不做此操作
#        if x > sys.maxsize&nbs***bsp;x < -sys.maxsize -1:
#            return 0
        res = 0
        num = abs(x)
        while num:
            res = res*10 + num%10
            num = int(num/10)
        if x>0:
            return res
        else:
            return -res

发表于 2021-04-22 15:27:40 回复(0)

Java

花落梦里

    public int reverse (int x) {
        int res=0;
        while(x!=0){//计算之前计算后续会不会出现溢出
            if(res>=Integer.MAX_VALUE/10||res<=Integer.MIN_VALUE/10)
                 return 0;
            res=res*10+x%10;
            x=x/10;
        }
        return res;
    }

发表于 2021-03-24 16:59:55 回复(0)

zbbsyx

class Solution {
public:
    int reverse(int x) {
        string s = to_string(x);
        if(x < 0)
            return -atoi(string(s.rbegin(),s.rend()).c_str());
        else
            return atoi(string(s.rbegin(),s.rend()).c_str());
    }
};

//懒人做法~

发表于 2019-05-23 16:35:20 回复(0)

牛客782860号

class Solution {
public:
    int reverse(int x) {
   int result = 0;
   while (x != 0)
   {
        if ((result > 2147483647 / 10) || (result < -2147483647/10))
            return 0;
       result=result*10+x%10;
       x = x / 10;
   }
   return result;
    }
};

发表于 2017-12-25 21:41:27 回复(0)

王大爷

class Solution {
    bool isOverflow=false;
public:
    int reverse(int x) {
        int flag=1;
        if(x<0)flag=-1,x=-x;
        
        string tmp=to_string(x);
        ::reverse(tmp.begin(),tmp.end());
        
        string imax=to_string(INT_MAX);
        if(tmp.size()>= imax.size() && tmp>imax){
            isOverflow=true;
            return 0;
        }
        return stoi(tmp)*flag;
    }
};

发表于 2017-09-11 21:49:30 回复(0)

C/C++

Fannie-帆

class Solution {

public:

int reverse(int x) {

int num;

num = abs(x);

if(num%10==0) num = num / 10; //去除末尾的0

string str = "";

str += to_string(num);

int len = str.length();

for(int i=0; i<len/2; i++){

string tmp = "";

tmp[0] = str[i];

str[i] = str[len - i - 1];

str[len - i - 1] = tmp[0];

}

string max_str = "";

max_str += to_string(INT_MAX);

int max_len = max_str.length();

int res = atoi(str.c_str());

if (x<0) res = 0 - res;

if(max_len > len) return res;

for(int i=0; i<max_len; i++){

if (max_str[i] < str[i]) return 0;

if (max_str[i] > str[i]) return res;

}

return INT_MAX;

}

};

就是不明白，如果溢出的时候也需要输出怎么办。我只能想到输出字符串。

发表于 2017-03-27 22:03:33 回复(0)

好好学习->天天向上

class Solution {
public:
    int reverse(int x) {
        int num = abs(x), ret(0);
        while(num > 0){
            //先检查是否会溢出
            if(ret > (INT_MAX - num%10) / 10)	return 0;
            ret = ret * 10 + num %10;
            num = num / 10;
        }
        
        return x>0 ? ret : -ret;
    }
};

检查溢出的不等式来自于：res*10 + num%10 > INT_MAX。此不等式若成立，则会溢出，返回0即可。

发表于 2016-08-15 13:46:52 回复(1)

Java

m-coder

import java.util.*;


public class Solution {
    /**
     * 
     * @param x int整型 
     * @return int整型
     */
    public int reverse (int x) {
        // write code here
        int res=0;
        while(x!=0){
            res=res*10+x%10;
            if(res-x%10!=res/10*10) return 0; //溢出判断
            x=x/10;
        }
        return res;
    }
}

发表于 2022-03-22 16:12:04 回复(0)

C++

皮卡丘乒乓

class Solution {
public:
    int reverse(int x) {
        long m=0;
        while(x)
        {
            m*=10;
            m += x%10;
            x/=10;
            
        }
        if(m>INT_MAX||m<INT_MIN)
            return 0;
        else
            return m;
        
    }
};

发表于 2021-08-10 01:23:40 回复(0)

ahac

class Solution {
public:
    int reverse(int x) {
        int res=0;
        int flag=0;
        if(x<0){
            flag=1;
        }
        x=x>0?x:-x;
        while(x){
            res=res*10+x%10;
            x/=10;
        }
        if(flag){
            return -1*res;
        }else{
            return res;
        }
    }
};

发表于 2016-05-22 21:09:13 回复(2)

JacobGo！

//本体关键点是如何判断溢出。
//推荐解答用的是用long类型存储结果，如果结果大于0x7fffffff或者小于0x80000000就溢出
//我的解法是每次计算新的结果时，再用逆运算判断与上一次循环的结果是否相同，不同就溢出
public int reverse(int x) {
		int res=0;
		while(x!=0){
			//最后一位
			int tail=x%10;
			int newRes=res*10+tail;
			//如果newRes-tail)/10!=res说明产生了溢出
			if((newRes-tail)/10!=res)
				return 0;
			res=newRes;
			x=x/10;
		}
		return res;
	}

编辑于 2017-07-29 12:38:22 回复(14)

LinuX18

class Solution {
public:
    int reverse(int x) 
    {
       long long res = 0;
       while(x!=0)
       {
           res = res*10+x%10;
           x/=10;
           if(res >= INT_MAX || res <= INT_MIN)
               return 0;
       }
        return res;
    }
};

编辑于 2017-07-27 17:55:06 回复(2)

后劲好大

// 与剑指offer上的一道题很相似，要考虑溢出
public class Solution {
    public int reverse(int x) {
        if(x == 0)
        	return x;
        
        String num = String.valueOf(x);
        int inx = 0;
        boolean minus = false;
        if(num.charAt(0) == '-'){
        	minus = true;
        	inx++;
        }
        long res = 0;
        for(int i = num.length() - 1; i >= inx ; i--){
        	int flag = minus ? -1 : 1;
        	res = res * 10 + flag * (num.charAt(i) - '0');
        	if(isOverflow(res))
        		return 0;
        }
        return (int) res;
    }
	
	public boolean isOverflow(long x){
		if(x > 0){
			if(x > 0x7fffffff)
				return true;
		}
		else{
			if(x < 0x80000000)
				return true;
		}		
		return false;
	}
}

发表于 2017-05-01 11:17:35 回复(0)

风中追风20180314092925

int reverse(int x) {
    long long res = 0;
    while (x) {
        res = res*10 + x%10;
        x /= 10;
    }
    return (res > INT_MAX || res < INT_MIN) ? 0 : res;
}

发表于 2019-05-01 08:52:29 回复(0)

提交观点

问题信息

模拟

难度：

214条回答 267收藏 26156浏览

通过挑战的用户

查看代码

牛客65523...

2022-10-08 22:19:52
Zincy星辰

2022-09-16 12:17:56
Flawles...

2022-09-16 12:11:47
Huya丶幻神

2022-09-16 10:06:35
蒋燊

2022-09-16 07:49:55

反转数字

输入

输出

输入

输出

输入

输出

输入

输出

问题信息

热门推荐

通过挑战的用户

相关试题