Java实现 LeetCode第30场双周赛 （题号5177，5445，5446，5447）

这套题不算难，但是因为是昨天晚上太晚了，好久没有大晚上写过代码了，有点不适应，今天上午一看还是挺简单的

5177. 转变日期格式

给你一个字符串 date ，它的格式为 Day Month Year ，其中：

Day 是集合 {“1st”, “2nd”, “3rd”, “4th”, …, “30th”, “31st”} 中的一个元素。
Month 是集合 {“Jan”, “Feb”, “Mar”, “Apr”, “May”, “Jun”, “Jul”, “Aug”, “Sep”, “Oct”, “Nov”, “Dec”} 中的一个元素。
Year 的范围在 ​[1900, 2100] 之间。
请你将字符串转变为 YYYY-MM-DD 的格式，其中：

YYYY 表示 4 位的年份。
MM 表示 2 位的月份。
DD 表示 2 位的天数。

示例 1：

输入：date = “20th Oct 2052”
输出：“2052-10-20”
示例 2：

输入：date = “6th Jun 1933”
输出：“1933-06-06”
示例 3：

输入：date = “26th May 1960”
输出：“1960-05-26”

提示：

给定日期保证是合法的，所以不需要处理异常输入。

class Solution {
    public String reformatDate(String date) {
        //先把这三个分开，日月年（按空格分成数组）
        String[] num = date.split(" ");
        //先求日，日是前面的数字就好，20th就是20，
        char[] day = num[0].toCharArray();
        String days ="";
        //如果这个字符是数字就可以拿出来
        for (char c:day){
            if(Character.isDigit(c)){
                days+=c;
            }
        }
        //如果是6th这种，拿出来是6不符合日期，如要前面加个0
        if(days.length()<2){
            days="0"+days;
        }
        //求月，月的话需要数组，然后找到下标+1就是月份，因为数组下标是从0开始，找到的下标是当前月份-1
        String months="";
       String[] month= {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
        for (int i=0;i<12;i++){
            if(month[i].equals(num[1])){
                months=(i+1)+"";
            }
        }
        //同样的要做处理，防止1月不符合日期格式，要在前面加0
        if(months.length()<2){
            months="0"+months;
        }
        //直接按照输出格式输出
        return num[2]+"-"+months+"-"+days;
    }
}

5445. 子数组和排序后的区间和

给你一个数组 nums ，它包含 n 个正整数。你需要计算所有非空连续子数组的和，并将它们按升序排序，得到一个新的包含 n * (n + 1) / 2 个数字的数组。

请你返回在新数组中下标为 left 到 right （下标从 1 开始）的所有数字和（包括左右端点）。由于答案可能很大，请你将它对 10^9 + 7 取模后返回。

示例 1：

输入：nums = [1,2,3,4], n = 4, left = 1, right = 5
输出：13
解释：所有的子数组和为 1, 3, 6, 10, 2, 5, 9, 3, 7, 4 。将它们升序排序后，我们得到新的数组 [1, 2, 3, 3, 4, 5, 6, 7, 9, 10] 。下标从 le = 1 到 ri = 5 的和为 1 + 2 + 3 + 3 + 4 = 13 。
示例 2：

输入：nums = [1,2,3,4], n = 4, left = 3, right = 4
输出：6
解释：给定数组与示例 1 一样，所以新数组为 [1, 2, 3, 3, 4, 5, 6, 7, 9, 10] 。下标从 le = 3 到 ri = 4 的和为 3 + 3 = 6 。
示例 3：

输入：nums = [1,2,3,4], n = 4, left = 1, right = 10
输出：50

提示：

1 <= nums.length <= 10^3
nums.length == n
1 <= nums[i] <= 100
1 <= left <= right <= n * (n + 1) / 2

class Solution {
    public int rangeSum(int[] nums, int n, int left, int right) {
        LinkedList<Integer> list = new LinkedList<>();
        int sum = 0;
        //暴力循环每一种情况
        for (int i = 0; i < nums.length; i++) {
            sum = 0;
            for (int j = i; j < nums.length; j++) {
                sum += nums[j];
                list.add(sum);
            }
        }
        //给每一种子数组和排序
        Collections.sort(list);
        int res = 0;
        //找到相对范围，因为下标是从0开始，但题目是从1开始，所以都要减1
        for (int i = left - 1; i <= right - 1; i++) {
            res+=list.get(i);
            if (res >  1000000007 ) {
                res -= 1000000007;
            }
        }
        return res;
    }
}

5446. 三次操作后最大值与最小值的最小差

给你一个数组 nums ，每次操作你可以选择 nums 中的任意一个数字并将它改成任意值。

请你返回三次操作后， nums 中最大值与最小值的差的最小值。

示例 1：

输入：nums = [5,3,2,4]
输出：0
解释：将数组 [5,3,2,4] 变成 [2,2,2,2].
最大值与最小值的差为 2-2 = 0 。
示例 2：

输入：nums = [1,5,0,10,14]
输出：1
解释：将数组 [1,5,0,10,14] 变成 [1,1,0,1,1] 。
最大值与最小值的差为 1-0 = 1 。
示例 3：

输入：nums = [6,6,0,1,1,4,6]
输出：2
示例 4：

输入：nums = [1,5,6,14,15]
输出：1

提示：

1 <= nums.length <= 10^5
-10^9 <= nums[i] <= 10^9

class Solution {
    public int minDifference(int[] nums) {
        /*
            这里有一个问题就是，我只能改三次，如果改的话，肯定是把最大的改小了，或者把最小的改大了
            我们先排个序，改的三次不是在头就是在尾，我们用后四个分别减去前四个，
            求出最小的，那其他三个就是比较大的，改的时候改那三个就可以了

        */

        Arrays.sort(nums);
        int n = nums.length;
        //如果不到四个元素，证明把其他三个全换成和另一个一样的就可以了，结果就为0了
        if (n <= 4) {
            return 0;
        }
        return Math.min(Math.min(nums[n - 1] - nums[3], nums[n - 2] - nums[2]), Math.min(nums[n - 3] - nums[1], nums[n - 4] - nums[0]));

    }
}

5447. 石子游戏 IV

Alice 和 Bob 两个人轮流玩一个游戏，Alice 先手。

一开始，有 n 个石子堆在一起。每个人轮流操作，正在操作的玩家可以从石子堆里拿走 任意 非零 平方数 个石子。

如果石子堆里没有石子了，则无法操作的玩家输掉游戏。

给你正整数 n ，且已知两个人都采取最优策略。如果 Alice 会赢得比赛，那么返回 True ，否则返回 False 。

示例 1：

输入：n = 1
输出：true
解释：Alice 拿走 1 个石子并赢得胜利，因为 Bob 无法进行任何操作。
示例 2：

输入：n = 2
输出：false
解释：Alice 只能拿走 1 个石子，然后 Bob 拿走最后一个石子并赢得胜利（2 -> 1 -> 0）。
示例 3：

输入：n = 4
输出：true
解释：n 已经是一个平方数，Alice 可以一次全拿掉 4 个石子并赢得胜利（4 -> 0）。
示例 4：

输入：n = 7
输出：false
解释：当 Bob 采取最优策略时，Alice 无法赢得比赛。
如果 Alice 一开始拿走 4 个石子， Bob 会拿走 1 个石子，然后 Alice 只能拿走 1 个石子，Bob 拿走最后一个石子并赢得胜利（7 -> 3 -> 2 -> 1 -> 0）。
如果 Alice 一开始拿走 1 个石子， Bob 会拿走 4 个石子，然后 Alice 只能拿走 1 个石子，Bob 拿走最后一个石子并赢得胜利（7 -> 6 -> 2 -> 1 -> 0）。
示例 5：

输入：n = 17
输出：false
解释：如果 Bob 采取最优策略，Alice 无法赢得胜利。

提示：

1 <= n <= 10^5

class Solution {
     public boolean winnerSquareGame(int n) {
         /*
            递推思路
                list保存一下可以取的石子的数量
                我们创建一个n+1的数组，循环每一个数量的石子数
                对于每一个石子数，只要当前石子数-可以取的石子数就证明可以取到这个数量
                并且数组当前石子数-可以取的石子数还要等于0，证明是没取过
                如果数组当前石子数-可以取的石子数等于1，说明我之前取过，
                如果我取过的话，我就不能再取了，我取过，该换bob取了

         */
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i * i <= n; i++) {
            //把可以取的数量都放进list
            list.add(i * i);
        }
        int[] dp = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            //循环每一种可以取的石子数
            for (int num : list) {
                //如果上一次不是我取得，证明我可以取，我取完得dp为1，bob取完得dp为0
                if (num <= i && dp[i - num] == 0) {
                    dp[i] = 1;
                }
            }
        }
        return dp[n] == 1;
    }
}

又不懂或者写的不恰当的地方欢迎大佬评论