精华内容
下载资源
问答
  • 整数反转JAVA

    2020-06-28 20:08:37
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的有符号...

    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。

    示例 1:

    输入: 123
    输出: 321
    示例 2:

    输入: -123
    输出: -321
    示例 3:

    输入: 120
    输出: 21
    注意:

    假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。

    package com.lxh.test;
    /**
     * 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。
     * 示例 1:
     * 输入: 123
     * 输出: 321
     * 示例 2:
     * 输入: -123
     * 输出: -321
     * 示例 3:
     * 输入: 120
     * 输出: 21
     * 
     * 注意:
    
       假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231,  231 − 1]。
       请根据这个假设,如果反转后整数溢出那么就返回 0。
    
     * @author dell
     *
     */
    public class Test7 {
    	public static int reverse1(int x)
    	{
    		if(x ==Integer.MIN_VALUE) return 0;
    		int neg = x<0?-1:1;
    		x *=neg;
    		int ret = 0;
    		while(x>0)
    		{
    			int n = ret;
    			n*= 10;
    			n+=x%10;
    			x/=10;
    			if(n/10!=ret) return 0;
    			ret = n;
    		}
    		return neg*ret;
    	}
    	public static int reverse2(int x)
    	{
            int rev = 0;
            while (x != 0) {
                int pop = x % 10;
                x /= 10;
                if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
                if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
                rev = rev * 10 + pop;
            }
            return rev;
    	}
    	public static void main(String[] args) {
    		System.out.println(reverse1(-123));
    		System.out.println(reverse2(-123));
    	}
    }
    
    
    展开全文
  • 7.整数反转Java

    2021-06-30 14:10:13
    7.整数反转Java 题目描述 给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ,就返回 0。 假设环境不允许存储 64 位整数(有...

    7.整数反转Java

    题目描述

    给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。
    如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ,就返回 0。
    假设环境不允许存储 64 位整数(有符号或无符号)。

    输入输出样式

    示例1:
    输入:x = 123
    输出:321

    示例2:
    输入:x = -123
    输出:-321

    本题来自LeetCode:https://leetcode-cn.com/problems/reverse-integer/

    思路

    方法一:每次取输入数字的末尾一个数,依次实现反转。但是要注意溢出问题,因为这里允许32位不能用64位存储的long型。
    在这里插入图片描述

    方法二:利用字符串,将数字转化为字符串,调用字符串reverse方法。同时注意溢出和符号问题。

    算法分析

    时间复杂度O(log |x|),空间复杂度为O(1)

    求解函数

    public int reverse(int x) {
            int rev = 0;
            while (x != 0) {
           		//溢出则直接返回0
                if (rev < Integer.MIN_VALUE / 10 || rev > Integer.MAX_VALUE / 10) {
                    return 0;
                }
                int digit = x % 10;
                x /= 10;
                rev = rev * 10 + digit;
            }
            return rev;
        }
    
        public int reverse(int x) {
            // 判断符号,存起来
            int op = x>0?1:-1;
            x = Math.abs(x);
            String s = new StringBuffer(String.valueOf(x)).reverse().toString();
            String sMax = String.valueOf(Integer.MAX_VALUE);
            int length = sMax.length();
            //判断溢出
            if(s.length()>=length && s.compareTo(sMax)>0){
                return 0;
            }
            return Integer.valueOf(s) *op;
        }
    
    展开全文
  • 7. 整数反转java写法

    2020-07-20 22:39:21
    如果是正整数,利用%10和/10的方式,不断取出对应位置上的数字,并且赋值到字符串的尾部;最后,Integer.parseInt方法转化为正整数并返回。 如果是负整数,先取绝对值,然后按照%10和/10的方式,不断取出对应位置上...

    我的思路是:

    如果是正整数,利用%10和/10的方式,不断取出对应位置上的数字,并且赋值到字符串的尾部;最后,Integer.parseInt方法转化为正整数并返回。
    如果是负整数,先取绝对值,然后按照%10和/10的方式,不断取出对应位置上的数字,同样添加到字符串上;最后转化为正整数,添加负号并返回。

    但是没有考虑到溢出的情况,后来根据官方的思想,了解了溢出的现象,只能把错误处理了,报NumberFormatException异常,表示溢出;

    class Solution {
        public int reverse(int x) {
           int c=0;
           String b ="";
           try{
                if(x>0){
                while(x>0) {
                    b=b+x%10;
                    x=x/10;
                }
            c = Integer.parseInt(b);
                }else if(x<0){
                    x=Math.abs(x);
                while(x>0) {
                    b=b+x%10;
                    x=x/10;
                }
            c = Integer.parseInt(b);
            c=-c;
            }else{
                c=0;
            }
        }catch(NumberFormatException e){
        }
                return c;
      }
    }

     

    时间复杂度为O(log10(x)),时间15ms,比较惨。

    下附力扣给出的官方答案:

    public static int reverse(int x) {
            int rev = 0;//rev存储反转的数字
            while(x!=0){
                int pop = x%10;//pop表示弹出的数
                //如果已经反转内容rev大于Integr最大值/10,那么一定溢出;
                // 如果最rev反转内容等于最大值/10且最后一位pop的数字大于7,那么就从正数这边溢出了
                //另外一种就是从负数那边溢出了
                if((rev>Integer.MAX_VALUE/10||(rev==Integer.MAX_VALUE/10&&pop>7))
                        ||rev<Integer.MIN_VALUE/10||(rev==Integer.MIN_VALUE/10&&pop<-8)){
                    return 0;
                }
                rev=rev*10+pop;//把pop防到rev后面
                x/=10;//去掉已经pop的内容
            }
            return rev;
        }
    

    只有6ms,膜拜

    展开全文
  • java 整数反转

    千次阅读 2019-06-05 20:19:22
    整数反转 题目描述: 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境...

    整数反转

    题目描述:

    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。
    
    示例 1:
    
    输入: 123
    输出: 321
     示例 2:
    
    输入: -123
    输出: -321
    示例 3:
    
    输入: 120
    输出: 21
    注意:
    
    假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231,  231 − 1]。
    请根据这个假设,如果反转后整数溢出那么就返回 0。
    

    题目分析:

    	因为反转之后存储在数组中的数据 在输出时由于数字过大会有溢出,可以使用一个 long long 型数据进行与2的31次方的溢出比较,
    遗憾的是 java 中没有 longlong 型数据,哈哈,不过也无所谓,我们可以用 溢出之后数字/10 与原数字不等的方法 与原数字比较进行判定
    有点不好理解,其实就是这样的:
    								if(ans != (ans * 10)/10)		
    

    代码展示(已验证):

    //因为 反转之后存储在数组中的数据 在输出时 会有溢出,可以使用一个 longlong 型数据进行比较
    //遗憾的是 java 中没有 longlong 型数据
    // 所以可以使用 溢出之后数字不等的方法 与原数字比较进行判定
    package leetcode;
    
    import java.util.Scanner;
    
    public class IntegerInversion 
    {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		int x = input.nextInt();
    		
    		int ans = 0;
    		int flag = x>0?1:-1;	// 表示的就是 正数,负数的状态 flag
    		x = x > 0 ? x : -x;		// 将x 转为正数 进行运算
    		while(x !=0)
    		{
    			if(ans != (ans * 10)/10)	// 判断 是否溢出(溢出的话 数据ans/10 和原来的ans 不相等)
    				{
    				System.out.println(0);		// leetcode 上面 都是 直接 return 数据,所以形式有所不同
    				break;
    				}
    			ans =ans * 10 + x%10;	// 倒序输出
    			x /= 10;
    		}
    		System.out.println(flag * ans);	// 正负数状态输出
    	}
    }
    

    泡泡:

    最重要的点在于如何解决溢出,其次就是倒序输出,最后的话就是状态了
    	溢出判断:
    		if(ans != (ans * 10)/10)
    	倒序输出:
    		ans =ans * 10 + x%10;
    		System.out.println(flag*ans);
    	状态处理:
    		int flag = x>0 ? 1:-1;
    

    ok,收工。

    展开全文
  • 在看到题目,我竟然不是想着去找他的反转的规律,而是直接通过遍历反转。想法有点硬,拉胯货色,不过能解出来就是好解。。 就是先判断数字是否带符号,也就是判断是否为负数,如果是负数,则倒转遍历转成字符串类型...
  • 整数反转 java 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储...
  • 浅析 LeetCode_007_整数反转Java 实现)LeetCode_007_整数反转题目描述总体分析解决方案小结 LeetCode_007_整数反转 题目描述 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: ...
  • 7.整数反转(简单) 题目如下: 给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ,就返回 0 假设环境不允许存储 64 位整数(有...
  • Java实现整数反转

    2021-07-22 14:08:25
    方法一: public static void main(String[] args) { ... System.out.println("输入一个4位整数:"); int num = scanner.nextInt(); String x= String.valueOf(num); StringBuffer stringBuffer = new .
  • 力扣——整数反转java

    千次阅读 2019-04-24 16:47:43
    题目:整数反转 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得...
  • Java实现 整数反转

    2020-07-29 04:39:24
    整数反转 原题地址: https://leetcode-cn.com/problems/reverse-integer/ 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 ...
  • 整数反转java

    千次阅读 2019-05-29 17:13:46
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转 示例1: 输入: 123 输出: 321 注意:假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为[−2的31方, 2的31方− 1]。请根据这个...
  • Java-整数反转-20190419

    千次阅读 2019-04-19 23:50:31
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1:输入: 123 输出: 321 示例 2:输入: -123 输出: -321 示例 3:输入: 120 输出: 21 注意:假设我们的环境只能存储得下 32 位的有符号整数...
  • 整数反转JAVA

    2021-05-21 17:27:52
    给你一个32位的有符号整数x,返回将x中的数字部分反转后的结果,如果反转整数超过32位的有符号整数范围[-2^31, 2^31-1]就返回0。假设环境不允许存储64位整数(有符号或无符号) 提示:-2^31 <= X<= 2^31-1 ...
  • java整数反转两种方式

    2020-07-17 09:31:26
    标题:java整数反转两种方式 一、题目 二、题解 方法一: * sum使用了double,sum=sum*10+b; //避免sum溢出 * -2147483648, * -2147483647,和2147483647只是符号不同 public int reverse02(int x) { boolean ...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 注意:假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为[−231, 231− 1]。请根据这个假设,如果反转整数溢出那么就返回 0...
  • 如果反转整数超过 32 位的有符号整数的范围 [−231,231−1][−2^{31}, 2^{31} − 1][−231,231−1] ,就返回 0。 假设环境不允许存储 64 位整数(有符号或无符号)。 解析: 该题可以借助字符串实现,但是转换...
  • leetcode 整数反转 java

    2020-02-26 11:01:28
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的有...
  • 执行用时 :2 ms, 在所有 java 提交中击败了53.22%的用户 内存消耗 :33.5 MB, 在所有 java 提交中击败了80.84%的用户 代码和注释 class Solution { public int reverse(int x) { int tmp = x; int revs = ...
  • leetcode 7.反转整数JAVA

    千次阅读 2018-10-19 17:15:14
    给定一个 32 位有符号整数,将整数中的数字进行反转。 示例 1: 输入: 123 输出: 321  示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们的环境只能存储 32 位有符号整数,...
  • leetcode初级算法 —— 整数反转 JAVA欢迎观看本博客题目详情 欢迎观看本博客   您好! 这是我第三次在 力扣(leetcode) 上练习算法。如有疏漏与不足之处还请多多指教。 题目详情   给出一个 32 位的有符号整数...
  • Java 整数反转

    2019-09-10 13:08:59
    我第一眼看到这个题目想到的是 整数反转整数反转的主要思路是有序取出每一个字符,然后倒序输出,我们这里也是这个思路。 通过取余的方式来倒序取出int的值 result = result* 10 + x%10; 2、溢出判断 Java的...
  • leetcode 7.整数反转 java

    2020-04-27 16:58:03
    7. 题目:整数反转 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 注意: 假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]...
  • 该题解采用JAVA字符串处理,先将整数转换为字符串,再用StringBuffer里的reverse反转字符串,最后把负号替换。循环除去反转后开头的0,使用Long转换字符串,再强制转换为int,判断未转换之前是否相等,如果不相等就...
  • 问:给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。 如果反转整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ,就返回 0。 假设环境不允许存储 64 位整数(有符号或无符号)。 例: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,189
精华内容 10,475
关键字:

整数的反转java

java 订阅