跳转至

2229. 检查数组是否连贯 🔒

题目描述

给你一个整数数组 nums ，如果 nums 是一个 连贯数组 ，则返回 true ，否则返回 false 。

如果数组包含 [x, x + n - 1] 范围内的所有数字（包括 x 和 x + n - 1 ），则该数组为连贯数组；其中 x 是数组中最小的数，n 是数组的长度。

 

示例 1：

输入：nums = [1,3,4,2]
输出：true
解释：
最小值是 1 ，数组长度为 4 。
范围 [x, x + n - 1] 中的所有值都出现在 nums 中：[1, 1 + 4 - 1] = [1, 4] = (1, 2, 3, 4) 。
因此，nums 是一个连贯数组。

示例 2：

输入：nums = [1,3]
输出：false
解释：
最小值是 1 ，数组长度为 2 。 
范围 [x, x + n - 1] 中的所有值没有都出现在 nums 中：[1, 1 + 2 - 1] = [1, 2] = (1, 2) 。 
因此，nums 不是一个连贯数组。

示例 3：

输入：nums = [3,5,4]
输出：true
解释：
最小值是 3 ，数组长度为 3 。
范围 [x, x + n - 1] 中的所有值都出现在 nums 中：[3, 3 + 3 - 1] = [3, 5] = (3，4，5) 。
因此，nums 是一个连贯数组。

 

提示：

  • 1 <= nums.length <= 105
  • 0 <= nums[i] <= 105

解法

方法一

1
2
3
4
5
class Solution:
    def isConsecutive(self, nums: List[int]) -> bool:
        mi, mx = min(nums), max(nums)
        n = len(nums)
        return len(set(nums)) == n and mx == mi + n - 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution {
    public boolean isConsecutive(int[] nums) {
        int mi = nums[0];
        int mx = nums[0];
        Set<Integer> s = new HashSet<>();
        for (int v : nums) {
            mi = Math.min(mi, v);
            mx = Math.max(mx, v);
            s.add(v);
        }
        int n = nums.length;
        return s.size() == n && mx == mi + n - 1;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution {
public:
    bool isConsecutive(vector<int>& nums) {
        unordered_set<int> s(nums.begin(), nums.end());
        int mi = *min_element(nums.begin(), nums.end());
        int mx = *max_element(nums.begin(), nums.end());
        int n = nums.size();
        return s.size() == n && mx == mi + n - 1;
    }
};

1
2
3
4
5
6
7
8
func isConsecutive(nums []int) bool {
    s := map[int]bool{}
    mi, mx := slices.Min(nums), slices.Max(nums)
    for _, x := range nums {
        s[x] = true
    }
    return len(s) == len(nums) && mx == mi+len(nums)-1
}

评论