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;
    	
    }
}

import java.util.*;
public class Solution {
    public boolean IsContinuous(int [] numbers) {
		if(numbers == null || numbers.length <= 4)
            return false;
        
        //先排序，否則計(jì)算間隔的時(shí)候可能會(huì)出現(xiàn)負(fù)值，比較麻煩
        Arrays.sort(numbers);
        int totalGap = 0;
        //計(jì)算大小王的數(shù)量
        int countZero = 0;
        for(int i = 0; i < numbers.length; i++){
            if(numbers[i] == 0){
                countZero++;
                continue;
            }
            //計(jì)算兩數(shù)之間的間隔
            if(i < numbers.length - 1){
                int gap = numbers[i + 1] - numbers[i] - 1;
                //如果出現(xiàn)對(duì)子，如2 2，則gap為-1，直接返回false
                if(gap < 0)
                    return false;
                totalGap += gap;
            }
        }
        //所有數(shù)間隔大于王數(shù)量，就返回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;
	            //計(jì)算間隔數(shù)
	            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;
	    }
}

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]存放大小王數(shù)目; a[i] (1~13)不為0表示牌被抽到;
	 * a[i]~a[i+4] (a[i]為第一個(gè)不為0即抽到的牌);
	 * 統(tǒng)計(jì)滿足連續(xù)其中缺少的牌 即a[i]==0的個(gè)數(shù);
	 * 與大小王個(gè)數(shù)比較即可
	 */
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張的時(shí)候返回false;
             return false;
         Arrays.sort(numbers);    //排序，方便統(tǒng)計(jì)王（0）的數(shù)量以及比較是否存在相等的牌（前后比較即可）
         int res = 0;    //統(tǒng)計(jì)王（0）的數(shù)量
         for(int i=0;i<numbers.length;i++){
             if(numbers[i] == 0){
                 res++;
                 continue;
             }
             //王的數(shù)量小于等于3張時(shí)才需要做判斷
             //判斷第一張非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記下最小的一個(gè)非0數(shù)字
? ? ? ? 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記下最小的一個(gè)非0數(shù)字
//
// ? ? ? ?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之外，數(shù)字最大最小差<=4并且沒有重復(fù)可以解開

?# 是否有重復(fù)的數(shù)可以利用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;
? ? }
}

public class Solution {
    public static boolean IsContinuous(int [] numbers) {
        if(numbers.length!=5)
            return false;
        int count = 0;//統(tǒng)計(jì)王的個(gè)數(shù)
        int max = -1;
        int min = 14;
        for(int i = 0;i<numbers.length;i++){
            if(numbers[i]==0){
                count++;
                continue;
            }
            if(numbers[i]>max)
                max = numbers[i];
            if(numbers[i]<min)
                min = numbers[i];
        }
        if(max==min&&count==4)
	        	return true;
        while(max-min!=4&&count>0){
            if(max<5){
                int t = Math.min(count, 5-max);
                max+=t;
                count -= t;
            }else{
                int t = Math.min(count, max-5);
                min -= t;
                count -= t;
            }
        }

        if(min==max-4)
            return true;//最大和最小相差4
        return false;   
    }
}

import java.util.Arrays;
public class Solution {
    public boolean IsContinuous(int [] numbers) {
        int count=0;
        Arrays.sort(numbers);
        for(int i=0; i<4; i++) {
            if(numbers[i] == 0) count++;
            else if(numbers[i] == numbers[i+1]) return false;
        }
        return numbers[4]-numbers[count]<5;
    }
}

import?java.util.*;

public?class?Solution?{
????public?boolean?IsContinuous(int?[]?numbers)?{
????????Arrays.sort(numbers);
????????int?zero?=?0;
????????int?gap?=?0;
????????for?(int?i?=?0;?i?<?numbers.length;?i++)?{
????????????if?(numbers[i]?==?0)?{
????????????????zero++;
????????????}?else?{
????????????????if?(i?>?0?&&?numbers[i?-?1]?!=?0?)?{
????????????????????if?(numbers[i]?==?numbers[i?-?1])?{
????????????????????????return?false;
????????????????????}?else?{
????????????????????????gap?+=?numbers[i]?-?numbers[i?-?1]?-?1;
????????????????????}

????????????????}
????????????}
????????}
????????if?(gap?<=?zero)?{
????????????return?true;
????????}?else?{
????????????return?false;
????????}




????}
}