该算法通过计算需要的万能牌个数，和已经拥有的万能牌个数对比来判断是否胡牌，算法通用，且效率高，计算胡牌算法每秒钟可以运行三百万次以上。

1. 所有合法牌：

0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09  万
0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19  条
0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29  筒
0x31 0x32 0x33 0x34 0x35 0x36 0x37            东西南北中发白

2. 核心算法

将万、条、筒、风各种花色分开，然后分别计算每种花色构成整扑（整扑即三张相同牌或者顺子）还需要多少张万能牌。如：0x01、0x01、0x02、0x03、0x04
构成整扑需要一张万能牌， 0x01、0x03、0x05、0x07构成整扑需要两张万能牌。

计算整扑按照从小到大的顺序一次计算。

首先检查是否是刻子（三张相同的牌）。

然后检测检查是否是对子。

如果是对子，检测它是否符合A2BxCy，xyz为张数，

如果x>0,y>1或者x>1,y>0，则分别检测A成对子和A成顺子需要的万能牌张数。否则，则A组合成对子来计算。

如果是单张牌，则检测其是否可以与后面的牌组合成顺子，如果不能则检测是否能组合成吃牌，例如一万二万，一万三万这种组合，如果还是不能，就是一张单独的牌。

风牌判断比较简单，这里就不赘述了。

计算完成后，依次遍历将牌在万，条，筒，风的情况下，它们构成整扑加将需要的万能牌个数，然后对比拥有的万能牌个数，便可以得出是否可以胡牌。

3. 逻辑代码

判断字牌（万，条，筒）组合成整扑需要的万能牌个数。

func SwitchCardToIndex(card uint8) uint8 {
    return 9 * (card / 16) + card % 16 - 1
}
func SwitchCardsToIndexList(cards []uint8) []uint8 {
    indexList := make([]uint8, 34)
    for _, card := range cards {
        index := SwitchCardToIndex(card)
        indexList[index] ++
    }
    return indexList
}
func CheckZiPaiZhengPu(cardsIndex []uint8) int {
    tmpCardsIndex := cardsIndex
    needMagicNum := 0
    curPos := 0
    for curPos < len(tmpCardsIndex){
        if tmpCardsIndex[curPos] >= 3 {
            tmpCardsIndex[curPos] -= 3
        } else if tmpCardsIndex[curPos] == 2 {
            if tmpCardsIndex[curPos+1] > 0 && tmpCardsIndex[curPos+2] > 0 && (tmpCardsIndex[curPos+1]>1 || tmpCardsIndex[curPos+2]>1){
                shunCardsIndex := make([]uint8, len(tmpCardsIndex))
                copy(shunCardsIndex, tmpCardsIndex)
                shunCardsIndex[curPos] --
                shunCardsIndex[curPos+1] --
                shunCardsIndex[curPos+2] --
                shunNeedNum := CheckZiPaiZhengPu(shunCardsIndex)
                duiCardsIndex := tmpCardsIndex
                duiCardsIndex[curPos] -= 2
                duiNeedNum := CheckZiPaiZhengPu(duiCardsIndex) + 1
                if duiNeedNum > shunNeedNum {
                    return shunNeedNum + needMagicNum
                }
                return duiNeedNum + needMagicNum
            } else {
                needMagicNum ++
                tmpCardsIndex[curPos] -= 2
            }
        } else if tmpCardsIndex[curPos] == 1{
            if tmpCardsIndex[curPos+1] >= 1 && tmpCardsIndex[curPos+2] >= 1 {
                tmpCardsIndex[curPos] --
                tmpCardsIndex[curPos+1] --
                tmpCardsIndex[curPos+2] --
            } else if tmpCardsIndex[curPos+1] >= 1 {
                needMagicNum ++
                tmpCardsIndex[curPos] --
                tmpCardsIndex[curPos+1] --
            } else if tmpCardsIndex[curPos+2] >= 1 {
                needMagicNum ++
                tmpCardsIndex[curPos] --
                tmpCardsIndex[curPos+2] --
            } else {
                needMagicNum += 2
                tmpCardsIndex[curPos] --
            }
        } else {
            curPos ++
        }
    }
    return needMagicNum
}

判断（万，条，筒）组合成整扑需要的万能牌个数。

func CheckFengPaiZhengPu(cardsIndex []uint8) int {
    tmpCardsIndex := cardsIndex
    needMagicNum := 0
    curPos := 0
    for curPos < 7{
        if tmpCardsIndex[curPos] >= 3 {
            tmpCardsIndex[curPos] -= 3
        } else if tmpCardsIndex[curPos] == 2 {
            needMagicNum ++
            tmpCardsIndex[curPos] -= 2
        } else if tmpCardsIndex[curPos] == 1{
            needMagicNum += 2
            tmpCardsIndex[curPos] --
        } else {
            curPos ++
        }
    }
    return needMagicNum
}

