扑克牌顺子

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if len(numbers)!=5:
            return False
        num_0=numbers.count(0)
        dif=0
        numbers.sort()
        n=len(numbers)
        for i in range(n-1):
            if numbers[i]!=0:
                if numbers[i]==numbers[i+1]:
                    return False
                else:
                    dif+=numbers[i+1]-numbers[i]-1
        if dif>num_0:
            return False
        else: return True

python解法：
解法1:排序之后数组中除了0的其他数字差值要在5以内，且不能有重复数字；

class Solution:
    def IsContinuous(self, numbers):
        if len(numbers) == 0:
            return False
        n = len(numbers)
        numbers = sorted(numbers)
        # 统计0的个数
        m = numbers.count(0)
#         for i in range(m,n-1):# 循环体内的m和n变化，并不会影响i的变化；
        for i in range(m,len(numbers)-1):
            # 1.numbers[i+1] - numbers[i] == 0看是否有重复元素；
            # 2.numbers[i+1] - numbers[i] >= n 排序之后数组中除了0的其他数字差值要在5以内；
            if numbers[i+1] - numbers[i] == 0 or numbers[i+1] - numbers[i] >= n:
                return False
            elif numbers[i+1] - numbers[i] < n:
                n -= numbers[i+1] - numbers[i]
        return True

解法2:统计0的个数，计算数组最大值和最小值(除了0）的差值，
若0的个数 <= 差值，则输出false，否则输出true，还要考虑不能有重复的数字；

class Solution:
    def IsContinuous(self, numbers):
        if len(numbers) == 0:
            return False
        n = len(numbers)
        numbers = sorted(numbers)
        # 统计0的个数
        m = numbers.count(0)
        for i in range(m,n-1):
            # 1.numbers[i+1] - numbers[i] == 0看是否有重复元素；
            # 2.numbers[i+1] - numbers[i] > m 看相邻两数的差值是否小于0的个数，因为是全部相邻两数的差值，其实就是最大值与最小值的差值与0的个数的比较；
            if numbers[i+1] - numbers[i] == 0 or numbers[i+1] - numbers[i] - 1 > m:
                return False
            elif numbers[i+1] - numbers[i] - 1 <= m:
                m -= numbers[i+1] - numbers[i] - 1
        return True

class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if len(numbers)>0:
            a=numbers.count(0)
            c=sorted(numbers)[a:]
            if len(c)==len(set(c)):
                if c[-1]-c[0]<=4:
                    return True
                else:
                    return False
            else:
                return False
        else:
            return False

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        if not numbers:
            return False
        numbers.sort()
        n = numbers.count(0)
        for j in range(n):
            numbers.remove(0)
        if max(numbers)-min(numbers)>4:
            return False
        for i in range(len(numbers)-1):
            if numbers[i+1]-numbers[i]!=1:
                if n==0&nbs***bsp;numbers[i+1]==numbers[i]:
                    return False
                else:
                    n-=1
        return True

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        #1、如果输入为空，返回false
        #2、除了王的任何某个特定数值的牌出现两张或者更多，那么一定凑不齐顺子。
        #思路，先统计王的数量，再把牌排序，如果后面一个数比前面一个数大于1以上，
        #那么中间的差值就必须用王来补了。看王的数量够不够，如果够就返回true，否则返回false。
        if not numbers:
            return False
        numbers.sort()#其实这里也将numbers由小到大排序了
        zeroNum = numbers.count(0)
        for index,value in enumerate(numbers[:-1]):
            if value != 0:
                if value == numbers[index+1]:
                    return False
                zeroNum = zeroNum -(numbers[index+1] - value)+1#前面排序了，所以括号里面肯定为正
                if zeroNum < 0:
                    return False
        return True

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers:
            return False
        numbers.sort()
        new_list = [i for i in numbers if i > 0]
        n = len(new_list)
        if n == 1:
            return True
        for i in range(n-1):
            if new_list[i+1] - new_list[i] == 0:
                return False
        num = max(new_list) - min(new_list)
        if num <= 4:
            return True
        return False

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers:
            return False
        zero = numbers.count(0)
        numbers.sort()
        for i, v in enumerate(numbers[:-1]):
            #因为我们每个都是当前数和下一个数比较，所以只能取到倒数第二个数！
            if v != 0:
                if numbers[i+1] == v:
                #如果五张牌有除了joker以外的牌有两张或两张以上，必然不能成顺子
                    return False
                zero = zero - (numbers[i+1] - v) + 1
                #此zero作为相邻两个数相差大于1的时候，做万能牌用
                #例如：12,13。 13-12 是不用消耗zero的
                if zero < 0:
                    return False
                #说明万能牌不够用，则不可能组成顺子
        return True

# -*- coding:utf-8 -*-

class Solution:
    def IsContinuous(self, numbers):
        n=numbers
        pai=[]
        if len(n)==0:
            return False

        for i in range(len(n)):
            if n[i]!=0:
                pai.append(n[i])
        pai.sort()
        if len(pai)==1:
            return True
        for i in range(len(pai)):
            if pai.count(pai[i])>=2:
                return False
        temp=0
        for i in range(len(pai)-1):
            temp=temp+(pai[i+1]-pai[i]-1)
        if temp<=len(n)-len(pai):
            return True
        else:
            return False

             
        
            
        
            
        # write code here

# -*- coding:utf-8 -*-
"""
1. 排序
2. 零的个数
3. 总的间隔区间
4. 零的个数小于间隔区间的个数，则可以补上
5. 注意存在一对的时候不可能有顺子
"""
class Solution:
    def IsContinuous(self, numbers):
        if not numbers:
            return False
        numbers = sorted(numbers)
        num_of_zeros = numbers.count(0)
        num_of_miss = 0
        for i in range(num_of_zeros, len(numbers) - 1):
            if numbers[i] == numbers[i+1]:
                return False
            elif numbers[i] + 1 == numbers[i+1]:
                continue
            else:
                num_of_miss += numbers[i+1] - numbers[i] - 1
        if num_of_zeros >= num_of_miss:
            return True
        else:
            return False


s = Solution()
ans = s.IsContinuous([0,0,3,14,5])
print(ans)

class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if not numbers:
            return False
        ns = [n for n in numbers if n != 0]
        return (max(ns) - min(ns) <= 4) and (len(ns) == len(set(ns)))

class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if len(numbers)==0:
           return False
        list1=[i for i in numbers]
        list1.sort()
        pre=0
        current=1
        count=0
        count1=0
        if len(numbers)<=2:
           return True
        while(pre<len(numbers)-1):
            if list1[pre]==0:
               count1+=1
            if list1[current]>list1[pre] and list1[pre]!=0:
               count+=list1[current]-list1[pre]-1
            pre+=1
            current+=1
        if list1[pre]==0:
            count1+=1
        if len(numbers)-count1<=1:
            return True
        if count1==count:
            return True
        else:
            return False

# -*- coding:utf-8 -*-
# 解题思路：必须满足两个条件才能组成顺子
# 1.除0之外没有数值重复（count + len(st) == 5）
# 2.最大值和最小值的差不能超过5（mx - mn < 5）
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        st = set()
        count = 0
        mx = 0
        mn = float('inf')
        for i in numbers:
            if i == 0:
                count += 1
            else:
                if i > mx:
                    mx = i

                if i < mn:
                    mn = i

                st.add(i)

        if count + len(st) == 5 and mx - mn < 5:
            return True

        return False