#python 2.7 时间：36ms 内存：5764k
# 说好的是一副牌，还会出现[3,0,0,0,0]？ 出题人这么想的？
# 两个条件：1，除0外没有重复，2，max-min<5
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if len(numbers):
            while min(numbers)==0:
                numbers.remove(0)
            if max(numbers) - min(numbers)<=4 and len(numbers)==len(set(numbers)):
                return True
        return False

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {
        sort(numbers.begin(), numbers.end());
        int cnt0 = 0, cntNeed = 0;
        for(int i = 0; i < 5; i++) {
            if(numbers[i] == 0) {
                ++cnt0;
            } else if(i + 1 < 5 ) {
                if(numbers[i + 1] == numbers[i]) return false;
                cntNeed += numbers[i + 1] - numbers[i] - 1;
            }
        }
        if(cntNeed > cnt0) return false;
        return true;
    }
};

import java.util.HashSet;
import java.util.Set;

public class Solution {
    public boolean IsContinuous(int [] numbers) {
        if(numbers.length == 0) return false;
    	Set<Integer> set = new HashSet<>();
    	int maxn = -1, minn = 14;
    	for(int a: numbers)
    	{
    		if(!set.add(a) && a!=0) return false;
    		if(a!=0) {
    			maxn = Math.max(maxn, a);
    			minn = Math.min(minn, a);
    		}
    	}
    	if(maxn - minn <=4) return true;
    	return false;
    	
    }
}

这坑爹的题目 说了5张牌 居然还给空数组 居心叵测的测试样例
排个序 计算前面0的个数zeros
然后zeros - (顺子差的数)
若zeros最后 >= 0 说明用大小王补够用 否则不行
还要判断一下只要有相同的牌直接返回false

class Solution {
public:
   bool IsContinuous(vector<int> numbers){
        if(numbers.empty()) return false;
        sort(numbers.begin(), numbers.end());
        int zeros = 0, i = 0;
        while(i < numbers.size() && numbers[i] == 0) {zeros++; i++;}
        for(i; i < numbers.size()-1; i++){
            if(numbers[i+1] == numbers[i]) return false;
            zeros -= (numbers[i+1] - numbers[i] - 1);
        }
        return zeros >= 0;        
    }
};

import java.util.*;
public class Solution {
    public boolean IsContinuous(int [] numbers) {
		if(numbers == null || numbers.length <= 4)
            return false;
        
        //先排序，否则计算间隔的时候可能会出现负值，比较麻烦
        Arrays.sort(numbers);
        int totalGap = 0;
        //计算大小王的数量
        int countZero = 0;
        for(int i = 0; i < numbers.length; i++){
            if(numbers[i] == 0){
                countZero++;
                continue;
            }
            //计算两数之间的间隔
            if(i < numbers.length - 1){
                int gap = numbers[i + 1] - numbers[i] - 1;
                //如果出现对子，如2 2，则gap为-1，直接返回false
                if(gap < 0)
                    return false;
                totalGap += gap;
            }
        }
        //所有数间隔大于王数量，就返回false
        if(totalGap > countZero){
            return false;
        }
        return true;
    }
}

import java.util.*;
public class Solution {
   public static boolean IsContinuous(int [] numbers) {
       		if(numbers == null || numbers.length <= 4)
                return false;
	        Arrays.sort(numbers);
			int count = 0;
	        for(int i : numbers){
	            if(i == 0)
	                count++;
	        }
	        //不含0，即不包含大小王
	        if(count == 0){
	            if(isSequence(numbers)){
	                return true;
	            }else{
	                return false;
	            }
	        }
	        //包含大小王
	        else{
	            if(count == 4)
	                return true;
	            int sum = 0;
	            //计算间隔数
	            for(int i = count + 1; i < numbers.length; i++){
	            	int gap = numbers[i] - numbers[i - 1] - 1;
	                if(gap < 0)
	                    return false;
	                sum += gap;
	            }
	            if(sum > count){
	                return false;
	            }
	            return true;
	        }
	    }
	    
