Project Euler 54 Poker hands(模拟+hash)

最新推荐文章于 2019-02-18 17:36:00 发布
最新推荐文章于 2019-02-18 17:36:00 发布
阅读量779 收藏
点赞数
分类专栏： ACM/Algorithms
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/michaelalan/article/details/8543265
版权

超级传送门：http://projecteuler.net/problem=54

 

刚看到题目描述，就联想到天津Regional的A题麻将那题，可惜没能AC，遗憾了好久。

这题比麻将那题要简单一些，规则描述比较清楚，要比较两手梭哈牌的大小，我用了hash来存牌，定义了各种判定判断函数来进行判断。

代码量还是比较大的，差不多600行，写的过程中很容易错。Unix/Linux设计思想——小即是美、每个函数的功能尽可能简单的专一，用这种设计思想来写，就不容易出错了。

 

代码如下：

#include <cstdio>
#include <cstring>

#define COLOR_H 0
#define COLOR_C 1
#define COLOR_S 2
#define COLOR_D 3

using namespace std;

char PACards[5][3];
char PBCards[5][3];
int PAHash[4][13];
int PBHash[4][13];

inline int calcPokerIndex(char card)
{
    if (card >= '2' && card <= '9')
        return card - '2';
    if (card == 'T')
        return 8;
    if (card == 'J')
        return 9;
    if (card == 'Q')
        return 10;
    if (card == 'K')
        return 11;
    if (card == 'A')
        return 12;
}

void doHash(char cards[5][3], int hash[4][13])
{
    memset(hash, 0, sizeof(int) * 4 * 13);

    for (int i = 0; i <= 4; i++)
    {
        int pokerIndex = calcPokerIndex(cards[i][0]);

        switch (cards[i][1])
        {
            case 'H':
                hash[COLOR_H][pokerIndex] = 1;
                break;
            case 'C':
                hash[COLOR_C][pokerIndex] = 1;
                break;
            case 'S':
                hash[COLOR_S][pokerIndex] = 1;
                break;
            case 'D':
                hash[COLOR_D][pokerIndex] = 1;
                break;
            default:
                break;
        }
    }
}

int getMaxPoker(int hash[4][13], int which)
{
    int cnt = 0;
    int tmpHash[13];
    memset(tmpHash, 0, sizeof(tmpHash));

    for (int i = 0; i <= 3; i++)
    {
        for (int j = 0; j <= 12; j++)
        {
            if (hash[i][j])
                tmpHash[j]++;
        }
    }

    for (int i = 12; i >= 0; i--)
    {
        while (tmpHash[i])
        {
            tmpHash[i]--;
            cnt++;
            if (cnt == which)
                return i;
        }
    }
}

int isOnePair(int hash[4][13])
{
    int count = 0;
    int pairCount = 0;
    int firstPairVal = 0;

    for (int j = 0; j <= 12; j++)
    {
        count = 0;
        for (int i = 0; i <= 3; i++)
        {
            if (hash[i][j])
                count++;
        }
        if (count == 2)
        {
            pairCount++;
            firstPairVal = j;
        }
    }

    if (pairCount == 1)
        return firstPairVal;

    return -1;
}

int isTwoPairs(int hash[4][13])
{
    int count = 0;
    int pairCount = 0;
    int firstPairVal = 0;
    int secondPairVal = 0;

    for (int j = 0; j <= 12; j++)
    {
        count = 0;
        for (int i = 0; i <= 3; i++)
        {
            if (hash[i][j])
                count++;
        }
        if (count == 2)
        {
            pairCount++;
            if (pairCount == 1)
                firstPairVal = j;
            else
                secondPairVal = j;
        }
    }

    if (pairCount == 2)
        return 13 * secondPairVal + firstPairVal;

    return -1;
}

int isThreeOfAKind(int hash[4][13])
{
    int count = 0;

    for (int j = 0; j <= 12; j++)
    {
        count = 0;
        for (int i = 0; i <= 3; i++)
        {
            if (hash[i][j])
                count++;
        }
        if (count == 3)
            return j;
    }
    return -1;
}

int isStraight(int hash[4][13])
{
    int tmpHash[13];
    memset(tmpHash, 0, sizeof(tmpHash));

    for (int i = 0; i <= 3; i++)
    {
        for (int j = 0; j <= 12; j++)
        {
            if (hash[i][j])
                tmpHash[j]++;
        }
    }

    for (int i = 0; i <= 8; i++)
    {
        if (tmpHash[i] && tmpHash[i + 1] && tmpHash[i + 2] && tmpHash[i + 3] && tmpHash[i + 4])
            return i + 4;
    }

    return -1;
}

