精华内容
下载资源
问答
  • 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整数反转

    2020-09-24 13:47:31
    /*给出一个 32 位的有符号整数,将这个整数中每位上的数字进行反转。若溢出返回0 * */ public class Day_04 { public int reverse(int x) { long result = 0; while(x != 0){ result = result*10+x%10; x /= ...
    package week_01;
    /*给出一个 32 位的有符号整数,将这个整数中每位上的数字进行反转。若溢出返回0
    * */
    public class Day_04 {
        public int reverse(int x) {
    
                long result = 0;
    
                while(x != 0){
                    result = result*10+x%10;
                    x  /= 10;
                }
                //强转之后溢出则返回0
                return (int)result == result? (int)result:0;
        }
    
        public static void main(String[] args) {
            System.out.println(new Day_04().reverse(-123));
        }
    }
    
    
    展开全文
  • Java 整数反转

    2020-06-05 14:23:06
    public class Test { public static void main(String[] args) { System.out.println... * rev是循环使用的,每循环一次最后一位就乘以10,并在改数后面拼接上前一位,以此来实现反转。 * 例如:输入为321, ..
    
    
    public class Test {
    
        public static void main(String[] args) {
            System.out.println(reverse(Integer.MAX_VALUE));
            System.out.println(reverse(120));
        }
    
        /**
         * rev是循环使用的,每循环一次最后一位就乘以10,并在改数后面拼接上前一位,以此来实现反转。
         * 例如:输入为321,
         * 第一次循环 rev =0, 321的余数pop=1, x除以10后等于32.1,但因为是整型所以自动舍去后面的小数,x=32, rev = 0*10 + 1 = 1
         * 第二次循环 rev =1,x=32的余数pop=2,x除以10后等于3.2,但因为是整型所以自动舍去后面的小数,x=3, rev = 1*10 + 2 = 12
         * 第三次循环 rev =12,x=3的余数pop=3,x除以10后等于0.3,但因为是整型所以自动舍去后面的小数,x=0, rev = 12*10 + 3 = 123
         * @param x
         * @return
         */
        public static int reverse(int x) {
            int rev = 0;
            while (x != 0) {
                int pop = x % 10;
                // 以下等于 x = x/10;
                x /= 10;
                // 大于等于Integer的正整数的最大值返回0
                if (rev > Integer.MAX_VALUE / 10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) {
                    return 0;
                }
                // 小于等于Integer的负整数的最大值返回0
                if (rev < Integer.MIN_VALUE / 10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) {
                    return 0;
                }
                rev = rev * 10 + pop;
            }
            return rev;
        }	
    }
    
    展开全文
  • java整数反转两种方式

    2020-07-17 09:31:26
    标题:java整数反转两种方式 一、题目 二、题解 方法一: * sum使用了double,sum=sum*10+b; //避免sum溢出 * -2147483648, * -2147483647,和2147483647只是符号不同 public int reverse02(int x) { boolean ...

    标题:java整数反转两种方式

    一、题目
    在这里插入图片描述二、题解
    方法一:
    * sum使用了double,sum=sum*10+b; //避免sum溢出
    * -2147483648,
    * -2147483647,和2147483647只是符号不同

    	public int reverse02(int x) {
        	boolean flag=false;
        	double sum=0;  //防止后面sum*10+b溢出
        	int b=0;
        	
        	if(x==-2147483648) {
        		return 0;
        	}
        	
        	if(x<0) {
        		flag=true;
        		x=-x;
        	}
        	
        	while(x>0) {
        		b=x%10;
        		x=x/10;
        		sum=sum*10+b;  //sum*10可能溢出
        		if(sum>Integer.MAX_VALUE) {
            		return 0;
            	}
        	}
        	//负数
        	if(flag) {
        		sum=-sum;
        	}
        	
        	return (int)sum;
    

    方法二:
    * sum使用了int
    * 不用sum*10+b>Integer.max_value 是因为前面的会溢出
    * 不用sum>(Integer.max_value-b)/10 是因为若b为负数就会溢出,
    * 同理sum<(Integer.min_value-b)/10 b为正数就会溢出
    【一种思维的体现】

    	public int reverse03(int x) {
        	int sum=0;  //防止后面sum*10+b溢出
        	int b=0;
        	
        	while(x!=0) {
        		b=x%10;
        		x=x/10;
        		if(sum>Integer.MAX_VALUE/10 || (sum==Integer.MAX_VALUE && b>7)) {
        			return 0;
        		}else if(sum<Integer.MIN_VALUE/10 || (sum==Integer.MIN_VALUE && b<-8)) {
        			return 0;
        		}
        		
        		sum=sum*10+b;  //sum可能溢出
        	}
        	
        	return sum;
    

    完整代码如下:

    package com.hhh.aa.basicNum;
    
    import org.junit.Test;
    
    /**
     * 将数字反转
     * @author dell
     *
     */
    public class TestConverInteger {
    	@Test
    	public void test0() {
    		int m=2147483647;
    		int sum=m*10;
    		System.out.println("m:"+m);
    		System.out.println("sum:"+sum);//因为溢出了,正数溢出-->负数
    		
    		int m2=-2147483648;
    		int sum2=m2*10;
    		System.out.println("m2:"+m2);
    		System.out.println("sum2:"+sum2);//负数溢出-->0
    		
    		int m3=-1;
    		m3=-m3;
    		System.out.println("m3:"+m3);
    		
    		System.out.println("-12/10:"+(-12/10));
    		System.out.println("-12%10:"+(-12%10));
    	}
    
    	
    	/**
    	 * sum使用了double
    	 * -2147483648,
    	 * -2147483647,和2147483647只是符号不同
    	 * @param x
    	 * @return
    	 */
    	public int reverse02(int x) {
        	boolean flag=false;
        	double sum=0;  //防止后面sum*10+b溢出
        	int b=0;
        	
        	if(x==-2147483648) {
        		return 0;
        	}
        	
        	if(x<0) {
        		flag=true;
        		x=-x;
        	}
        	
        	while(x>0) {
        		b=x%10;
        		x=x/10;
        		sum=sum*10+b;  //sum*10可能溢出
        		if(sum>Integer.MAX_VALUE) {
            		return 0;
            	}
        	}
        	//负数
        	if(flag) {
        		sum=-sum;
        	}
        	
        	return (int)sum;
        }
    	@Test
    	public void test02() {
    //		int m=2147483647;
    //		int m=-2147483648;
    		int m=1534236469;
    		
    		int reverse = this.reverse02(m);
    		System.out.println("reverse:"+reverse);
    		
    //		int h=964632430;
    //		int hh=h*10;
    //		System.out.println(hh);//problem溢出后,的数是怎么变的
    	}
    	
    	/**
    	 * sum使用了int
    	 * 不用sum*10+b>Integer.max_value 是因为前面的会溢出
    	 * 不用sum>(Integer.max_value-b)/10 是因为若b为负数就会溢出,
    	 * 同理sum<(Integer.min_value-b)/10 b为正数就会溢出
    	 * @param x
    	 * @return
    	 */
    	public int reverse03(int x) {
        	int sum=0;  //防止后面sum*10+b溢出
        	int b=0;
        	
        	while(x!=0) {
        		b=x%10;
        		x=x/10;
        		if(sum>Integer.MAX_VALUE/10 || (sum==Integer.MAX_VALUE && b>7)) {
        			return 0;
        		}else if(sum<Integer.MIN_VALUE/10 || (sum==Integer.MIN_VALUE && b<-8)) {
        			return 0;
        		}
        		
        		sum=sum*10+b;  //sum可能溢出
        	}
        	
        	return sum;
        }
    	@Test
    	public void test03() {
    		int m=123;
    		
    		int reverse = this.reverse03(m);
    		System.out.println("reverse:"+reverse);
    	}
    }
    
    
    展开全文
  • 整数反转 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 java实现,非算法实现 package hello; ...
  • 问题: 示例 1: 输入: 123 输出: 321 ...请根据这个假设,如果反转整数溢出那么就返回 0。 问题说明 问题的难度适中,主要考虑数学思维,已经计算机中对于边界的处理技巧。这里有个非常有趣的问题...
  • 1.整数反转 120-&gt;21 ,-123-&gt;-321,会出现溢出的情况。 思路:得到一个数的绝对值,取这个数的最后一位放在新数的第一位;将新数扩大10倍,将该数值从个位变为十位,个位数为传过来的数的倒数第二位...
  • public class IntegerReverse { public static void main(String[] args) { int target = 762142; System.out.println("Original number is : " + target); String str = Integer.toString(target);...
  • 一、将 int 整数通过 String 转换,溢出捕获class Solution {public int reverse(int x) {long nums = 0;int temp = 1;try {temp = x / Math.abs(x);StringBuilder num = new StringBuilder();num.append(Math.abs(x...
  • java实现整数反转的两种方式发布时间:2020-05-19 15:59:17来源:亿速云阅读:1079作者:小新今天小编给大家分享的是java实现整数反转的两种方式,相信很多人都不太了解,为了让大家更加了解,所以给大家总结了以下...
  • 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转整数溢出那么就返回 0。 ...
  • 一、将 int 整数通过 String 转换,溢出捕获class Solution {public int reverse(int x) {long nums = 0;int temp = 1;try {temp = x / Math.abs(x);StringBuilder num = new StringBuilder();num.append(Math.abs(x...
  • 题目:给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。示例1:输入: 123输出: 321示例 2:输入: -123输出: -321注意:假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为[−2^31, 2...
  • 要在Java反转整数,请尝试以下代码-示例importjava.lang.*;publicclassDemo{publicstaticvoidmain(String[]args){inti=239,rev=0;System.out.println("Original:"+i);while(i!=0){intdigit=i%10;rev=re...
  • 第7题:整数反转给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。示例 1:输入: 123输出: 321示例 2:输入: -123输出: -321示例 3:输入: 120输出: 21V1版本V1版本简单暴力,将整数反转到list中...
  • 题目描述给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。备注注意:假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 $[−2^{31}, 2^{31} − 1]$。请根据这个假设,如果反转后...
  • Java实现 整数反转

    2020-07-29 04:39:24
    整数反转 原题地址: https://leetcode-cn.com/problems/reverse-integer/ 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 ...
  • 7.整数反转java版,每日一题系列(此题来自力扣网)给出一个31位的有符号整数,你需要将这个整数中每位上数字进行反转。示例1:输入: 123输出: 321示例2:输入: -123输出: -321示例3:输入: 120输出: 21方法:弹出和推...
  • Java刷题整数反转

    2020-06-23 19:19:31
    整数反转 题目: 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 思路: 例如:x=123 设结果为res...
  • 使用Java实现整数反转

    2021-04-02 09:48:41
    使用Java实现整数反转 public static void main(String[] args) { while(true) { System.out.println("请输入一个数:"); Scanner sc = new Scanner(System.in); int x = sc.nextInt(); if (x == 0) { ...
  • java实现整数反转

    2020-07-29 20:39:56
    给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。...分析:拿1543举例,因为实现整数反转,所以最后要输出3451,因为这是一道算法题,所以我们要从数学的角度出发,1543分别对10取余
  • 模十取余参数不断模10取得最低位,相反数不断乘10相加,(通过参数除10不断刷新最低位)得到最终相反数的反转结果/*整数反转*/class Test2 {public static void main(String[] args) {int num = reverseInt(123);...
  • Java程序反转数字在此程序中,您将学习在Java中使用while循环和for循环来反转数字。示例:在Java中使用while循环反转数字publicclassReverseNumber{publicstaticvoidmain(String[]args){intnum=1234,reversed=0;...
  • LeetCode_007_整数反转题目描述给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。示例 1:输入: 123输出: 321示例 2:输入: -123输出: -321示例 3:输入: 120输出: 21注意:假设我们的环境只能存储...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 812
精华内容 324
关键字:

java整数反转

java 订阅