剑指offer面试题61(java版):扑克牌中的顺子

welcome to my blog

剑指offer面试题61(java版):扑克牌中的顺子

题目描述

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。

class Solution {
    public boolean isStraight(int[] nums) {
        int n = nums.length;
        int flag=0;
        int min=14, max=0;
        for(int i=0; i<n; i++){
            if(nums[i]!=0){
                min = Math.min(min, nums[i]);
                max = Math.max(max, nums[i]);
                if((flag&(1<<nums[i]))!=0){
                    return false;
                }
                flag = flag | (1<<nums[i]);
            }
        }
        return max - min <= 4;
    }
}

第四次做; 核心: 1)数组中的max - min <= 4; ==4的情况是正好是顺子; <4的情况是数组中含有0; 2) 元素不能重复出现, 每个元素只能出现一次; 3) 养成一些意识, 比如发现题目中的数字取值范围有限就要想到用bitmap

class Solution {
    public boolean isStraight(int[] nums) {
        //input check
        if(nums==null || nums.length!=5)
            return false;
        int n = nums.length;
        int min = 14, max = 0;
        //可以用一个整数实现, 毕竟只有14个数字, 而且每个数字的状态只有两个: 出现过/没出现过
        boolean[] flag = new boolean[14];
        for(int i=0; i<n; i++){
            int a = nums[i];
            //判断输入是否合法
            if(a<0 || a>13)
                return false;
            if(a==0)
                continue;
            //非零元素不能重复出现(只能出现一次)
            if(flag[a]==true)
                return false;
            flag[a]=true;
            min = Math.min(min, a);
            max = Math.max(max, a);
        }
        return max - min <= 4;
    }
}

思路

• 明确顺子的定义:不重复的连续数, 两个限制条件: 1.不重复 2.连续
• 额外条件: 大小王可以作为任意数字, 为和其它牌便于区分,不妨令大小王取值为0, 但是功能上当做任意数
• 对于顺子来说, 相邻两数之间的差为1, 五张牌的话,相邻两张牌的差的和等于4, 如果相邻两张牌的差的和减去4的结果大于0的个数,说明无法凑成顺子; 小于0的个数就能凑成顺子
• 总结:
  • 对数组中的元素排序,并逐个遍历元素
    • 是0的话, zeroCount++
    • 非0的话, 先判断相邻两数是否相等, 相等的话就不是顺子了,返回false
    • 再计算相邻两数的差, 并将这个值加到前面计算出的差值delta上
  • 如果delta大于zeroCount就无法凑成顺子,返回false; 否则返回true

第三次做; 检查是否为合法输入; 检查非零元素是否重复:bit map; 进一步检查max - min 是否小于等于4; 注意min不考虑0; 最后的return能够包含全零的情况

public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers==null || numbers.length!=5)
            return false;
        int flag = 0, min = 14, max = -1;
        for(int i=0; i<numbers.length; i++){
            if(numbers[i]<0 || numbers[i]>13)
                return false;
            if(numbers[i]==0)
                continue;
            //重复出现
            if((flag & (1<<(numbers[i]-1))) !=0)
                return false;
            flag = flag | (1<<(numbers[i]-1));
            min = Math.min(min, numbers[i]);
            max = Math.max(max, numbers[i]);
        }
        //全零的情况也满足, 因为max初始值比min初始值小
        return max - min <= 4;
    }
}

第三次做, 使用了int[]记录数字出现的次数, 检查数字是否重复; 其实用bit map更方便! 更省空间; 没检查输入的合法性

public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers==null || numbers.length!=5)
            return false;
        int[] arr =new int[14];
        int min = 14, max = -1;
        for(int i=0; i<numbers.length; i++){
            if(numbers[i]==0)
                continue;
            arr[numbers[i]]++;
            if(arr[numbers[i]]==2)
                return false;
            min = Math.min(min, numbers[i]);
            max = Math.max(max, numbers[i]);
        }
        return min==14? true : (max - min <= 4);
    }
}

