Reverse digits of an integer.
Example1: x = 123, return 321
Example2: x = -123, return -321
The input is assumed to be a 32-bit signed integer. Your function should return 0 when the reversed integer overflows.

反序輸出整形，當數(shù)太大的時候要溢出返回0

My View

我想到的是很簡單的反序，出于java優(yōu)越的語言條件，寫了一個調(diào)庫的算法（調(diào)庫就沒意思了，所以就是寫著玩玩）

class Solution {
    public int reverse(int x) { 
         try{
             int a = Integer.parseInt(new StringBuffer(String.valueOf(Math.abs(x))).reverse().toString());     
             if(x<0){
                 return a*-1;   
             }else{
                 return a;
             }   
         }catch(NumberFormatException e){
             return 0;
         }
    }
}

一層套一層……可讀性就很差了，主要是把傳進來的int值轉(zhuǎn)換為絕對值，然后轉(zhuǎn)換為字符串，通過StringBuffer構(gòu)造，經(jīng)過reverse函數(shù)反序，最后toString返回字符串，最后的最后，強轉(zhuǎn)為整形。

在這里判斷是否溢出用的是try catch，當數(shù)字溢出沒法轉(zhuǎn)換為整形的時候，就會拋出異常，然后在catch中捕獲就ok了。

當然效率不是很高，打敗了34%的用戶。

同樣，我們可以不借助API的reverse方法，來自己實現(xiàn)一個。

  public int reverse(int x) {
        try{
             int a = Integer.parseInt(reverse_my(String.valueOf(Math.abs(x))));
             if(x<0){
               return a*-1;   
             }
               return a;
         }catch(NumberFormatException e){
             return 0;
       }
    }
    
    public String reverse_my(String a){
        StringBuffer sb = new StringBuffer();
        for (int i = a.length() - 1; i >= 0; i--) {
            sb.append(a.charAt(i));
        }
        return sb.toString();
    }

效果是一樣的哈，也是打敗了34%的用戶。

Solution

題目太簡單……官方都沒給優(yōu)秀的方案，于是去社區(qū)看大神的方案。

一個七行的代碼。

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

主要通過算術(shù)運算來達到反序的效果。

public int reverse(int x)
{
    int result = 0;

    while (x != 0)
    {
        int tail = x % 10;
        int newResult = result * 10 + tail;
        if ((newResult - tail) / 10 != result)
        { return 0; }
        result = newResult;
        x = x / 10;
    }

    return result;
}

這個也是如此，但是樓主的解決溢出方面和獨特，利用溢出之后數(shù)值變化來辨別，

If overflow exists, the new result will not equal previous one.
No flags needed. No hard code like 0xf7777777 needed.

當整形（-xxxx - xxxx）溢出之后可能進入起始點或者終止點,那么此時返回去計算上一個值肯定是得不到原結(jié)果，那么這時候就認為是溢出。

這個方法確實很好，但是我還是喜歡顯而易見的，比如第一種方法。