//数字转成字符串，reverse方法直接将字符串反转了。最后都是toString重写的，不然就是引用的地址了。
//负号也是可以通过这个方式直接转的。这里就用了long来作比较，有点不符合题意，没事。
class Solution {
    public int reverse(int x) { 
        
        StringBuilder sb = new StringBuilder();

        long a = Math.abs((long)x);
        String s = new StringBuilder(String.valueOf(a)).reverse().toString();
        if(x<0){
            sb.append('-');
        }
        String s1 = sb.append(s).toString();
        Long i = Long.parseLong(s1);
        if(i>2147483647 | i<-2147483648){
            return 0;
        }
        return Integer.parseInt(s1);
    }
}

 

class Solution {
    public int reverse(int x) {
        int res = 0;
        while(x != 0) {
            int temp = x % 10;
            //为什么要这么判断呢，因为题目中的假设环境不允许存储64位整数，所以没法存储比2147483647最大数字了，
            //必须在倒数第二次循环的时候存储好。
            //判断是否 大于 最大32位整数
            if (res>214748364 || (res==214748364 && temp>7)) {
                return 0;
            }
            //判断是否 小于 最小32位整数
            if (res<-214748364 || (res==-214748364 && temp<-8)) {
                return 0;
            }
            res = res * 10  + temp;
            x = x / 10;
             
        }
        return res;
    }
}

class Solution {
    public int myAtoi(String s) {
        //用的i的时候就不能用for了
        int i = 0;
        while (i < s.length() && s.charAt(i) == ' '){
            i++;
        }
        int start = i;
        int sign = 1;
        int res = 0;
        for(;i < s.length(); i++){
            //不考虑连续出现两个+的情况了,为啥这么笨呢，让第一次的位置特殊不就行了，真是无语了
            if (i == start && s.charAt(i) == '+'){
                sign = 1;
            } else if (i == start && s.charAt(i) == '-'){
                sign = -1;
            }
            //判断字符串是否是数字
            else if (Character.isDigit(s.charAt(i))){
                //因为是ASCII编码，减出来就是数值了。
                 int num = s.charAt(i) - '0';
                 if(res > Integer.MAX_VALUE/10 || (res == Integer.MAX_VALUE/10&&num>Integer.  
                        MAX_VALUE%10)){
                    return Integer.MAX_VALUE;
                }
                if(res < Integer.MIN_VALUE/10 || (res == Integer.MIN_VALUE/10&&-num<Integer.     
                         MIN_VALUE%10)){
                    return Integer.MIN_VALUE;
                }
                res = res * 10  + num * sign;
            } else{
                break;
            }
        }
        return res;
    }
}

//转换成数字的反转，让反转后的数字和x相等

class Solution {
    public boolean isPalindrome(int x) {
        int res = 0;
        if (x >= 0){
            //最后用到x，先赋值给一个临时变量
            int temp = x;
            while (temp != 0) {
            int num = temp % 10;
            res = res * 10 + num;
            temp = temp / 10;
            }
            if (res == x){
                return true;
            }
        }
        return false;
    }
}

//

class Solution {
    public boolean isPalindrome(int x) {
        // 特殊情况：
        // 如上所述，当 x < 0 时，x 不是回文数。
        // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
        // 则其第一位数字也应该是 0
        // 只有 0 满足这一属性
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int revertedNumber = 0;
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }

        // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
        // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
        // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
        return x == revertedNumber || x == revertedNumber / 10;
    }
}

 

 

class Solution {
    public int maxArea(int[] height) {
        int low = 0;
        //字符串是带括号，数组是不带括号，集合是size()
        int high = height.length - 1;
        int res = 0;
        int area = 0;
        while (low < high) {
            //为什么老是写int[]啊，写数组名字[]啊
            area = Math.min(height[low],height[high]) * (high - low);
            //要做到这一次的值要和上一次的值作比较取最小
            res = Math.max(area, res);
            if (height[low] < height[high]) {
                low++;
            } else {
                high--;
            }
        }    
        return res;    
    }
}

 

//substring() 方法返回的子串包括 start 处的字符，但不包括 stop 处的字符。
//substr() 方法返回的子串从 start 处的字符开始（包括）往后截取length长度，如果超过最末端就到最末端结束。
class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int length1 = strs[0].length();
        int length2 = strs.length;
        for (int i = 0; i < length1; i++) {
            char c = strs[0].charAt(i);
            for (int j = 1; j < length2; j++) {
                //char类型可以直接等于运算

                //顺序错了不行，短路或顺带先判断了数据超界问题。
                //if (c != strs[j].charAt(i) || i == strs[j].length()){  
                if ( i == strs[j].length() || c != strs[j].charAt(i)){  
                //if (i == strs[j].length() || strs[j].charAt(i) != c) {
                  return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    }
}