第二次做，重要：非零数字不能重复；if else的安排； 不使用HashSet而是使用Bit-Map思想:每一个bit表示一个数字，0表示对应数字没有出现过，1表示对应数字出现过

public class Solution {
    public boolean isContinuous(int [] numbers) {
        //input check
        if(numbers==null || numbers.length != 5)
            return false;
        //
        int max=0, min=14, zeroNum=0, bitMap=0;
        for(int i=0; i<numbers.length; i++){
            //检查输入的合理性
            if(numbers[i] < 0 || numbers[i] > 13)
                return false;
            if(numbers[i]==0){
                zeroNum++;
                continue;
            }
            //here, numbers[i] != 0
            //bit map
            if((bitMap & (1<<(numbers[i]-1))) == 1)
               return false;
            bitMap = (bitMap | (1<<(numbers[i]-1)));
            max = Math.max(max,numbers[i]);
            min = Math.min(min,numbers[i]);
        }
        return max - min + 1 <= numbers.length;
    }
}

第二次做，重要：非零数字不能重复； if else控制分支的安排

import java.util.HashSet;

public class Solution {
    public boolean isContinuous(int [] numbers) {
        //input check
        if(numbers == null || numbers.length!=5)
            return false;
        int zeroNum=0, max=0, min=14;
        HashSet<Integer> hs = new HashSet<>();
        for(int i=0; i<numbers.length; i++){
            //先检查输入是否正确
            if(numbers[i] < 0 || numbers[i] > 13)
                return false;
            else if(numbers[i] == 0){
                zeroNum++;
                continue;
            }
            //here, numbers[i] != 0
            if(hs.contains(numbers[i])) //除了0，其他数字都不能重复
                return false;
            //here, numbers[i] != 0 && hs不包含numbers[i]
            hs.add(numbers[i]);
            max = Math.max(max, numbers[i]);
            //最小值不考虑0
            min = Math.min(min, numbers[i]); 
        }
        // 最大值，最小值(不考虑0的最小值),以及非0元素个数这三者之间需要满足的不等式
        //return max - min + 1 - (numbers.length - zeroNum) <= zeroNum; 
        //将上式化简
        return max - min + 1 <= numbers.length;
    }
}

import java.util.Arrays;
public class Solution {
    public boolean isContinuous(int [] numbers) {
        /*
        思路:
            数组中 Sigma(arr[i+1]-arr[i]-1) 的结果大于0的个数就不是顺子; 小于0的个数就是顺子
            但是还要满足:除了0之外不能有对子
        */
        //input check
        if(numbers.length < 5)
            return false;
        //execute
        Arrays.sort(numbers);
        int zeroCount=0;
        int delta=0;
        for(int i=0; i<numbers.length-1; i++){
            if(numbers[i]==0)
                zeroCount++;
            else if(numbers[i] == numbers[i+1])
                return false;
            else // numbers[i] !=0 && numbers[i] != numbers[i+1]
                delta += numbers[i+1] - numbers[i] - 1;
        }
        return delta <= zeroCount;
    }
}

其他答案(使用哈希的思想判断是否重复)

如果说了这么多还没明白什么是Bit-map，那么我们来看一个具体的例子，假设我们要对0-7内的5个元素(4,7,2,5,3)排序（这里假设这些元素没有重复）。那么我们就可以采用Bit-map的方法来达到排序的目的。要表示8个数，我们就只需要8个Bit（1Bytes），首先我们开辟1Byte的空间，将这些空间的所有Bit位都置为0 然后遍历这5个元素，首先第一个元素是4，那么就把4对应的位置为1（可以这样操作 p+(i/8)|(0×01<<(i%8)) 当然了这里的操作涉及到Big-ending和Little-ending的情况，这里默认为Big-ending）,因为是从零开始的，所以要把第五位置为1。 然后再处理第二个元素7，将第八位置为1,，接着再处理第三个元素，一直到最后处理完所有的元素，将相应的位置为1。 然后我们现在遍历一遍Bit区域，将该位是一的位的编号输出（2，3，4，5，7），这样就达到了排序的目的。 其实就是把计数排序用的统计数组的每个单位缩小成bit级别的布尔数组