int isFlush(int hash[4][13])
{
    int count = 0;

    for (int i = 0; i <= 3; i++)
    {
        count = 0;
        for (int j = 0; j <= 12; j++)
        {
            if (hash[i][j])
                count++;
        }
        if (count == 5)
            return 1;
    }
    return -1;
}

int isFullHouse(int hash[4][13])
{
    int count = 0;
    int pairVal = -1;
    int threeVal = -1;

    for (int j = 0; j <= 12; j++)
    {
        count = 0;
        for (int i = 0; i <= 3; i++)
        {
            if (hash[i][j])
                count++;
        }

        if (count == 2)
            pairVal = j;
        if (count == 3)
            threeVal = j;
    }

    if (pairVal == -1 || threeVal == -1)
        return -1;

    return 13 * threeVal + pairVal;
}

int isFourOfAKind(int hash[4][13])
{
    int count = 0;

    for (int j = 0; j <= 12; j++)
    {
        count = 0;
        for (int i = 0; i <= 3; i++)
        {
            if (hash[i][j])
                count++;
        }
        if (count == 4)
            return j;
    }
    return -1;
}

int isStraightFlush(int hash[4][13])
{
    for (int i = 0; i <= 3; i++)
    {
        for (int j = 0; j <= 8; j++)
        {
            if (hash[i][j] && hash[i][j + 1] && hash[i][j + 2] && hash[i][j + 3] && hash[i][j + 4])
                return j + 4;
        }
    }
    return -1;
}

int isRoyalFlush(int hash[4][13])
{
    for (int i = 0; i <= 3; i++)
    {
        if (hash[i][8] && hash[i][9] && hash[i][10] && hash[i][11] && hash[i][12])
            return 1;
    }
    return -1;
}

int checkDefault(int PAHash[4][13], int PBHash[4][13])
{
    for (int i = 1; i <= 5; i++)
    {
        int PAPokerVal = getMaxPoker(PAHash, i);
        int PBPokerVal = getMaxPoker(PBHash, i);

        if (PAPokerVal != PBPokerVal)
            return PAPokerVal > PBPokerVal;
    }
}

