每日练习（12.07）

 

题一：整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。


示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0

package com.yang;

import java.util.ArrayList;
import java.util.Comparator;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: com.yang
 * @Author: yzh
 * @CreateTime: 2023-12-01
 */

/*
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。


示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0
 */
public class MyDemo {
    public static void main(String[] args) {
        String revStr = new StringBuilder("-123").reverse().toString();
        System.out.println(reverse(-123));
        System.out.println(reverse3(-123));
    }
    //解法一
    public static int reverse(int x) {
        //取x的绝对值 再转为字符串
        String str = Integer.toString(Math.abs(x));
        //用StringBuilder反转字符串
        String revStr = new StringBuilder(str).reverse().toString();

        try {
            //字符串转换回整数
            int rev = Integer.parseInt(revStr);
            //根据原始整数的符号返回结果
            return (x < 0) ? -rev : rev;
        } catch (NumberFormatException e) {
            return 0;
        }
    }
    //解二
    public static int reverse3(int x) {
        int result = 0;
        while (x != 0) {
            // 获取输入数字的最后一位数字
            int temp = x % 10;
            // 判断是否大于最大32位整数
            if (result > 214748364 || (result == 214748364 && temp > 7)) {
                return 0;
            }

            // 判断是否小于最小32位整数
            if (result < -214748364 || (result == -214748364 && temp < -8)) {
                return 0;
            }
            // 将当前得到的数字加入到结果中
            result = result * 10 + temp;
            // 去掉输入数字的最后一位，继续循环
            x = x / 10;
        }
        return result;
    }


}

题二： 回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。


示例 1：

输入：x = 121
输出：true
示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。

package com.yang;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: com.yang
 * @Author: yzh
 * @CreateTime: 2023-12-01
 */

/**
 * @BelongsProject: untitled
 * @BelongsPackage: com.yang
 * @Author: yzh
 * @CreateTime: 2023-11-28
 */
/*
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。


示例 1：

输入：x = 121
输出：true
示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。

*/
public class MyTest {

    public static void main(String[] args) {

        System.out.println(isPalindrome2(1210));
    }

    //双指针判断
    public static boolean isPalindrome(int x) {
        String s = String.valueOf(x);
        char[] chars = s.toCharArray();
        int left =0;
        int right =chars.length-1;
        while (left<=right){
            if (chars[left] != chars[right]){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

    //字符串反转
    public static boolean isPalindrome2(int x) {
        String s = String.valueOf(x);
        StringBuilder sb = new StringBuilder(s).reverse();
        return s.equals(sb.toString());
    }
}

题三：盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49

示例 2：

输入：height = [1,1]
输出：1

package com.yang;

/**
 * @BelongsProject: untitled
 * @BelongsPackage: com.yang
 * @Author: yzh
 * @CreateTime: 2023-12-07
 */

/**
 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

 返回容器可以储存的最大水量。

 说明：你不能倾斜容器。

 示例 1：
 输入：[1,8,6,2,5,4,8,3,7]
 输出：49

 示例 2：

 输入：height = [1,1]
 输出：1
 */
public class Exercise {
    public static void main(String[] args) {

    }

    //双指针往中间夹逼 先将两个指针固定在数组两端，计算当前面积，将高度较小的一端向中间移动。重复上述过程，直到两个指针相遇
    public int maxArea(int[] height) {
        // 左指针
        int left =0;
        // 右指针
        int right =height.length-1;
        // 最大面积
        int maxArea =0;
        //双指针往中间夹逼
        while (left