	    private static boolean isSequence(int[] numbers){
	        
	        for(int i = 1 ; i < numbers.length; i++){
	            if(numbers[i] - numbers[i-1] != 1){
	                return false;
	            }
	        }
	        return true;
	    }
}

题目描述

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

解题思路

要组成顺子，我们想一想最简单的情况，就是四个王再搭一个任意牌，这五张牌必然是顺子。

那么到底如何判断是不是顺子呢？

一个关键点是0的个数，就是王的个数。另一个关键点是非0元素之间的差值和。

如果这个差值的和大于王的个数，那么王是无法填补里面的间隙的，那么就形不成顺子了。

下面举个简单的例子。比如有五张牌，分别是1，3，4，5，0，那么0可以作为2，可以作为顺子，此时0 的个数是1，而间隙是(3-1-1)+(4-3-1)+(5-4-1)=1（注意，数组要先排序，所以此时数组是0,1,3,4,5）,而0不要参与计算。此时0的个数为1，差值也为1，所以0可以来填补这个间隙，所以可以作为顺子。

再来看一个例子：0,0,1,5,6，0的个数为2，间隙为(5-1-1)+(6-5-1)=3,此时3>2，所以无法用0来填补，所以无法构成顺子。

最后就是注意，如果存在对子，那么肯定就不是顺子了。

分析完毕。

我的答案

import java.util.Arrays;
public class Solution {
    public boolean IsContinuous(int [] numbers) {
        if(numbers.length <= 0){
            return false;
        }

        //零的个数，即王的个数
        int zeroNum = 0;
        //排序后元素之间的差值
        int gapNum = 0;

        //数组排序
        Arrays.sort(numbers);

        //遍历数组
        for(int i=0;i<numbers.length-1;i++){
            //统计王的个数，统计到一个就重新循环，因为不需要参与后面的差值计算
            //也不需要对比是不是顺子
            if(numbers[i] == 0){
                zeroNum++;
                continue;
            }
            //不是王，并且还是对子，那肯定不是顺子了
            if(numbers[i] == numbers[i+1]){
                return false;
            }
            //不是王，计算一下两两的差值，最后与王的个数做比较
            gapNum += numbers[i+1] - numbers[i] - 1;
        }

        //差值小于王的个数，说明可以用王来构成顺子
        if(gapNum <= zeroNum){
            return true;
        }

        return false;
    }
}

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {
        if(numbers.size()!=5) return false;
        sort(numbers.begin(),numbers.end());
        int i=0;
        while(numbers[i]==0) i++;
        if(numbers[4]-numbers[i]>4) return false;
        for(int j=i;j<4;j++){
            if(numbers[j]==numbers[j+1]) return false;
        }
        return true;
    }
};

/*
	 * 思路:大小王看为0;则牌范围为0~13;
	 * a[0]存放大小王数目; a[i] (1~13)不为0表示牌被抽到;
	 * a[i]~a[i+4] (a[i]为第一个不为0即抽到的牌);
	 * 统计满足连续其中缺少的牌 即a[i]==0的个数;
	 * 与大小王个数比较即可
	 */
public class Solution {
    public boolean IsContinuous(int [] numbers) {
    	int[] a=new int[14];
    	for(int i=0;i<numbers.length;i++){
    		a[ numbers[i] ]++;
    	}
    	
    	for(int i=1;i<a.length-6;i++){
    		if(a[i]!=0){
    			int count=0;
    			for(int j=i;j<i+5;j++){
    				if(a[j]==0){
    					count++;
    				}
    			}
    			if(count==a[0]){
    				return true;
    			}
    			break;
    		}
    	}
    	return false;   	
    }
}