检测是否可以胡牌

func CanHuPai(handCardIndex []uint8, magicCard uint8) bool {
    magicIndex := SwitchCardToIndex(magicCard)
    tmpCardIndex := make([]uint8, len(handCardIndex))
    copy(tmpCardIndex, handCardIndex)
    magickNum := tmpCardIndex[magicIndex]
    if magickNum >= 3 {
        return true
    }
    tmpCardIndex[magicIndex] = 0
    tmpIndexList := make([]uint8, 11)
    //分析万,条，筒
    //ziPaiType := []string{"万", "条", "筒"}
    ziPaiNeedMagicNums := make([]int, 3)
    for i:=0; i<3; i++ {
        copy(tmpIndexList, tmpCardIndex[i*9:(i+1)*9])
        tmpResult := CheckZiPaiZhengPu(tmpIndexList)
        ziPaiNeedMagicNums[i] = tmpResult
    }
    //分析风
    copy(tmpIndexList, tmpCardIndex[27:34])
    fengPaiNeedMagicNum := CheckFengPaiZhengPu(tmpIndexList)
    //jiangType := []string{"万", "条", "筒"}
    totalNeedMagick := ziPaiNeedMagicNums[0] + ziPaiNeedMagicNums[1] + ziPaiNeedMagicNums[2] + fengPaiNeedMagicNum
    //所有牌都可以成整朴，将必定在财神牌上
    if int(magickNum) - totalNeedMagick >= 0 {
        //fmt.Println("将在------",jiangType[ziPaiType])
        return true
    }
    //将在万,条，筒中
    for ziPaiType:=0; ziPaiType<3; ziPaiType++{
        leftMagicNum := int(magickNum) + ziPaiNeedMagicNums[ziPaiType] - totalNeedMagick
        if leftMagicNum >= 0 {
            for eyeIndex:=0; eyeIndex<9; eyeIndex ++ {
                copy(tmpIndexList, tmpCardIndex[ziPaiType * 9:(ziPaiType+1) * 9])
                if tmpIndexList[eyeIndex] >= 2 {
                    tmpIndexList[eyeIndex] -= 2
                    tmpNeedMagic := CheckZiPaiZhengPu(tmpIndexList)
                    if leftMagicNum >= tmpNeedMagic {
                        return true
                    }
                } else if tmpIndexList[eyeIndex] == 1 && leftMagicNum > 0{
                    tmpNeedMagic := 1
                    tmpIndexList[eyeIndex] --
                    tmpNeedMagic += CheckFengPaiZhengPu(tmpIndexList)
                    if leftMagicNum >= tmpNeedMagic {
                        return true
                    }
                }
            }
        }
    }
    //将在风中
    leftMagicNum := int(magickNum) + fengPaiNeedMagicNum - totalNeedMagick
    if leftMagicNum >= 0 {
        for eyeIndex:=0; eyeIndex<7; eyeIndex ++ {
            copy(tmpIndexList, tmpCardIndex[27:34])
            if tmpIndexList[eyeIndex] >= 2 {
                tmpIndexList[eyeIndex] -= 2
                tmpNeedMagic := CheckZiPaiZhengPu(tmpIndexList)
                if leftMagicNum >= tmpNeedMagic {
                    return true
                }
            } else if tmpIndexList[eyeIndex] == 1 && leftMagicNum > 0{
                tmpNeedMagic := 1
                tmpIndexList[eyeIndex] --
                tmpNeedMagic += CheckFengPaiZhengPu(tmpIndexList)
                if leftMagicNum >= tmpNeedMagic {
                    return true
                }
            }
        }
    }
    return false
}

4. 测试代码

func main() {
    if err:=recover(); err != nil {
        fmt.Println(err)
    }
    //cardsIndex := SwitchCardsToIndexList([]uint8{0x11,0x17,0x12,0x11,0x17,0x12,0x13,0x13,0x21,0x21,0x22,0x22,0x22,0x23,0x23,0x26,0x26})
    //cardsIndex := SwitchCardsToIndexList([]uint8{0x12,0x12,0x13,0x13,0x13,0x14,0x15,0x16,0x02,0x02,0x03,0x03,0x03,0x04,0x05,0x06,0x26,0x26})
    cardsIndex := SwitchCardsToIndexList([]uint8{0x11,0x11,0x12,0x13,0x13,0x22,0x22,0x23,0x24,0x26,0x26})
    isHu := CanHuPai(cardsIndex, 0x26)
    fmt.Println(isHu)
}

5. 说明

转载自 https://www.jianshu.com/p/5b824a50c1b8