"找朋友"判断逻辑

规则如下:

1.牌与数值的映射关系如下:

数值 - 牌
3 - 3
4 - 4
…
10 - 10
11 - J
12 - Q
13 - K
14 - A
15 - 2
16 - 小王
17 - 大王
18 - 赖子

2.以下判断方法传入的参数必须是从 大到小排好序的数组

3.可以带任意张 赖子 牌 , 如果满足条件并且有多种可能,最终返回的是最大值

4. 如果传入的数组满足判断条件返回 该牌的最大值(可以用作与其他同类型牌作比较) , 否则返回false

例如:

	isShunZi([10,9,8,7,6,5])	//返回的是: 10
	isShunZi([18,18,9,8,7,6,5])	//返回的是:  11

ps:这里就大概写了顺子和连对的逻辑, 单张, 对子, 炸弹等逻辑比较简单就没有写了,

1) 判断是否顺子

//判断是否是顺子
function isShunZi(arr) {
      if (arr.length > 12) {  //不能超过12张牌(ps: 这里不限制最小5张 是为了给连对做判断)
        return false
      }
      var purePoker = []; //去掉赖子的牌
      for (let i = 0; i < arr.length; i++) {
        if (arr[i] != 18) {
          purePoker.push(arr[i]);
        }
      }

      //顺子不能带2
      if (purePoker[0] > 14) {
        return false;
      }

      var maxDistanceValue = arr.length - 1;     //最大差值
      var nowDistanceValue = purePoker[0] - purePoker[purePoker.length - 1];
      if (nowDistanceValue <= maxDistanceValue) {
        var n = []; //一个新的临时数组 
        var isStraight = true;  //是否是顺子
        for (var i = 0; i < purePoker.length; i++) {       //不能有重复的牌
          if (n.indexOf(purePoker[i]) == -1) {
            n.push(purePoker[i]);
          } else {
            isStraight = false;
            break;
          }
        }

        if (isStraight) {
          var value;//最大值
          if (nowDistanceValue == maxDistanceValue) {
            value = purePoker[0];
          } else {
            value = purePoker[purePoker.length - 1] + maxDistanceValue;
          }

          value = value > 14 ? 14 : value;
          return value;

        } else {
          return false;
        }
      } else {
        return false;
      }
}

2) 判断是否是连对

	 //计算癞子个数
    function getLaiZiCount(data) {
      var laiziCount = data.filter((v) => {
        return v == 18;
      })
      return laiziCount.length;
    }
    
    //是否是连对
    function isLianDui(arr) {
      if (arr.length % 2 != 0 || arr.length > 24 || arr.length < 4) {  //长度不能为奇数  并且不能超过24 小于4
        return false;
      }
      if (arr.length == 4 && getLaiZiCount(arr) == 2) { //有两个癞子 并且长度为4
        return false;
      }
      var purePoker = []; //去掉癞子的牌
      for (let i = 0; i < arr.length; i++) {
        if (arr[i] != 18) {
          purePoker.push(arr[i]);
        }
      }

      var pokerArr1 = []; //分割数组1
      var pokerArr2 = []; //分割数组2
      for (var i = 0; i < purePoker.length; i++) {     //不能有重复的牌
        if (pokerArr1.indexOf(purePoker[i]) == -1) {
          pokerArr1.push(purePoker[i]);
        } else {
          pokerArr2.push(purePoker[i]);
        }
      }

      if (pokerArr1.length > arr.length / 2) {
        return false;
      }

      while (pokerArr1.length < arr.length / 2) {
        pokerArr1.unshift(18);
      }
      while (pokerArr2.length < arr.length / 2) {
        pokerArr2.unshift(18);
      }
      var maxValue1 = isShunZi(pokerArr1);
      var maxValue2 = isShunZi(pokerArr2);

      if (maxValue1 && maxValue2) {
        var value = maxValue1 <= maxValue2 ? maxValue1 : maxValue2;
        return value;
      } else {
        return false;
      }
    }

最后还顺便贴一个 “跑得快” 的3带2 和飞机的判断逻辑(没有赖子)

	function getGroup(data, index = 0, group = []) {
      var need_apply = new Array();
      need_apply.push(data[index]);
      for (var i = 0; i < group.length; i++) {
        need_apply.push(group[i] +"_"+ data[index]);
      }
      group.push.apply(group, need_apply);

      if (index + 1 >= data.length) return group;
      else return getGroup(data, index + 1, group);
    }
    
	// 是否是3带2 和飞机
    function isPlane(array) {
      if (array[0] > 14) {//不能含有2
        return false;
      }
      var map = {}
      var arr3 = []
      var pokerLength = array.length;
      for (let index = 0; index < pokerLength; index++) {
        var poker = array[index];
        map[poker] ? map[poker]++ : map[poker] = 1;
      }
      for (const key in map) {  //统计每种牌的张数
        if (map[key] >= 3) {
          arr3.unshift(key)
        }
      }
      console.log(map, arr3);


      if (arr3.length == 0) {
        return false
      } else if (arr3.length == 1 && pokerLength == 5) { //3带2
        return arr3[0]
      }
      
      arr3 = arr3.map((v)=>{
        return String(v)
      })
      var groupArr = getGroup(arr3);//各种可能的组合
      console.log("groupArr", groupArr);
      var resultGroup = {}; //最终满足条件的组合
      for (var i = 0, len = groupArr.length; i < len; i++) {  //筛选组合
        const group = groupArr[i].split("_");
        if (isShunZi(group) && pokerLength - group.length * 3 == group.length * 2) {
          resultGroup[group[0]] = group.length;
        }
      }
      console.log("resultGroup", resultGroup);
      var resultGroupKeys = Object.keys(resultGroup)
      if (resultGroupKeys.length == 0) {
        return false
      } else {
        Array.prototype.max = function () {
          return Math.max.apply({}, this);
        }
        return resultGroupKeys.max()
      }
    }