判断牌类型

原创 2016年06月01日 02:43:21
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
using namespace std;

#define CREATEVARIABLE(Type, Name)\
protected:\
    Type Name;\
public:\
    void set##Name(Type value){\
        Name = value;\
    }\
    Type get##Name()const{\
        return Name;\
    }

struct CardsTypeCount {
    int One;
    int Two;
    int Three;
    int Four;
    vector<int> OneArray;
    vector<int> TwoArray;
    vector<int> ThreeArray;
    vector<int> FourArray;
};
class Cards
{
    CREATEVARIABLE(vector<int>, obj1)
        CREATEVARIABLE(vector<int>, obj2)
        CREATEVARIABLE(vector<int>, obj3)

    enum CARDSTYPE {
        TypeError = 0,
        Single,	                //1
        DanShunzi,		//单顺    1*n(n>=5)
        Double,			//2
        Rocket,			//火箭    双王
        DoubleShunZi,		//双顺    2*n(n>=3)
        Three,			//3
        ThreeBandOne,		//3+1
        ThreeBandTwo,		//3+2
        ThreeShunZi,	        //三顺    3*n(n>=2)
        AircraftWithWingsOne,	//3*n+n
        AircraftWithWingsTwo,   //3*n+2*n(n>=2)
        Bomb,			//炸弹    4*1
        FourBandOne,		//4+1
        FourBandTwo		//4+2*2
    };
public:
    void shuffleCards();
    CARDSTYPE judge( vector<int> &data);
    vector<int> sort(vector<int> &data);

public:
    CardsTypeCount identical(const vector<int> &data);
    CARDSTYPE switchOne(const vector<int> &data, const CardsTypeCount &TypeCount);
    CARDSTYPE switchTwo(const vector<int> &data, const CardsTypeCount &TypeCount);
    CARDSTYPE switchThree(const vector<int> &data, const CardsTypeCount &TypeCount);
    CARDSTYPE switchFour(const vector<int> &data, const CardsTypeCount &TypeCount);
    void put(vector<int>&data,int count);
};

void Cards::shuffleCards()
{
    vector<int> init;
    for (int i = 0; i < 54; i++)
        init.push_back(i);

    random_shuffle(init.begin(), init.end());
    for(int i=0;i<13;i++)
        cout <<setw(3)<<i+3;

    for(int i=0;i<54;i++)
    {
        if(!(i%13))
            cout <<endl<<endl;
        cout << setw(3)<<i;

    }
cout <<endl<<endl;
    obj1.clear();
    obj2.clear();
    obj3.clear();
    for (int i = 0; i < 17; i++)
        obj1.push_back(init[i]);
    for (int i = 17; i < 34; i++)
        obj2.push_back(init[i]);
    for (int i = 34; i < 51; i++)
        obj3.push_back(init[i]);
}

Cards::CARDSTYPE Cards::judge( vector<int> &data)
{
    CARDSTYPE Type = CARDSTYPE::TypeError;
    const CardsTypeCount &TypeCount = identical(data);
    int Count;
    if (TypeCount.OneArray.size() ? data[0] == TypeCount.OneArray[0] : 0)
        Count = 1;
    else if (TypeCount.TwoArray.size() ? data[0] == TypeCount.TwoArray[0] : 0)
        Count = 2;
    else if (TypeCount.ThreeArray.size() ? data[0] == TypeCount.ThreeArray[0] : 0)
        Count = 3;
    else if(TypeCount.FourArray.size() ? data[0] == TypeCount.FourArray[0] : 0)
        Count = 4;

    const vector<int>&Tmp = sort(data);

    switch (Count)
    {
    case 1:Type = switchOne(Tmp, TypeCount); break;
    case 2:Type = switchTwo(Tmp, TypeCount); break;
    case 3:Type = switchThree(Tmp, TypeCount); break;
    case 4:Type = switchFour(Tmp, TypeCount);
    }
    return Type;
}

