剑指 Offer 61. 扑克牌中的顺子

输入: [1,2,3,4,5]
输出: True

输入: [0,0,1,2,5]
输出: True

class Solution {
    public boolean isStraight(int[] nums) {
        // 排序法 nlogn

        // 集合 n，n
        // 如果要成为一个顺子，则需要 满足两个条件
        // 1、不存在有重复的数，大小王除外
        // 2、最大值 - 最小值 < 5,大小王除外
        Set<Integer> set = new HashSet<>();
        int max = -1, min = 20;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] == 0) continue;
            if(set.contains(nums[i]))return false;
            set.add(nums[i]);
            max = Math.max(nums[i], max);
            min = Math.min(nums[i], min);
        }

        return max - min < 5;
    }
}

class Solution(object):
    def isStraight(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """

        # 集合 n，n
        # 如果要成为一个顺子，则需要 满足两个条件
        # 1、不存在有重复的数，大小王除外
        # 2、最大值 - 最小值 < 5,大小王除外
        s = set()
        max_num, min_num = -1, 20

        for i in range(len(nums)):
            if nums[i] == 0:
                continue
            if nums[i] in s:
                return False
            s.add(nums[i])
            max_num = max(max_num, nums[i])
            min_num = min(min_num, nums[i])

        return max_num - min_num < 5

class Solution {
public:
    bool isStraight(vector<int>& nums) {
        // 集合 n，n
        // 如果要成为一个顺子，则需要 满足两个条件
        // 1、不存在有重复的数，大小王除外
        // 2、最大值 - 最小值 < 5,大小王除外
        set<int> s;
        int max_num = -1, min_num = 20;

        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == 0) {
                continue;
            }
            if (s.count(nums[i])) {
                return false;
            }
            s.insert(nums[i]);
            max_num = max(max_num, nums[i]);
            min_num = min(min_num, nums[i]);
        }

        return max_num - min_num < 5;
    }
};

func isStraight(nums []int) bool {
    // 集合 n，n
    // 如果要成为一个顺子，则需要 满足两个条件
    // 1、不存在有重复的数，大小王除外
    // 2、最大值 - 最小值 < 5,大小王除外
    s := make(map[int]bool)
    maxNum, minNum := -1, 20

    for _, num := range nums {
        if num == 0 {
            continue
        }
        if _, ok := s[num]; ok {
            return false
        }
        s[num] = true
        if num > maxNum {
            maxNum = num
        }
        if num < minNum {
            minNum = num
        }
    }

    return maxNum-minNum < 5
}

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var isStraight = function(nums) {
    // 集合 n，n
    // 如果要成为一个顺子，则需要 满足两个条件
    // 1、不存在有重复的数，大小王除外
    // 2、最大值 - 最小值 < 5,大小王除外
    const s = new Set();
    let maxNum = -1, minNum = 20;

    for (let i = 0; i < nums.length; i++) {
        if (nums[i] === 0) {
            continue;
        }
        if (s.has(nums[i])) {
            return false;
        }
        s.add(nums[i]);
        maxNum = Math.max(maxNum, nums[i]);
        minNum = Math.min(minNum, nums[i]);
    }

    return maxNum - minNum < 5;
};