import java.util.Arrays;
 public class Solution {
     public boolean IsContinuous(int [] numbers) {
         if(numbers.length != 5)    //不够5张的时候返回false;
             return false;
         Arrays.sort(numbers);    //排序，方便统计王（0）的数量以及比较是否存在相等的牌（前后比较即可）
         int res = 0;    //统计王（0）的数量
         for(int i=0;i<numbers.length;i++){
             if(numbers[i] == 0){
                 res++;
                 continue;
             }
             //王的数量小于等于3张时才需要做判断
             //判断第一张非0的牌与最后一张的差，超过4，则不可能是顺子
             //判断前后张牌是否相等，相等则不可能是顺子
             if(res !=4 && (numbers[numbers.length-1]-numbers[i]>4 ||numbers[i] == numbers[i+1]))
                 return false;
             else 
                 return true;
         }
         return true;
     }
 }

function IsContinuous(numbers)
{
    // write code here
    var joker = 0;
    var n = numbers.sort();
    for(let i=0;i<4;i++){
        if(n[i]==0) joker++;
        else if(n[i]==n[i+1]) return false;
    }
    return n[4]-n[joker]<5;
}

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)))

    public boolean IsContinuous(int [] numbers) {
        int[] counts = new int[18];
        for (int num:numbers)   counts[num]++;
        int left,i;
        for (left = 1; left <14; left++) {
            if (counts[left] != 0)  break;
        }
        //用left记下最小的一个非0数字
        for (i = left + 1; i <= left+4; i++) {
            if (counts[i] == 0){
                if (counts[0] == 0) return false;
                else                counts[0]--;
            }
        }
        return true;
    }

//    public boolean IsContinuous(int [] numbers) {
//        int[] counts = new int[14];
//        for (int num:numbers)   counts[num]++;
//        int left,i;
//        for (left = 1; left <14; left++) {
//            if (counts[left] != 0)  break;
//        }
//        //用left记下最小的一个非0数字
//
//        for (i = left + 1; i <= left+4 && i<14  ; i++) {
//            if (counts[i] == 0){
//                if (counts[0] == 0) return false;
//                else                counts[0]--;
//            }
//        }
//
//        if (i == left + 5)  return true;
//        else{
//            if (14 - left + counts[0] == 5) return true;
//            else                            return false;
//        }
//    }

class Solution:
    def IsContinuous(self, numbers):
        numbers.sort()
        zero = numbers.count(0)
        gap = 0
        if not numbers:
            return False
        for i in range(zero,len(numbers)-1):
            if numbers[i+1] == numbers[i]:
                return False
            gap += numbers[i+1]-numbers[i]-1
        if gap <= zero:
            return True
        return False

Python solution:

该题利用除0之外，数字最大最小差<=4并且没有重复可以解开

​# 是否有重复的数可以利用len(numbers)==len(set(numbers))判断

def Issamenum(self, numbers):
    for i in numbers:
        if numbers.count(i) != 1 and i != 0:
            return False
    return True

​
def IsContinuous(self, numbers):
    # write code here
    if len(numbers) != 5:
        return False
    while min(numbers) == 0:
        numbers.remove(0)
    if max(numbers) - min(numbers) <= 4 and self.Issamenum(numbers):
        return True
    return False

import java.util.Arrays;

public class Solution {
    public boolean IsContinuous(int [] numbers) {
        if (numbers == null || numbers.length == 0) {
            return false;
        }
        Arrays.sort(numbers);
        int zeroCount = 0;
        boolean isSuccess = true;
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == 0) {
                zeroCount++;
            }
        }
        int k = zeroCount;
        for (int i = k; i < numbers.length - 1; i++) {
            if (numbers[i+1] - numbers[i] - 1 <= zeroCount && numbers[i+1] != numbers[i]) {
                zeroCount -= numbers[i+1] - numbers[i] - 1;
            }
            else {
                isSuccess = false;
                break;
            }
        }
        return isSuccess;
    }
}