vector<int> Cards::sort(vector<int>& data)
{
    int Array[4][15] = {0};
    for (int i = 0; i < data.size(); i++)
    {
        if ((data[i] == 52) || (data[i] == 53))
        {
            if(data[i] == 52)
            Array[0][13] = 52;
            else
                Array[0][14] = 53;
            continue;
        }
        for (int j = 0; j < 4; j++)
            if (Array[j][data[i]%13] == 0)
            {
                Array[j][data[i]%13] = data[i];
                break;
            }
    }
    data.clear();
    vector<int>Return;
    for (int i = 3; i >= 0;i--)
    {
        for (int j = 14; j >= 0; j--)
        {
            if (Array[i][j] != 0)
            {
                for (int k = i; k >= 0; k--)
                {
                    data.push_back(Array[k][j]);
                    Return.push_back(Array[k][j] % 13);
                    Array[k][j] = 0;
                }
            }
        }
    }
    return Return;
}

CardsTypeCount Cards::identical(const vector<int>& data)
{
    vector<int>Count;
    vector<int>Type;
    bool off;
    for (auto value : data)
    {
        off = true;
        for (int i = 0; i < Type.size();i++)
        {
            if (value == Type[i])
            {
                Count[i]++;
                off = false;
            }
        }
        if (off)
        {
            Type.push_back(value);
            Count.push_back(1);
        }
    }

    CardsTypeCount TypeCount;
    TypeCount.One = TypeCount.Two = TypeCount.Three = TypeCount.Four = 0;

    for (int i = 0; i < Type.size();i++)
    {
        switch (Count[i])
        {
        case 1:
            TypeCount.One++;
            TypeCount.OneArray.push_back(Type[i]);	break;
        case 2:
            TypeCount.Two++;
            TypeCount.TwoArray.push_back(Type[i]);	break;
        case 3:
            TypeCount.Three++;
            TypeCount.ThreeArray.push_back(Type[i]);	break;
        case 4:
            TypeCount.Four++;
            TypeCount.FourArray.push_back(Type[i]);
        }
    }
    return TypeCount;
}

Cards::CARDSTYPE Cards::switchOne(const vector<int> &data, const CardsTypeCount &TypeCount)
{
    const int &Size = data.size();
    if (Size == 1)
        return CARDSTYPE::Single;
    else if ((Size == 2) && (data[0] == 53) && (data[1] == 52))
        return CARDSTYPE::Rocket;
    else if(Size >=5 )
    {
        for (int i = 0; i < Size-1; i++)
        {
            if (data[i] - 1 != data[i + 1])
                break;
            else
            {
                if (i == Size - 2)
                    return CARDSTYPE::DanShunzi;
            }
        }
    }
    return CARDSTYPE::TypeError;
}

Cards::CARDSTYPE Cards::switchTwo(const vector<int> &data, const CardsTypeCount &TypeCount)
{
    const int &Size = data.size();
    if(!(Size%2))
    {
        if (Size == 2)
            return CARDSTYPE::Double;
        else if (Size >=6)
            if(TypeCount.Two == Size / 2.0)
                return CARDSTYPE::DoubleShunZi;
    }

    return CARDSTYPE::TypeError;
}

Cards::CARDSTYPE Cards::switchThree(const vector<int> &data, const CardsTypeCount &TypeCount)
{
    const int &Size = data.size();
    if (Size == 3)
        return CARDSTYPE::Three;
    else if (Size == 4)
        return CARDSTYPE::ThreeBandOne;
    else if ((TypeCount.Three == 1) && (TypeCount.Two == 1))
        return CARDSTYPE::ThreeBandTwo;
    else if (Size >= 6)
    {
        if (TypeCount.Three == Size / 3.0)
            return CARDSTYPE::ThreeShunZi;
        else if (TypeCount.Three == TypeCount.One)
            return CARDSTYPE::AircraftWithWingsOne;
        else if (TypeCount.Three == TypeCount.Two)
            return CARDSTYPE::AircraftWithWingsTwo;
    }
    return CARDSTYPE::TypeError;
}

