精华内容
下载资源
问答
  • 要在Java反转整数,请尝试以下代码-示例importjava.lang.*;publicclassDemo{publicstaticvoidmain(String[]args){inti=239,rev=0;System.out.println("Original:"+i);while(i!=0){intdigit=i%10;rev=re...

    要在Java中反转整数,请尝试以下代码-

    示例import java.lang.*;

    public class Demo {

    public static void main(String[] args) {

    int i = 239, rev = 0;

    System.out.println("Original: " + i);

    while(i != 0) {

    int digit = i % 10;

    rev = rev * 10 + digit;

    i /= 10;

    }

    System.out.println("Reversed: " + rev);

    }

    }

    输出结果Original: 239

    Reversed: 932

    在上面的程序中,我们有以下int值,我们将其反转。int i = 239;

    现在,循环遍历,直到该值为0。找到余数并执行以下操作以获得与给定整数239相反的值。while(i != 0) {

    int digit = i % 10;

    rev = rev * 10 + digit;

    i /= 10;

    }

    展开全文
  • LeetCode_007_整数反转题目描述给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。示例 1:输入: 123输出: 321示例 2:输入: -123输出: -321示例 3:输入: 120输出: 21注意:假设我们环境只能存储...

    LeetCode_007_整数反转

    题目描述

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

    示例 1:

    输入: 123

    输出: 321

    示例 2:

    输入: -123

    输出: -321

    示例 3:

    输入: 120

    输出: 21

    注意:

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

    来源:力扣(LeetCode)

    链接:https://leetcode-cn.com/problems/reverse-integer

    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

    总体分析

    题目中要求将一个有符号整数进行反转,通过题目给出的例子,需要注意以下几点:

    整数会有负数的情况,反转后符号不变。

    只能存储 32 位有符号整数,取值范围为:-2147483648 ~ 2147483647。超过此范围即为溢出。如果反转后发生了溢出情况,返回 0。

    要反转的数字最后一位是 0 的情况反转过来后要将 0 舍弃。

    如题目中的这个例子:120 --> 21。

    解决方案

    思路分析:

    首先,先分析溢出问题,对于题目中要求的 32 位有符号整数,其实也就是 int 类型,相对应的取值范围为:-2147483648 ~ 2147483647。那么发生溢出的情况就是反转过来的数不在这个范围内。

    举个例子:将 2111222239 反转过来后为 9322221112,此时这个数超过了上面的范围,这个情况就是溢出,此时返回 0 即可。

    接着,分析转换的数是负数时的情况:如果要转换的数是负数,就先取其绝对值将其反转后再将结果转换为负数返回即可。

    综上,可以设计解题流程如下,假设要转换的数为 x:

    首先判断 x 是否为 -2147483648,如果是返回 0,防止取 x 绝对值 -x 时报错。

    判断 x 是否为负数,如果是负数则先取其绝对值然后递归取反,最后将结果转换为负数。

    使用一个变量 result 保存结果,初始时为 0。

    对 x 取反时将 x % 10 依次取出最后一位数(例如: 256 % 10 = 6)放置到 result 中(即 result * 10 + x % 10),最后将 x / 10。依次进行此过程即可将 x 反转。

    在取反过程中需要注意的是要进行该判断:if (result > 214748364) 进行提前判断溢出处理。

    举个例子说明:

    1463847412 反转后为 2147483641,此时当反转到 214748364 时,还没有大于,所以没有溢出。如果 result > 214748364 说明反转后就已经溢出了。

    例如:1563847412 -> 2147483651,当反转到 214748365 时,由于大于了 214748364,所以可以提前判断溢出。

    判断 result 是否溢出,如果溢出返回 0,否则返回反转后的结果,这里判断溢出是因为前面的提前判断溢出不能判断到最后一位,如果最后一位加的数超过溢出值的话就会产生溢出,所以需要判断。不好理解的话可以结合下面代码进行理解。

    根据以上思路,可设计题解代码如下:

    /**

    * 整数反转解题方案

    *

    * @author 踏雪彡寻梅

    * @date 2020/2/6 - 12:14

    */

    class Solution {

    public int reverse(int x) {

    if (x == -2147483648) {

    // 做此判断防止取 x 绝对值时 x = -x 报错

    return 0;

    }

    if (x < 0) {

    // 如果为负数,取其绝对值调用自己然后将结果转为负数

    return -reverse(-x);

    }

    // 用于保存结果返回

    int result = 0;

    // 取反操作

    while (x != 0) {

    if (result > 214748364) {

    // 处理溢出

    // 举例:1463847412

    // 反转后:2147483641

    // 此时当反转到 214748364 时,还没有大于,所以没有溢出

    // 如果 result > 214748364 反转后就已经溢出了

    // 例如:1563847412 -> 2147483651

    // 当反转到 214748365 时,由于大于了 214748364,所以可以提前判断溢出

    return 0;

    }

    // 接收取反结果

    result = result * 10 + x % 10;

    x /= 10;

    }

    // 如果溢出就返回 0

    // 防止提前判断溢出不能判断到最后一位的情况,如果最后一位加的数超过溢出值的话就会产生溢出

    return result <= 2147483647 ? result : 0;

    }

    }

    提交结果:

    456205a0a151e67017e0ffd8f662d212.png

    提交后时间上和空间上的结果还是效果蛮好的O(∩_∩)O。接下来进行一些简单的时间复杂度和空间复杂度分析。

    时间复杂度简单分析:

    对于时间复杂度则是分析 while 循环中的代码,因为这块代码占据了程序的时间是最多的。

    while (x != 0) {

    if (result > 214748364) {

    return 0;

    }

    result = result * 10 + x % 10;

    x /= 10;

    }

    从以上代码可以看出,x 每循环一次就除以 10,直到 x = 0 时或者 result 溢出时才结束循环。这里假设 result 不溢出的情况来进行分析:

    对于 x / 10 判断 x 是否等于 0 其实可以看为:x 除了几次 10 才等于 0。这里假设这个次数为 n。

    用式子表达也就是:x / 10 / 10 / 10 / ... / 10 = x / 10n = 0,即可以表示为 x = 10n

    也就是说明,程序的运行时间主要跟 n 相关,所以需要将 n 计算出来:

    通过 x = 10n 求解 n 这个问题在高中时就已经学过了,即 n = log10x。

    所以,时间复杂度为 O(log10x) = O(lgx)。

    空间复杂度简单分析:

    空间上使用了一个 result 整型变量用来辅助接收结果,每次赋值分配的空间都是常数级别的,所以空间复杂度为 O(1)。

    小结

    解题时需要注意特殊情况:为负数的情况、尾部为 0 的情况以及整数溢出的情况。

    如有写的不足的,请见谅,请大家多多指教。

    展开全文
  • 题目描述(题目难度,简单)给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。示例 1:输入: 123输出: 321示例 2:输入: -123输出: -321示例 3:输入: 120输出: 21注意:假设我们环境只能存储得下 ...

    题目描述(题目难度,简单)

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

    示例 1:

    输入: 123

    输出: 321

    示例 2:

    输入: -123

    输出: -321

    示例 3:

    输入: 120

    输出: 21

    注意:

    假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为

    math?formula=%5B%E2%88%922%5E%7B31%7D%2C%202%5E%7B31%7D%20%E2%88%92%201%5D。请根据这个假设,如果反转后整数溢出那么就返回 0。

    示例代码

    class Solution {

    public int reverse(int x) {

    long y = x;

    long res = 0;

    do{

    res = 10*res + y % 10;

    }while((y /= 10) != 0);

    if(res < Integer.MIN_VALUE || res > Integer.MAX_VALUE){

    return 0;

    }

    return (int)res;

    }

    }

    思路解析

    这个题的题目难度虽然被划为简单,但是这一题提交的正确率却是前 7 题里最低的。

    7040957f3f9f

    image.png

    所以我们不能小看它,这个题我原来在一次机试考试中也遇到过,也顺利的解决了。所以最开始我也看轻了这道题,提交好几次都没通过。问题就出在这个题加了可能溢出这个条件,开始我还想有没有比较巧妙的办法,提前判断反转后会不会溢出,想了几个方法,但提交发现都有漏洞。最后突然想到,这个溢出这么难判断的原因就是使用 int 去存反转后的结果,如果溢出就会把溢出部分的数据位丢掉,导致结果不正确。那我们用一个更长的数据类型(long)去存反转后的结果不就行了,这样肯定不会存在有丢掉数据位的情况。最后直接把反转后的结果与 int 类型的上下限比较即可判断是否溢出。

    感觉这是最简洁的办法了,也好记。以后面试遇到就这样回答了(^0^)。

    帮大家回忆一下 Java 基本数据类型的长度:

    类型

    长度(字节)

    byte

    1

    short

    2

    int

    4

    long

    8

    float

    4

    double

    8

    char

    2

    还有一点需要注意的就是,Java 数值类型中没有无符号类型

    下面也贴出 leetcode 官方给的题解吧,应该算是标准的正解,但饶了点弯,不如上面的代码简洁好记,给大家对比一下,同时给大家多一个思路。

    leetcode 官方题解(内容原样复制)

    方法:弹出和推入数字 & 溢出前进行检查

    思路

    我们可以一次构建反转整数的一位数字。在这样做的时候,我们可以预先检查向原整数附加另一位数字是否会导致溢出。

    算法

    反转整数的方法可以与反转字符串进行类比。

    我们想重复“弹出”

    math?formula=x 的最后一位数字,并将它“推入”到

    math?formula=%5Ctext%7Brev%7D 的后面。最后,

    math?formula=%5Ctext%7Brev%7D 将与

    math?formula=x 相反。

    要在没有辅助堆栈 / 数组的帮助下 “弹出” 和 “推入” 数字,我们可以使用数学方法。

    //pop operation:

    pop = x % 10;

    x /= 10;

    //push operation:

    temp = rev * 10 + pop;

    rev = temp;

    但是,这种方法很危险,因为当

    math?formula=%5Ctext%7Btemp%7D%20%3D%20%5Ctext%7Brev%7D%20%5Ccdot%2010%20%2B%20%5Ctext%7Bpop%7D 时会导致溢出。

    幸运的是,事先检查这个语句是否会导致溢出很容易。

    为了便于解释,我们假设

    math?formula=%5Ctext%7Brev%7D 是正数。

    如果

    math?formula=temp%20%3D%20%5Ctext%7Brev%7D%20%5Ccdot%2010%20%2B%20%5Ctext%7Bpop%7D 导致溢出,那么一定有

    math?formula=%5Ctext%7Brev%7D%20%5Cgeq%20%5Cfrac%7BINTMAX%7D%7B10%7D

    如果

    math?formula=%5Ctext%7Brev%7D%20%3E%20%5Cfrac%7BINTMAX%7D%7B10%7D,那么

    math?formula=temp%20%3D%20%5Ctext%7Brev%7D%20%5Ccdot%2010%20%2B%20%5Ctext%7Bpop%7D 一定会溢出。

    如果

    math?formula=%5Ctext%7Brev%7D%20%3D%3D%20%5Cfrac%7BINTMAX%7D%7B10%7D,那么只要

    math?formula=%5Ctext%7Bpop%7D%20%3E%207

    math?formula=temp%20%3D%20%5Ctext%7Brev%7D%20%5Ccdot%2010%20%2B%20%5Ctext%7Bpop%7D就会溢出。

    math?formula=%5Ctext%7Brev%7D 为负时可以应用类似的逻辑。

    class Solution {

    public int reverse(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;

    }

    }

    怎么样,对比后,是不是发现还是第一种方法更简单更好理解一点呢(嘻嘻)。

    补充两点知识点*(也挺重要)

    一、取余运算和取模运算的异同

    这个题目最开始,我还是分正负数来考虑的,因为我印象里记得 %

    对正数和负数的运算好像有区别。最后去查了一下,补充在这里。

    C/C++ 和 Java 一样,% 是取余运算;而 Python 的 % 是取模运算。

    取余运算和取模运算的区别:

    对于整型数

    math?formula=a%EF%BC%8Cb 来说,取余运算或者取模运算的方法都是下面两步:

    求整数商:

    math?formula=c%20%3D%20a%2Fb

    计算余数或者模:

    math?formula=r%20%3D%20a%20-%20c%5Ccdot%20b

    而两者的区别就在于第一步不同:取余运算在取

    math?formula=c的值时,向

    math?formula=0 方向舍入,而取模运算在计算

    math?formula=c的值时,则是向负无穷方向舍入。

    例如计算:

    math?formula=-7%5C%254

    第一步:求整数商,取余运算算出的整数商为

    math?formula=c%3D%5Clceil%5Cfrac%7B-7%7D%7B4%7D%5Crceil%3D-1,而取模运算算出的整数商为

    math?formula=c%3D%5Clfloor%5Cfrac%7B-7%7D%7B4%7D%5Crfloor%3D-2

    第二步:计算余数和模的公式相同,但因

    math?formula=c的值不同,取余的结果为

    math?formula=-7-(-1%5Ctimes4)%3D-3,取模的结果为

    math?formula=-7-(-2%5Ctimes4)%3D1

    归纳:当

    math?formula=a

    math?formula=b符号一致时,取余运算和取模运算的结果一样。

    当符号不一致时,结果不一样。取余运算结果的符号和

    math?formula=a一致,取模运算结果的符号和

    math?formula=b一致。

    验证结果如下:

    对于 Java 来说,

    代码如下:

    public class Test {

    public static void main(String[] argus){

    System.out.println("-7 % 4 = "+(-7%4));

    System.out.println("7 % -4 = "+(7%-4));

    }

    }

    运行结果如下:

    7040957f3f9f

    image.png

    对于 Python 来说,

    7040957f3f9f

    image.png

    二、Java 位运算部分知识点

    在解这道题的时候,考虑过使用位运算简化代码。虽然最后没用上,但还是记在这吧,万一以后用的上呢。

    一、Java 移位运算

    <>为右移运算(左边补符号位),>>>为无符号右移运算(左边恒补 0),注意 Java 中没有<<

    二、Java 取绝对值的位运算实现

    int abs(int x){

    return (x+(x = x>>31))^x;//有点过于精炼,哈哈

    }

    分解一下代码,实际上是有两步,

    第一步,令 y = x >> 31

    第二步,返回结果 (x+y) ^ y

    代码解释如下:

    当 x 为正数时,y = 0,则 (x+0) ^ 0 还是 x。

    当 x 为负数时,x 右移 31位,左边补符号位 1 ,最终y = 0xFFFFFFFF,也即 y = -1。所以(x+y) ^ y = (x-1)^0xFFFFFFFF = ~(x-1) = -x,perfect!!!

    完结撒花

    展开全文
  • 7.整数反转java版,每日一题系列(此题来自力扣网)给出一个31位有符号整数,你需要将这个整数中每位上数字进行反转。示例1:输入: 123输出: 321示例2:输入: -123输出: -321示例3:输入: 120输出: 21方法:弹出和推...

    7.整数反转java版,每日一题系列(此题来自力扣网)

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

    示例1:

    输入: 123

    输出: 321

    示例2:

    输入: -123

    输出: -321

    示例3:

    输入: 120

    输出: 21

    方法:弹出和推入数字&溢出前进行检查

    思路

    我们可以一次构建翻转整数的一位数字。在这样做的时候,我们可以预先检查向原整数附加另一位数字是否导致溢出。

    算法:

    反转整数的方法可以与反转字符串进行类比。

    我们想重复"弹出"x的最后一位数字,并将它"推入"到rev的后面。最后,rev将于x相反。

    要在没有辅助堆栈/数组的帮助下"弹出"和"推入"数字,我们可以使用数学方法。

    //pop operation:

    pop = x % 10;

    x /= 10;

    //push operation:

    temp = rev * 10 + pop;

    rev = temp;

    但是,这种方法有溢出的风险。

    class solution {

    public int reverse(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;

    }

    }

    作者:leetcode链接:来源:力扣(leetcode)著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    来自:https://www.cnblogs.com/wjmmt/p/12858531.html

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • 整数反转JAVA

    2020-06-28 20:08:37
    给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们环境只能存储得下 32 位有符号...
  • 标签:sed--参考minus解法保留only要求whenHello 各位,这里是新治第二篇博客,今天要解这道题是LeetCode第七题,整数反转,先来读一下题:Given a 32-bit signed integer, reverse digits of an integer....
  • 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。示例 1:输入: 1234输出: 4321示例 2:输入: -1234输出: -4321示例 3:输入: 120输出: 21注意:假设我们环境只能存储得下 32 位有符号整数,...
  • leetcode 整数反转 java

    2020-02-26 11:01:28
    给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们环境只能存储得下 32 位有...
  • 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。示例 1:输入: 123输出: 321示例 2:输入: -123输出: -321示例 3:输入: 120输出: 21注意:假设我们环境只能存储得下 32 位有符号整数,则其...
  • java实现整数反转的两种方式发布时间:2020-05-19 15:59:17来源:亿速云阅读:1079作者:小新今天小编给大家分享java实现整数反转的两种方式,相信很多人都不太了解,为了让大家更加了解,所以给大家总结了以下...
  • 整数反转Java

    2020-06-03 09:43:19
    整数反转 package leetCoder; import org.omg.PortableInterceptor.INACTIVE; /** * @author : zhaoliang ... //给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 public
  • 模十取余参数不断模10取得最低位,相反数不断乘10相加,(通过参数除10不断刷新最低位)得到最终相反数的反转结果/*整数反转*/class Test2 {public static void main(String[] args) {int num = reverseInt(123);...
  • 今天我们继续力扣之旅,还是从简单题目下手,整数反转与回文数整数反转题目描述:给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。示例 1:输入: 123输出: 321示例 2:输入: -123输出: -321...
  • 整数反转 java 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们环境只能存储...
  • 第7题:整数反转给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。示例 1:输入: 123输出: 321示例 2:输入: -123输出: -321示例 3:输入: 120输出: 21V1版本V1版本简单暴力,将整数反转到list中...
  • 整数反转java

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

    2020-04-03 11:10:05
    给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们环境只能存储得下 32 ...
  • leetcode 7.整数反转 Java

    2021-01-01 19:38:25
    给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 注意: 假设我们环境只能存储得下 32 位有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果 反转整数溢出那么就...
  • leetcode 7.整数反转 java

    2020-04-27 16:58:03
    给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 注意: 假设我们环境只能存储得下 32 位有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,...
  • 整数反转(简单)宫水三叶发布于 今天 12:10题目描述给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。注意:假设我们环境只能存储得下 32 位有符号整数,则其数值范围为 [$−2^{31}$, $2^{...
  • 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们环境只能存储得下 32 位有符号...
  • 思路:运用整数/10和整数%10把入参整数分解进行反转,因为题目要求不能对于超出整数范围反转数要进行归零,所以使用long来做结果,再进行强制转换。 /** * 整数反转 * @param x 待反转的整数 * @return 反转后...
  • 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。假设我们环境只能存储得下 32 位有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转整数溢出那么就返回 0。 ...
  • 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。Given a 32-bit signed integer, reverse digits of an integer.示例1:输入:123输出: 321示例 2:输入: -123输出: -321示例 3:输入: 120输出: ...
  • 力扣 整数反转(Java)

    2019-12-09 16:06:47
    给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们环境只能存储得下 32 位有符号...
  • 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例 1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意: 假设我们环境只能存储得下 32 位有...
  • leetcode初级算法 —— 整数反转 JAVA欢迎观看本博客题目详情 欢迎观看本博客   您好! 这是我第三次在 力扣(leetcode) 上练习算法。如有疏漏与不足之处还请多多指教。 题目详情   给出一个 32 位有符号整数...
  • 题目描述给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。备注注意:假设我们环境只能存储得下 32 位有符号整数,则其数值范围为 $[−2^{31}, 2^{31} − 1]$。请根据这个假设,如果反转后...
  • LeetCode 7:整数反转java) 给出一个 32 位有符号整数,你需要将这个整数中每位上数字进行反转。 示例1: 输入: 123 输出: 321 示例 2: 输入: -123 输出: -321 示例 3: 输入: 120 输出: 21 注意...

空空如也

空空如也

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

整数的反转java

java 订阅