标签： easy

目标

给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:

输入: rowIndex = 3
输出: [1,3,3,1]

示例 2:

输入: rowIndex = 0
输出: [1]

示例 3:

输入: rowIndex = 1
输出: [1,1]

说明:

• 0 <= rowIndex <= 33

进阶：

你可以优化你的算法到 O(rowIndex) 空间复杂度吗？

思路

返回杨辉三角第 rowIndex 行的元素。

代码

/**
 * @date 2025-01-28 1:06
 */
public class GetRow119 {

    public List<Integer> getRow(int rowIndex) {
        List<Integer> res = new ArrayList<>();
        res.add(1);
        if (rowIndex == 0) {
            return res;
        }
        for (int i = 1; i <= rowIndex; i++) {
            int prev = res.get(0);
            for (int j = 1; j < res.size(); j++) {
                int cur = prev + res.get(j);
                prev = res.get(j);
                res.set(j, cur);
            }
            res.add(1);
        }
        return res;
    }

}

性能

目标

给你一个长度为 n 的整数数组 nums ，请你返回 nums 中最 接近 0 的数字。如果有多个答案，请你返回它们中的 最大值 。

示例 1：

输入：nums = [-4,-2,1,4,8]
输出：1
解释：
-4 到 0 的距离为 |-4| = 4 。
-2 到 0 的距离为 |-2| = 2 。
1 到 0 的距离为 |1| = 1 。
4 到 0 的距离为 |4| = 4 。
8 到 0 的距离为 |8| = 8 。
所以，数组中距离 0 最近的数字为 1 。

示例 2：

输入：nums = [2,-1,1]
输出：1
解释：1 和 -1 都是距离 0 最近的数字，所以返回较大值 1 。

说明：

• 1 <= n <= 1000
• -10^5 <= nums[i] <= 10^5

思路

返回数组中最接近 0 的数字，如果有多个结果返回最大的那个。

代码

/**
 * @date 2025-01-20 8:43
 */
public class FindClosestNumber2239 {

    public int findClosestNumber(int[] nums) {
        int res = nums[0];
        int min = Math.abs(res);
        for (int num : nums) {
            int b = Math.abs(num);
            if (min > b) {
                res = num;
                min = b;
            } else if (min == b) {
                res = num > 0 ? num : res;
            }
        }
        return res;
    }

}

性能

目标

给你一个 非负 整数数组 nums 和一个整数 k 。

如果一个数组中所有元素的按位或运算 OR 的值 至少 为 k ，那么我们称这个数组是 特别的 。

请你返回 nums 中 最短特别非空 子数组 的长度，如果特别子数组不存在，那么返回 -1 。

示例 1：

输入：nums = [1,2,3], k = 2
输出：1
解释：
子数组 [3] 的按位 OR 值为 3 ，所以我们返回 1 。
注意，[2] 也是一个特别子数组。

示例 2：

输入：nums = [2,1,8], k = 10
输出：3
解释：
子数组 [2,1,8] 的按位 OR 值为 11 ，所以我们返回 3 。

示例 3：

输入：nums = [1,2], k = 0
输出：1
解释：
子数组 [1] 的按位 OR 值为 1 ，所以我们返回 1 。

说明：

• 1 <= nums.length <= 50
• 0 <= nums[i] <= 50
• 0 <= k < 64

思路

求数组 nums 的最短特别子数组长度，特别子数组的所有元素按位与的结果大于等于 k。

枚举子数组，暴力求解每个子数组的或值。

代码

/**
 * @date 2025-01-16 22:22
 */
public class MinimumSubarrayLength3095 {
    /**
     * 枚举起点 O(n^2)
     */
    public int minimumSubarrayLength_v1(int[] nums, int k) {
        int n = nums.length;
        int res = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            int or = 0;
            for (int j = i; j < n; j++) {
                or |= nums[j];
                if (or >= k) {
                    res = Math.min(res, j - i + 1);
                    break;
                }
            }
        }
        return res == Integer.MAX_VALUE ? -1 : res;
    }

    /**
     * 枚举终点 O(n^3)
     */
    public int minimumSubarrayLength(int[] nums, int k) {
        int n = nums.length;
        int res = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                int or = 0;
                for (int x = j; x <= i; x++) {
                    or |= nums[x];
                }
                if (or >= k) {
                    res = Math.min(res, i - j + 1);
                }
            }
        }
        return res == Integer.MAX_VALUE ? -1 : res;
    }
}

性能

目标

给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。

一次操作中，你可以删除 nums 中的最小元素。

你需要使数组中的所有元素都大于或等于 k ，请你返回需要的 最少 操作次数。

示例 1：

输入：nums = [2,11,10,1,3], k = 10
输出：3
解释：第一次操作后，nums 变为 [2, 11, 10, 3] 。
第二次操作后，nums 变为 [11, 10, 3] 。
第三次操作后，nums 变为 [11, 10] 。
此时，数组中的所有元素都大于等于 10 ，所以我们停止操作。
使数组中所有元素都大于等于 10 需要的最少操作次数为 3 。

示例 2：

输入：nums = [1,1,2,4,9], k = 1
输出：0
解释：数组中的所有元素都大于等于 1 ，所以不需要对 nums 做任何操作。

示例 3：

输入：nums = [1,1,2,4,9], k = 9
输出：4
解释：nums 中只有一个元素大于等于 9 ，所以需要执行 4 次操作。

