扑克牌顺子

public boolean IsContinuous (int[] numbers) {
    // write code here
    Arrays.sort(numbers);
    int diff=0 ,zeroNum=0;
    for(int i=0;i<numbers.length;i++){
        if(numbers[i]==0){
            zeroNum++;
        }else if(i>0 && numbers[i-1]!=0){
            if(numbers[i]!=numbers[i-1]){
                diff+=(numbers[i]-numbers[i-1])-1;
            }else{
                return false;
            }
        }
    }
    return diff<=zeroNum;
}

import java.util.*;

public class Solution {
    public boolean IsContinuous(int [] numbers) {
        //先排序
        Arrays.sort(numbers);
        int count = 0;
        for (int num : numbers) {
            if (num == 0) {
                count++;
            }
        }
        //新数组不带0的
        int[] c = Arrays.copyOfRange(numbers,count,numbers.length);
        boolean flag = false;
        int sum = 0;
        for (int i = 0; i < c.length-1; i++) {
            if( c[i] == c[i+1]){
                return flag;
            } else if (c[i] != c[i+1] && c[i+1]-c[i] != 1) {
                sum += c[i+1]-c[i]-1;
            }
        }
        if (sum <= count){
            flag = true;
        }
        return flag;
    }
}

public boolean IsContinuous(int[] numbers) {
        int max = 0;
        int min = 14;
        for(int i = 0; i < numbers.length; i++) {
            // 如果有重复值, 并且重复值不为 0, 返回 false
            if((numbers[i] == min || numbers[i] == max) && numbers[i] != 0) {
                return false;
            }
            if(max - min > 4) {
                return false;
            }
            // 更新最大值
            if(max < numbers[i]) {
                max = numbers[i];
            }
            // 更新最小值, 遇到 0 不更新
            if(min > numbers[i] && numbers[i] != 0) {
                min = numbers[i];
            }
        }
        // 最后一次更新最大值, 最小值, 还没有进行判断
        return max - min <= 4;
    }

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

public class Solution {
    public boolean IsContinuous(int [] numbers) {
        int len = 5;
        int min = 14;
        int max = 0;
        int count = 0;
        int n = 0;
        for(int i: numbers){
            if(i == 0){
                count++;
            } else {
                min = i<min?i:min;
                max = i>max?i:max;
            }
        }
        
        if( max - min > len - 1 || count == len ){
            return false;
        }
        
        for(int i = 0 ; i < numbers.length; i++){
            if(numbers[i] > 0){
                n += (numbers[i] == 1 ? 1 : 0);
                numbers[i] = numbers[i] - min;
            }
        }
        
        if(n > 1){
            return false;
        }
        
        int t;
        for(int i = 0 ; i < numbers.length; ){
            if (numbers[i] == 0 || numbers[i] == i){
                i++;
                continue;
            }
            if( numbers[numbers[i]]  == numbers[i] ){
                return false;
            } else {
                t = numbers[numbers[i]];
                numbers[numbers[i]] = numbers[i];
                numbers[i] = t;
            }
        }
        
        return true;
    }
}

import java.util.*;
/**
1.先对数组排序
2.遍历数组，找出其中0的个数，同时判断有没有非0且重复的牌，
  如果有那么返回false
3.确定数组中的非0牌不重复后，找出非0牌的最大值和最小值left、right
4.从left到right要保持连续，需要right-left+1张牌，
    若整个数组的长度大于等于right-left+1，则肯定可以构成顺子，返回true
    否则返回false

*/
public class Solution {
    public boolean IsContinuous(int [] numbers) {
        Arrays.sort(numbers);
        int count = 0;
        for(int  i = 0;i <numbers.length;++i){ 
            if(numbers[i] != 0){
                count = i;
                for(; i <numbers.length-1;++i){
                    if(numbers[i] == numbers[i+1])
                        return false;
                }
                break;
            }
        }
        
        int left = numbers[count];
        int right = numbers[numbers.length-1];
        if(right - left +1 <= numbers.length){
            return true;
        }else{
            return false;
        }

    }
}

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




    }
}

import java.util.*;
public class Solution {
    public boolean IsContinuous(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return false;
        }
        int maxNum = 0;
        int minNum = 14;
        int count0 = 0;
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < 5; i++) {
            if (numbers[i] == 0) {
                count0++;
            } else {
                if (!set.add(numbers[i])) {
                    return false;
                }
                maxNum = Math.max(maxNum, numbers[i]);
                minNum = Math.min(minNum, numbers[i]);
            }
        }
        int need0 = maxNum - minNum + count0 - 4;
        return count0 >= need0;
    }
}

O(N)复杂度
1、进行牌值与数量的映射，用数组即可
2、统计0数量，方便后续填充
3、找到数字值最小的牌
4、从该牌位置向后搜索，遇到元素值重复就返回false，遇到数量为0则用0填充（如果还有0）
5、双指针找到最大和最小的牌
6、最大牌减最小牌加0数量-1得等于5

public class Solution {
    public boolean IsContinuous(int [] numbers) {
        int[] indexs = new int[14];
        for(int i=0; i<numbers.length; i++) {
            indexs[numbers[i]]++;
        }
        //统计0数量
        int zeroCount = indexs[0];
        int index = 1;
        //找到第一个数字位置
        while(indexs[index]==0) {
                index++;
            }
        //模拟放置空白位置
        for(; index<14; index++) {
            if(indexs[index]>1)
                return false;
            if(indexs[index]<1) {
                if(zeroCount>0) {
                    indexs[index] = 1;
                    zeroCount--;
                }

            }

        }
        //双指针找到两端
        int i=1;
        for(;i<14;i++) {
            if(indexs[i]==1)
                break;
        }
        int j = 13;
        for(;j>=0; j--) {
            if(indexs[j]==1)
                break;
        }
        return j-i+zeroCount+1 == 5;
    }
}

import java.lang.Math;
import java.util.HashSet;
public class Solution {
   
    public boolean IsContinuous(int [] numbers) {
        HashSet<Integer> set = new HashSet();
        int max = -1;
        int min = 14;
        for(int i=0;i<numbers.length;i++){
            if(numbers[i]==0){
                continue;
            }
            if(set.contains(numbers[i])){
                return false;
            }
            set.add(numbers[i]);
            max = Math.max(max,numbers[i]);
            min = Math.min(min,numbers[i]);
            if(max-min>=5){
                return false;
            }
        }
        return true;
    }
}

import java.util.*;

public class Solution {
    public boolean IsContinuous(int [] numbers) {
        Arrays.sort(numbers); // 先排序
        int cnt = 0, dif = 0;
        for (int i = 0; i < numbers.length-1; i++) {
            if (numbers[i] == 0) cnt++;
            else {
                // 站位相同非0 直接返回
                if (numbers[i] == numbers[i+1]) return false;
                dif += numbers[i+1] - numbers[i] - 1;
            }
        }
        return dif <= cnt; // 0够用补齐空缺位置就行
    }
}