int checkOnePair(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isOnePair(PAHash);
    PBRetVal = isOnePair(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    if (PARetVal != -1 && PBRetVal != -1)
    {
        if (PARetVal != PBRetVal)
            return PARetVal > PBRetVal;

        for (int i = 1; i <= 5; i++)
        {
            int PAPokerVal = getMaxPoker(PAHash, i);
            int PBPokerVal = getMaxPoker(PBHash, i);

            if (PAPokerVal != PBPokerVal)
                return PAPokerVal > PBPokerVal;
        }
    }

    return -1;
}

int checkTwoPairs(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isTwoPairs(PAHash);
    PBRetVal = isTwoPairs(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    if (PARetVal != -1 && PBRetVal != -1)
    {
        if (PARetVal != PBRetVal)
            return PARetVal > PBRetVal;

        for (int i = 1; i <= 5; i++)
        {
            int PAPokerVal = getMaxPoker(PAHash, i);
            int PBPokerVal = getMaxPoker(PBHash, i);

            if (PAPokerVal != PBPokerVal)
                return PAPokerVal > PBPokerVal;
        }
    }

    return -1;
}

int checkThreeOfAKind(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isThreeOfAKind(PAHash);
    PBRetVal = isThreeOfAKind(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    if (PARetVal != -1 && PBRetVal != -1)
    {
        if (PARetVal != PBRetVal)
            return PARetVal > PBRetVal;

        for (int i = 1; i <= 5; i++)
        {
            int PAPokerVal = getMaxPoker(PAHash, i);
            int PBPokerVal = getMaxPoker(PBHash, i);

            if (PAPokerVal != PBPokerVal)
                return PAPokerVal > PBPokerVal;
        }
    }

    return -1;
}

int checkStraight(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isStraight(PAHash);
    PBRetVal = isStraight(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    if (PARetVal != -1 && PBRetVal != -1)
    {
        if (PARetVal != PBRetVal)
            return PARetVal > PBRetVal;

        for (int i = 2; i <= 5; i++)
        {
            int PAPokerVal = getMaxPoker(PAHash, i);
            int PBPokerVal = getMaxPoker(PBHash, i);

            if (PAPokerVal != PBPokerVal)
                return PAPokerVal > PBPokerVal;
        }
    }

    return -1;
}

int checkFlush(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isFlush(PAHash);
    PBRetVal = isFlush(PBHash);

    if (PARetVal != -1 && PBRetVal != -1)
    {
        if (PARetVal == 1 && PBRetVal == 1)
        {
            for (int i = 1; i <= 5; i++)
            {
                int PAPokerVal = getMaxPoker(PAHash, i);
                int PBPokerVal = getMaxPoker(PBHash, i);

                if (PAPokerVal != PBPokerVal)
                    return PAPokerVal > PBPokerVal;
            }
        }
        else
            return PARetVal > PBRetVal;
    }

    return -1;
}

int checkFullHouse(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isFullHouse(PAHash);
    PBRetVal = isFullHouse(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    if (PARetVal != -1 && PBRetVal != -1)
        return PARetVal > PBRetVal;

    return -1;
}

int checkFourOfAKind(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isFourOfAKind(PAHash);
    PBRetVal = isFourOfAKind(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    if (PARetVal != -1 && PBRetVal != -1)
    {
        if (PARetVal == PBRetVal)
        {
            int PASingleVal = -1;
            int PBSingleVal = -1;

            for (int i = 1; i <= 5; i++)
            {
                int pokerVal = getMaxPoker(PAHash, i);
                if (pokerVal != PARetVal)
                {
                    PASingleVal = pokerVal;
                    break;
                }
            }

            for (int i = 1; i <= 5; i++)
            {
                int pokerVal = getMaxPoker(PBHash, i);
                if (pokerVal != PBRetVal)
                {
                    PBSingleVal = pokerVal;
                    break;
                }
            }

            return PASingleVal > PBSingleVal;
        }
        else
            return PARetVal > PBRetVal;
    }
    return -1;
}

int checkStraightFlush(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isStraightFlush(PAHash);
    PBRetVal = isStraightFlush(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    if (PARetVal != PBRetVal)
        return PARetVal > PBRetVal;

    return -1;
}

int checkRoyalFlush(int PAHash[4][13], int PBHash[4][13])
{
    int PARetVal;
    int PBRetVal;

    PARetVal = isRoyalFlush(PAHash);
    PBRetVal = isRoyalFlush(PBHash);

    if (PARetVal != -1 && PBRetVal == -1)
        return 1;
    if (PARetVal == -1 && PBRetVal != -1)
        return 0;

    return -1;
}

int beats(char PA[5][3], char PB[5][3])
{
    doHash(PA, PAHash);
    doHash(PB, PBHash);

    int retVal;

    retVal = checkRoyalFlush(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkStraightFlush(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkFourOfAKind(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkFullHouse(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkFlush(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkStraight(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkThreeOfAKind(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkTwoPairs(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    retVal = checkOnePair(PAHash, PBHash);
    if (retVal != -1)
        return retVal;

    return checkDefault(PAHash, PBHash);
}

int main()
{
    freopen("poker.txt", "r", stdin);

    int ans = 0;
    while(scanf("%s", PACards[0]) > 0)
    {
        for (int i = 1; i <= 4; i++)
            scanf("%s", PACards[i]);
        for (int i = 0; i <= 4; i++)
            scanf("%s", PBCards[i]);

        if (beats(PACards, PBCards))
            ans++;
    }
    printf("%d\n", ans);

    return 0;
}


 

Uranux
关注
专栏目录
Project Euler 问题 54 的解决方案：在扑克游戏中，玩家 1 赢了多少手？-matlab开发
06-01
这是这里发现的问题的解决方案： < http index.php?section=problems&id> 当我解决这个问题时，我发现代码是模块化和简单的。 我认为它可以帮助其他人学习逻辑思维以及如何将一个大问题简化为几个小问题。 这就是为什么我认为我在这里提交解决方案并没有打破任何道德障碍。
Project-Euler:ProjectEuler +解决方案
05-15
该软件包包含我针对Euler项目问题​​的解决方案代码。 源代码包括对所涉及数学的详细说明，以证明程序中的逻辑合理。 此代码仅供“参考”。 您需要事先获得书面许可才能执行以下任何操作：逐字重新发布代码，发布...
Project Euler 54
weixin_30343157的博客
02-18 99
#include<bits/stdc++.h> using namespace std; string ss[5]; string tt[5]; int num=0; map<char,int> mp; //map<char,char> cc; int x,x1,x2,x3,x4,x5; int y,y1,y2,y3,y4,y5; bool...
project euler 54
whuawell的博客
12-04 604
Problem 54 Poker hands In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way: High Card: Highest value card.One Pair: Two card
Project Euler ：Problem 54 Poker hands
312小公举的专栏
07-07 1175
In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way: High Card: Highest value card.One Pair: Two cards of the same value.Two Pairs: Tw
欧拉公式求圆周率的matlab代码-Project-Euler:HackerRank上的ProjectEuler和ProjectEuler+
05-23
在本项目"欧拉公式求圆周率的matlab代码-Project-Euler:HackerRank上的ProjectEuler和ProjectEuler+"中，我们关注的是如何利用欧拉公式来计算圆周率π。Project Euler是一个著名的在线问题解决平台，挑战者需要编写...
ProjectEuler:来自https的ProjectEuler +解决方案
05-08
ProjectEuler + 我在Java中（仅Java）对HackerRank的解决方案。 有关更多详细信息，请。 相信我，不是一个奇怪的网站。 ##为什么要用Java？ 很好的问题。 会的，如果您是在C ++中使用“ unsigned int / long”的，...
Project-Euler:我使用 C++ 解决 Project Euler 问题
06-01
Project-Euler 我使用 C++ 解决 Project Euler 问题 摘自网站： “欧拉计划是一系列具有挑战性的数学/计算机编程问题，需要的不仅仅是数学洞察力来解决。虽然数学可以帮助你找到优雅有效的方法，但解决大多数问题...
project euler1.rar_ACM_project_project euler
09-21
【项目欧拉（Project Euler）】是一个非常受欢迎的在线数学和计算机编程挑战平台，它吸引着全球的程序员和数学爱好者参与。项目欧拉的问题通常涉及数学、算法和计算机科学，鼓励解决问题并学习新技能。本压缩包...
Euler Project 54
weixin_42147487的博客
06-04 362
In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way:High Card: Highest value card.One Pair: Two cards of the same value.Two Pairs: Two di...
Project Euler problem 54
水
11-06 594
一道有点复杂的模拟题吧。。 也不算难写 细节上注意一下就行了。。 首先就是判断rank。 这个还是好判断的。 如果rank一样就要把每个人手中的牌按优先级排列一下，两人按顺序比较 这个优先级，说例子吧。 假如是两个对儿的。  优先比较的肯定是大的那个对儿，然后是小的那个对儿，再然后是那个单张的 再说一个 有一对儿还有三张一样的。 优先比较的是三张的，再比较一对儿的 再一个例子，就有一个对
Project Euler Problem 54： Poker hands【模拟】
nobleman
02-11 499
PE其他解题报告请参考这里,本题答案在留言首条 Poker hands Problem 54 In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way: High Card: Highest value card. One ...
欧拉工程第54题：Poker hands
weixin_34174105的博客
07-31 192
package projecteuler51to60; import java.awt.peer.SystemTrayPeer; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import ...
ZOJ1111：Poker Hands(模拟题)
ACM！荣耀之路！
11-19 4668
A poker deck contains 52 cards - each card has a suit which is one of clubs, diamonds, hearts, or spades (denoted C, D, H, S in the input data). Each card also has a value which is one of 2, 3, 4, 5,
【ProjectEuler】ProjectEuler_014
sytzz的专栏
11-05 422
using System; using System.Collections.Generic; using System.Text; using System.Collections; namespace projecteuler014 { class Program { static int[] data = new int[1000001];
Project Euler 44
lushl9301的专栏
11-27 1126
这道题真是遇到问题了……果然……我写的慢了，超时了……TLE……好久没用这词了~ 注意……这个超时，是指超过了1min……擦…… 题目很简单，就是让你找最小的D出来~ 哎……python的in操作我估计是很慢的……因为根本不知道你的list是否有序，那么就一个一个找吧…… def main(): min = 2147483647 p = [n*(3*n-1)//2
Project Euler 11~15
Charlie Pan's Blog
04-16 922
Problem 11: In the 2020 grid below, four numbers along a diagonal line have been marked in red. 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 9
百度2012年校招笔试题——pszStringRotate
Uranux
11-01 2977
百度2013校园招聘笔试题 算法与程序设计 第4题:          字符串左移，void *pszStringRotate(char *pszString, int nCharsRotate),比如ABCDEFG，移3位变DEFGABC，要求空间复杂度O（1），时间复杂度O（n）。         字符串位移,再简单不过了,方法也很多. 有朴素算法(逐位移动,移动nCharsRotat
GSP粉煤气化过程数值模拟：Euler-Lagrangian方法的应用
"该文基于Euler-Lagrangian方法，使用ANSYS/Fluent软件对GSP粉煤气化过程进行了数值模拟，旨在解决实际工业应用中的问题，如喷嘴寿命短和水冷壁烧穿。模拟采用了Species Transport模型耦合湍流-化学反应，Realizable...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值