说明：

• 1 <= nums.length <= 50
• 1 <= nums[i] <= 10^9
• 1 <= k <= 10^9
• 输入保证至少有一个满足 nums[i] >= k 的下标 i 存在。

思路

求数组中小于 k 的元素个数。

代码

/**
 * @date 2025-01-14 8:41
 */
public class MinOperations3065 {

    public int minOperations(int[] nums, int k) {
        int res = 0;
        for (int num : nums) {
            if (num < k){
                res++;
            }
        }
        return res;
    }
}

性能

目标

给你三个 正 整数 num1 ，num2 和 num3 。

数字 num1 ，num2 和 num3 的数字答案 key 是一个四位数，定义如下：

• 一开始，如果有数字 少于 四位数，给它补 前导 0 。
• 答案 key 的第 i 个数位（1 <= i <= 4）为 num1 ，num2 和 num3 第 i 个数位中的 最小 值。

请你返回三个数字 没有 前导 0 的数字答案。

示例 1：

输入：num1 = 1, num2 = 10, num3 = 1000
输出：0
解释：
补前导 0 后，num1 变为 "0001" ，num2 变为 "0010" ，num3 保持不变，为 "1000" 。
数字答案 key 的第 1 个数位为 min(0, 0, 1) 。
数字答案 key 的第 2 个数位为 min(0, 0, 0) 。
数字答案 key 的第 3 个数位为 min(0, 1, 0) 。
数字答案 key 的第 4 个数位为 min(1, 0, 0) 。
所以数字答案为 "0000" ，也就是 0 。

示例 2：

输入： num1 = 987, num2 = 879, num3 = 798
输出：777

示例 3：

输入：num1 = 1, num2 = 2, num3 = 3
输出：1

说明：

• 1 <= num1, num2, num3 <= 9999

思路

有三个小于等于 9999 的正整数，求四位数字 key，从左向右第 i 位是这三个数字对应数位（十进制）上数字的最小值。

根据题意模拟即可。

代码

/**
 * @date 2025-01-11 16:55
 */
public class GenerateKey3270 {
    public int generateKey(int num1, int num2, int num3) {
        int res = 0;
        int base = 1000;
        for (int i = 0; i < 4; i++) {
            int a1 = num1 / base;
            int a2 = num2 / base;
            int a3 = num3 / base;
            res += Math.min(a1, Math.min(a2, a3)) * base;
            num1 %= base;
            num2 %= base;
            num3 %= base;
            base /= 10;
        }
        return res;
    }
}

性能

目标

给你一个字符串 date，它的格式为 yyyy-mm-dd，表示一个公历日期。

date 可以重写为二进制表示，只需要将年、月、日分别转换为对应的二进制表示（不带前导零）并遵循 year-month-day 的格式。

返回 date 的 二进制 表示。

示例 1：

输入： date = "2080-02-29"
输出： "100000100000-10-11101"
解释：
100000100000, 10 和 11101 分别是 2080, 02 和 29 的二进制表示。

示例 2：

输入： date = "1900-01-01"
输出： "11101101100-1-1"
解释：
11101101100, 1 和 1 分别是 1900, 1 和 1 的二进制表示。

说明：

• date.length == 10
• date[4] == date[7] == '-'，其余的 date[i] 都是数字。
• 输入保证 date 代表一个有效的公历日期，日期范围从 1900 年 1 月 1 日到 2100 年 12 月 31 日（包括这两天）。

思路

将日期转化为二进制表示。

代码

/**
 * @date 2025-01-01 18:53
 */
public class ConvertDateToBinary3280 {

    public String convertDateToBinary(String date) {
        return new StringBuilder().append(Integer.toBinaryString(Integer.parseInt(date.substring(0,4))))
                .append("-")
                .append(Integer.toBinaryString(Integer.parseInt(date.substring(5,7))))
                .append("-")
                .append(Integer.toBinaryString(Integer.parseInt(date.substring(8,10)))).toString();
    }

}

性能

目标

给你一个长度为 偶数 的整数数组 nums 。你需要将这个数组分割成 nums1 和 nums2 两部分，要求：

• nums1.length == nums2.length == nums.length / 2 。
• nums1 应包含 互不相同 的元素。
• nums2也应包含 互不相同 的元素。

如果能够分割数组就返回 true ，否则返回 false 。

示例 1：

输入：nums = [1,1,2,2,3,4]
输出：true
解释：分割 nums 的可行方案之一是 nums1 = [1,2,3] 和 nums2 = [1,2,4] 。

示例 2：

输入：nums = [1,1,1,1]
输出：false
解释：分割 nums 的唯一可行方案是 nums1 = [1,1] 和 nums2 = [1,1] 。但 nums1 和 nums2 都不是由互不相同的元素构成。因此，返回 false 。

说明：

• 1 <= nums.length <= 100
• nums.length % 2 == 0
• 1 <= nums[i] <= 100

思路

判断数组中同一元素的出现次数不超过两次。

代码

/**
 * @date 2024-12-28 19:16
 */
public class IsPossibleToSplit3046 {

    public boolean isPossibleToSplit(int[] nums) {
        int[] cnt = new int[101];
        for (int num : nums) {
            if (++cnt[num] > 2) {
                return false;
            }
        }
        return true;
    }
}

性能