finscn · August 29, 2015 13:57 · coswind · Mar 25, 2014 · coswind · Mar 25, 2014
diff --git a/checkSequence b/checkSequence
 /*

 检测 两组任意(不限个数 不限花色) 的扑克牌, 混到一起后能否构成任意长度(大于1 小于15)的顺子.
 A可表示1或14,小王可表示1--5,大王可表示1--14

 说明:
 1 我微博里说 小王代表 1到9有误, 我这边实际遇到的场景是 小王代表 1--5 (当然 这个无所谓)
 2 牌是可以有重复的 : 例如 可以 4个小王 9个大王 等等, 可以理解为是从无数副扑克牌当中随意抽取出两组
 3 组成的顺子 可以不是5张 , 其实严格说 就是 等差为1的等差数列
 4 能且只能组成一组顺子, 组成顺子后, 牌没有剩余

 */

 // cards 结构:  [ {point:牌面点数, num:对应数值}, .... ]

 function checkSequence(cards1, cards2) {

    var totalCount = cards1.length + cards2.length;
    //总牌数>14, 必然无法构成等差数列
    if (totalCount > 14) {
        return false;
    }

    var allCards = []; // 普通数字牌对应数组
    var countA = 0; // A数量
    var countRedJoker = 0; // 大王数量
    var countBlackJoker = 0; // 小王数量

    var _cards = cards1;
    while (true) {
        _cards.forEach(function(card) {
            // 记录 A 大王 小王的个数
            if (card.point == "A") {
                countA++;
            } else if (card.point == "RED_JOKER") {
                countRedJoker++;
            } else if (card.point == "BLACK_JOKER") {
                countBlackJoker++;
            } else {
                // 把普通数字牌混为一组
                allCards.push(card);
            }
        });
        if (_cards == cards2) {
            break;
        }
        _cards = cards2;
    }

    // A大于2个 或者 虽然A等于2个,但总牌数小于14, 则必然无法构成等差数列
    if (countA > 2 || countA == 2 && totalCount < 14) {
        return false
    }

    // 对普通数字牌排序
    allCards.sort(function(a, b) {
        return a.num - b.num;
    });

    var ANA, AN, NA;

    if (countA == 2) {
        //如果有两个A, 那么一个A当做1 放到最前面, 另一个A当做14, 放到后面
        ANA = [{
            point: "A",
            num: 1
        }].concat(allCards).concat([{
            point: "A",
            num: 14
        }]);
    } else if (countA == 1) {
        // 只有一个A 时, 把A放前面测一次, 放后面再测一次, 这样做代码上简单, 但是性能肯定不好
        AN = [{
            point: "A",
            num: 1
        }].concat(allCards);

        NA = [].concat(allCards).concat({
            point: "A",
            num: 14
        });
    }

    if (ANA) {
        return _checkQueue(ANA, countRedJoker, countBlackJoker);
    } else if (AN) {
        return _checkQueue(AN, countRedJoker, countBlackJoker) || _checkQueue(NA, countRedJoker, countBlackJoker);
    } else {
        return _checkQueue(allCards, countRedJoker, countBlackJoker);
    }


 }


 function _checkQueue(cardList, countRedJoker, countBlackJoker) {

    console.log(cardList)
    console.log(countRedJoker)
    console.log(countBlackJoker)

    // 小王代表的最大数
    var blackJokerMax = 5;

    var prevNum = cardList[0].num;
    for (var i = 1; i < cardList.length; ) {
        var currentNum = cardList[i].num;
        if (prevNum === currentNum) {
            // 有重复的牌, 不是等差数列
            return false;
        }
        var useJoker = false

        // 如果两张相邻牌的差不是1, 尝试用王补位
        if (prevNum + 1 != currentNum) {
            //blackJokerMax之后的, 用大王补位
            if (prevNum + 1 > blackJokerMax) {
                if (countRedJoker > 0) {
                    countRedJoker--;
                    useJoker = true;
                } else {
                    return false;
                }
            } else {
                //blackJokerMax或之前的, 有小王, 优先用小王补位
                if (countBlackJoker > 0) {
                    countBlackJoker--;
                    useJoker = true;
                } else if (countRedJoker > 0) {
                    //blackJokerMax或之前的, 没有小王 尝试用大王补位
                    countRedJoker--;
                    useJoker = true;
                } else {
                    // 没有王, 则无法构成等差数列
                    return false;
                }
            }
        }
        if (useJoker) {
            //如果用王补过位, 则做相应的处理
            prevNum += 1;
        } else {
            prevNum = currentNum;
            i++;
        }
    }

    var firstNum = cardList[0].num;
    var lastNum = cardList[cardList.length - 1].num;


    // 此时队列中间部分已经排列好, 剩余的小王只能往前分配, 大王可能往前 可能往后

    // 剩余小王数大于队列前端能分配的最大数量, 则不是等差数列
    if (countBlackJoker >= firstNum) {
        return false
    }

    // 如果有未分配的小王
    if (countBlackJoker > 0) {
        // 如果此时数列最小值>blackJokerMax+1, 则小王不能直接分配到数列前面,需要先用若干个大王来补位
        if (firstNum > blackJokerMax + 1) {
            //有大王 用大王补位,否则返回false
            if (countRedJoker >= firstNum - (blackJokerMax + 1)) {
                countRedJoker -= firstNum - (blackJokerMax + 1);
                firstNum = blackJokerMax + 1;
            } else {
                return false;
            }
        }

        // 分配所有剩余的小王 因为前面的一些预判断, 下面两行代码总是能得到预期结果的
        firstNum -= countBlackJoker;
        countBlackJoker = 0;
    }
    // 至此, 小王全部分配完毕


    // 如果有未分配的大王
    if (countRedJoker > 0) {
        // 优先尝试往后分配,且尽可能多的分配
        if (lastNum < 14) {
            countRedJoker -= (14 - lastNum);
        }
        // 如果还有未分配的 大王, 且队列前面已经装不下了, 返回false
        if (countRedJoker >= firstNum) {
            return false;
        }
        countRedJoker = 0;
    }

    //如果大小王都分配完毕, 则符合等差数列
    if (countBlackJoker == 0 && countRedJoker == 0) {
        return true;
    }
    return false;
 }


 ////////////////////////////////////
 ////////////////////////////////////
 ////////////////////////////////////
 ////////////////////////////////////

 // 以下为测试用例

 // 定义常量
 //    牌面点数 : 对应数值
 var Card = {
    "2": 2,
    "3": 3,
    "4": 4,
    "5": 5,
    "6": 6,
    "7": 7,
    "8": 8,
    "9": 9,
    "10": 10,
    "J": 11,
    "Q": 12,
    "K": 13,

    "A": null,
    "RED_JOKER": null,
    "BLACK_JOKER": null,
 };


 function test(c1, c2) {
    var cards1 = [],
        cards2 = [];
    c1.forEach(function(c) {
        cards1.push({
            point: c,
            num: Card[c]
        })
    });
    c2.forEach(function(c) {
        cards2.push({
            point: c,
            num: Card[c]
        })
    });
    console.log(checkSequence(cards1, cards2));
 }



 //  返回 true
 test([2, 9, "A", "RED_JOKER", "BLACK_JOKER"], ["RED_JOKER", "BLACK_JOKER", 3,8])

 //  返回 false
 test(["BLACK_JOKER", "BLACK_JOKER"], ["RED_JOKER", "RED_JOKER", 8, 9,10,"J","Q","A"])
	/*

	检测两组任意(不限个数不限花色) 的扑克牌, 混到一起后能否构成任意长度(大于1 小于15)的顺子.
	A可表示1或14,小王可表示1--5,大王可表示1--14

	说明:
	1 我微博里说小王代表 1到9有误, 我这边实际遇到的场景是小王代表 1--5 (当然这个无所谓)
	2 牌是可以有重复的 : 例如可以 4个小王 9个大王等等, 可以理解为是从无数副扑克牌当中随意抽取出两组
	3 组成的顺子可以不是5张 , 其实严格说就是等差为1的等差数列
	4 能且只能组成一组顺子, 组成顺子后, 牌没有剩余

	*/

	// cards 结构: [ {point:牌面点数, num:对应数值}, .... ]

	function checkSequence(cards1, cards2) {

	var totalCount = cards1.length + cards2.length;
	//总牌数>14, 必然无法构成等差数列
	if (totalCount > 14) {
	return false;
	}

	var allCards = []; // 普通数字牌对应数组
	var countA = 0; // A数量
	var countRedJoker = 0; // 大王数量
	var countBlackJoker = 0; // 小王数量

	var _cards = cards1;
	while (true) {
	_cards.forEach(function(card) {
	// 记录 A 大王小王的个数
	if (card.point == "A") {
	countA++;
	} else if (card.point == "RED_JOKER") {
	countRedJoker++;
	} else if (card.point == "BLACK_JOKER") {
	countBlackJoker++;
	} else {
	// 把普通数字牌混为一组
	allCards.push(card);
	}
	});
	if (_cards == cards2) {
	break;
	}
	_cards = cards2;
	}

	// A大于2个或者虽然A等于2个,但总牌数小于14, 则必然无法构成等差数列
	if (countA > 2 \|\| countA == 2 && totalCount < 14) {
	return false
	}

	// 对普通数字牌排序
	allCards.sort(function(a, b) {
	return a.num - b.num;
	});

	var ANA, AN, NA;

	if (countA == 2) {
	//如果有两个A, 那么一个A当做1 放到最前面, 另一个A当做14, 放到后面
	ANA = [{
	point: "A",
	num: 1
	}].concat(allCards).concat([{
	point: "A",
	num: 14
	}]);
	} else if (countA == 1) {
	// 只有一个A 时, 把A放前面测一次, 放后面再测一次, 这样做代码上简单, 但是性能肯定不好
	AN = [{
	point: "A",
	num: 1
	}].concat(allCards);

	NA = [].concat(allCards).concat({
	point: "A",
	num: 14
	});
	}

	if (ANA) {
	return _checkQueue(ANA, countRedJoker, countBlackJoker);
	} else if (AN) {
	return _checkQueue(AN, countRedJoker, countBlackJoker) \|\| _checkQueue(NA, countRedJoker, countBlackJoker);
	} else {
	return _checkQueue(allCards, countRedJoker, countBlackJoker);
	}


	}


	function _checkQueue(cardList, countRedJoker, countBlackJoker) {

	console.log(cardList)
	console.log(countRedJoker)
	console.log(countBlackJoker)

	// 小王代表的最大数
	var blackJokerMax = 5;

	var prevNum = cardList[0].num;
	for (var i = 1; i < cardList.length; ) {
	var currentNum = cardList[i].num;
	if (prevNum === currentNum) {
	// 有重复的牌, 不是等差数列
	return false;
	}
	var useJoker = false

	// 如果两张相邻牌的差不是1, 尝试用王补位
	if (prevNum + 1 != currentNum) {
	//blackJokerMax之后的, 用大王补位
	if (prevNum + 1 > blackJokerMax) {
	if (countRedJoker > 0) {
	countRedJoker--;
	useJoker = true;
	} else {
	return false;
	}
	} else {
	//blackJokerMax或之前的, 有小王, 优先用小王补位
	if (countBlackJoker > 0) {
	countBlackJoker--;
	useJoker = true;
	} else if (countRedJoker > 0) {
	//blackJokerMax或之前的, 没有小王尝试用大王补位
	countRedJoker--;
	useJoker = true;
	} else {
	// 没有王, 则无法构成等差数列
	return false;
	}
	}
	}
	if (useJoker) {
	//如果用王补过位, 则做相应的处理
	prevNum += 1;
	} else {
	prevNum = currentNum;
	i++;
	}
	}

	var firstNum = cardList[0].num;
	var lastNum = cardList[cardList.length - 1].num;


	// 此时队列中间部分已经排列好, 剩余的小王只能往前分配, 大王可能往前可能往后

	// 剩余小王数大于队列前端能分配的最大数量, 则不是等差数列
	if (countBlackJoker >= firstNum) {
	return false
	}

	// 如果有未分配的小王
	if (countBlackJoker > 0) {
	// 如果此时数列最小值>blackJokerMax+1, 则小王不能直接分配到数列前面,需要先用若干个大王来补位
	if (firstNum > blackJokerMax + 1) {
	//有大王用大王补位,否则返回false
	if (countRedJoker >= firstNum - (blackJokerMax + 1)) {
	countRedJoker -= firstNum - (blackJokerMax + 1);
	firstNum = blackJokerMax + 1;
	} else {
	return false;
	}
	}

	// 分配所有剩余的小王因为前面的一些预判断, 下面两行代码总是能得到预期结果的
	firstNum -= countBlackJoker;
	countBlackJoker = 0;
	}
	// 至此, 小王全部分配完毕


	// 如果有未分配的大王
	if (countRedJoker > 0) {
	// 优先尝试往后分配,且尽可能多的分配
	if (lastNum < 14) {
	countRedJoker -= (14 - lastNum);
	}
	// 如果还有未分配的大王, 且队列前面已经装不下了, 返回false
	if (countRedJoker >= firstNum) {
	return false;
	}
	countRedJoker = 0;
	}

	//如果大小王都分配完毕, 则符合等差数列
	if (countBlackJoker == 0 && countRedJoker == 0) {
	return true;
	}
	return false;
	}


	////////////////////////////////////
	////////////////////////////////////
	////////////////////////////////////
	////////////////////////////////////

	// 以下为测试用例

	// 定义常量
	// 牌面点数 : 对应数值
	var Card = {
	"2": 2,
	"3": 3,
	"4": 4,
	"5": 5,
	"6": 6,
	"7": 7,
	"8": 8,
	"9": 9,
	"10": 10,
	"J": 11,
	"Q": 12,
	"K": 13,

	"A": null,
	"RED_JOKER": null,
	"BLACK_JOKER": null,
	};


	function test(c1, c2) {
	var cards1 = [],
	cards2 = [];
	c1.forEach(function(c) {
	cards1.push({
	point: c,
	num: Card[c]
	})
	});
	c2.forEach(function(c) {
	cards2.push({
	point: c,
	num: Card[c]
	})
	});
	console.log(checkSequence(cards1, cards2));
	}



	// 返回 true
	test([2, 9, "A", "RED_JOKER", "BLACK_JOKER"], ["RED_JOKER", "BLACK_JOKER", 3,8])

	// 返回 false
	test(["BLACK_JOKER", "BLACK_JOKER"], ["RED_JOKER", "RED_JOKER", 8, 9,10,"J","Q","A"])