Cards::CARDSTYPE Cards::switchFour(const vector<int> &data, const CardsTypeCount &TypeCount)
{
    const int &Size = data.size();
    switch (Size)
    {
    case 4:
        return CARDSTYPE::Bomb;
    case 5:
        return CARDSTYPE::FourBandOne;
    case 6:
        if (TypeCount.Two == 1)
            return CARDSTYPE::FourBandTwo;
    }

    return CARDSTYPE::TypeError;
}

void Cards::put(vector<int>& data, int count)
{
    cout << endl << "count:" << count << endl;
    for (auto value : data)
        cout << setw(3) << value;
}

int main()
{
    Cards cards;
    srand(unsigned(time(nullptr)));
    while(1)
    {
        cards.shuffleCards();
        for (auto value : cards.getobj1())
        {
            cout << setw(3) << value;
        }
        cout << endl << endl;
        cards.sort(cards.getobj1());
        getchar();
    }

    return 0;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

斗地主系列之牌型判断

参考资料: 1.
  • hfreeman2008
  • hfreeman2008
  • 2014年07月13日 16:15
  • 2969

斗地主判断牌型源码

这是看着别人的代码写的,这样写虽然很全面,但是毫无条理,我吧牌型打完之后感觉很不好,所以放弃,我给每一段加了注释,贴出代码让大家看一看 using UnityEngine; using S...
  • w36371
  • w36371
  • 2016年11月21日 15:28
  • 1074

麻将胡牌算法

用数字代替麻将中的所有牌: 一万~九万    1~9 一筒~九筒    11~19 一条~九条    21~29 东、南、西、北、中、发、白    31~37 胡牌的种类:对对胡、十三幺和33332...
  • qq_22026331
  • qq_22026331
  • 2017年01月10日 09:14
  • 5282

剑指Offer——从扑克中抽五张牌,判断是否是连续的五张

主要思路: 把大小王视为0,先排序,排完之后,统计其中0的个数,和排序后每两个数之间间隔的和,比较和与0的个数,如果相等则认为是连续的(大小王可视为任何一张牌),所以间隔减去大小王的数就等于,无法连...
  • zhang2531
  • zhang2531
  • 2016年04月08日 10:00
  • 637

五张牌的牌型比较,其实一百多行的代码就够了。

牌型分为9种, 杂牌,一对,两对,三条,顺子,同花,葫芦,四条,同花顺。 判断五张牌的牌型,其实代码页很简单,不需要很复杂。 #include #include #include #includ...
  • abcd1236386
  • abcd1236386
  • 2013年12月26日 09:55
  • 1373

地主算法之判断牌型

每个游戏都有属于自己的规则,当然地主也不例外,常斗地主的朋友可能知道在斗地主里面一共有13种牌型,你所出的牌必须符合13种的一种才能够出得了牌,这个就叫地主的规则。那么我们下面可以通过一个枚举结构来表...
  • u014466630
  • u014466630
  • 2014年05月09日 10:13
  • 439

麻将432牌型听牌判断流程图

麻将432牌型听牌判断流程图
  • IamNot
  • IamNot
  • 2015年09月15日 14:46
  • 1640

麻将胡牌判定的判定算法

麻将胡牌判定的判定算法 问题背景 : 简化了麻将规则,给定[1s-9s],[1b-9b],[1t-9t]一共27种牌,每种牌都有4张。需要判断给定的牌是不是胡牌。 胡牌的定义为: 1...
  • pp634077956
  • pp634077956
  • 2018年01月13日 23:39
  • 65

判断5张扑克牌的组成

一副牌中发五张扑克牌给你,让你判断数字的组成: 有以下几种情况: 1:四条:即四张一样数值的牌(牌均不论花色) 2:三条带一对 3:三条带两张不相同数值的牌 4:两对 5:顺子(包括10,...
  • hs794502825
  • hs794502825
  • 2014年07月22日 10:43
  • 3509

斗地主检测牌型(玩家)

BRANDSTATUS JudgeVOwn()//检测牌型是否合法可出 { List vTemp = SelectedCard;//选择的牌 Sort(vTemp,false);//排序 ...
  • OnInit
  • OnInit
  • 2015年11月20日 22:28
  • 973
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:判断牌类型
举报原因:
原因补充:

(最多只允许输入30个字)