（BOSS）Poker time! （20 xp）

最新推荐文章于 2024-08-10 16:54:17 发布
最新推荐文章于 2024-08-10 16:54:17 发布
阅读量353 收藏 4
点赞数 6
分类专栏： C档起步 C语言 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alexanderabc/article/details/141069954
版权

“千里春风不识路，万仞山顶自相逢”

当当当！小橘归来，继续解题！

题目描述

背景：两个人每人发3张牌（各从一副牌中），每张牌包括花色（红桃(Heart)>黑桃(Spade)>方块(Diamond)>梅花(Club））和大小（从小到大依次是：2-10、J、Q、K、A），谁手上有最大的一张或多张（如果有相同的牌）牌谁获胜。

输入：A的3张牌（未排序）和B的3张牌（未排序）。（参见用例）

输出：A的3张牌的排序后的输出和B的3张牌的排序后的输出，以及A和B谁获胜。（参见用例）

解题思路

本题乍一看考排序，再定睛一看，哦，原来是有优先级的排序（花色和大小）。诶那感觉也不是很困难嘿嘿，结果真写起来就被啪啪打脸：）

经小橘不严谨的总结，认为本题的难点主要有三个，一是对于输入输出时的细节处理，二是对花色和大小的权重赋值处理，三是对'10'的单独处理

整体思路是先对牌的花色和大小分别进行赋值，然后想办法将这两个属性整合到一个数中用于比较，比较的过程中完成A、B的降序排序，最终输出结果。即：赋值——>整合——>比较——>输出。

关键参数

A[3][3],B[3][3]：3×3的二维数组，用于储存输入的三张牌，列为3是由于10的存在，得多留一位。

A_score[3][2],B_score[3][2]：对于每个花色和大小进行重新赋值，方便后续整合比较。花色的优先级高，故将其设为百位数。

A_sum[3],B_sum[3]：是对花色和大小整合后的数值，是比较和排序的依据。

难点分析

下面咱们对难点逐一进行分析：

1、输入输出时的细节处理

输入中只有10是特殊的，所以我们希望能将所有的输入都转变成两位的形式，这样方便后续的处理和比较。

注意：输入中无10，第三位为空格；若有10，则将第二位转变为'9'+1，第三位转变为0，并补上空格。

for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&A[i][0],&A[i][1],&A[i][2]);
        if(A[i][1]=='1'&&A[i][2]=='0')
        {
            A[i][1]='9'+1;
            A[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }
    scanf("\n");
    for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&B[i][0],&B[i][1],&B[i][2]);
        if(B[i][1]=='1'&&B[i][2]=='0')
        {
            B[i][1]='9'+1;
            B[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }

输出时要对第一步处理进行还原，将'9'+1还原为'10'

for(i=0;i<3;i++)
    {
        if(A[i][1]=='9'+1)
        {
            A[i][1]='1';
            A[i][2]='0';
        }
        if(B[i][1]=='9'+1)
        {
            B[i][1]='1';
            B[i][2]='0';
        }
    }
    
//输出结果
    printf("A:"); 
    for(i=0;i<3;i++)
    {
        if(A[i][2]=='0')
            printf(" %c%c%c",A[i][0],A[i][1],A[i][2]);
        else
            printf(" %c%c",A[i][0],A[i][1]);
    }
    printf("\n");
    printf("B:");
    for(i=0;i<3;i++)
    {
        if(B[i][2]=='0')
            printf(" %c%c%c",B[i][0],B[i][1],B[i][2]);
        else
            printf(" %c%c",B[i][0],B[i][1]);
    }
    printf("\n");

2、花色和大小的权重赋值处理

以A为例，对于花色和大小进行赋值。由于花色的优先级更高，故我们将花色权重设置到百位，这样对大小的赋值不会影响到花色。

A_sum,B_sum即代表整体的分数，后面可以直接拿这个作比较。

switch(A[i][0])
        {
            case 'H':
                A_score[i][0]=400;
                break;
            case 'S':
                A_score[i][0]=300;
                break;
            case 'D':
                A_score[i][0]=200;
                break;
            case 'C':
                A_score[i][0]=100;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        switch(A[i][1])
        {
            case '2':
                A_score[i][1]=1;
                break;
            case '3':
                A_score[i][1]=2;
                break;
            case '4':
                A_score[i][1]=3;
                break;
            case '5':
                A_score[i][1]=4;
                break;
            case '6':
                A_score[i][1]=5;
                break;
            case '7':
                A_score[i][1]=6;
                break;
            case '8':
                A_score[i][1]=7;
                break;
            case '9':
                A_score[i][1]=8;
                break;
            case '9'+1:
                A_score[i][1]=9;
                break;
            case 'J':
                A_score[i][1]=10;
                break;
            case 'Q':
                A_score[i][1]=11;
                break;
            case 'K':
                A_score[i][1]=12;
                break;
            case 'A':
                A_score[i][1]=13;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        A_sum[i]=A_score[i][0]+A_score[i][1];

3、对'10'的单独处理

这个前面都已提到，一个是在输入时将数组由三位转换为两位，输出时在转变回来，另一个则是要注意运算时位数的统一。

完整代码

#include<stdio.h>

int main()
{
//本题的难点主要有三个，一是对于花色和大小的赋值处理，二是对花色和大小的权重处理，三是对'10'的单独处理
    char A[3][3],B[3][3];
    int A_score[3][2],B_score[3][2],A_sum[3],B_sum[3];
    int i,j,temp;
    char ctemp1,ctemp2;

//输入中只有10是特殊的，所以我们希望能将所有的输入都转变成两位的形式，这样方便后续的处理和比较
//注意：输入中无10，第三位为空格；若有10，则将第二位转变为'9'+1，第三位转变为0，并补上空格
    for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&A[i][0],&A[i][1],&A[i][2]);
        if(A[i][1]=='1'&&A[i][2]=='0')
        {
            A[i][1]='9'+1;
            A[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }
    scanf("\n");
    for(i=0;i<3;i++)
    {
        scanf("%c%c%c",&B[i][0],&B[i][1],&B[i][2]);
        if(B[i][1]=='1'&&B[i][2]=='0')
        {
            B[i][1]='9'+1;
            B[i][2]=0;
            if(i!=2)
                scanf(" ");
        }
    }

//对于花色和大小进行赋值。由于花色的优先级更高，故我们将花色权重设置到百位，这样对大小的赋值不会影响到花色
//A_sum,B_sum即代表整体的分数，后面可以直接拿这个作比较
    for(i=0;i<3;i++)
    {
        switch(A[i][0])
        {
            case 'H':
                A_score[i][0]=400;
                break;
            case 'S':
                A_score[i][0]=300;
                break;
            case 'D':
                A_score[i][0]=200;
                break;
            case 'C':
                A_score[i][0]=100;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        switch(A[i][1])
        {
            case '2':
                A_score[i][1]=1;
                break;
            case '3':
                A_score[i][1]=2;
                break;
            case '4':
                A_score[i][1]=3;
                break;
            case '5':
                A_score[i][1]=4;
                break;
            case '6':
                A_score[i][1]=5;
                break;
            case '7':
                A_score[i][1]=6;
                break;
            case '8':
                A_score[i][1]=7;
                break;
            case '9':
                A_score[i][1]=8;
                break;
            case '9'+1:
                A_score[i][1]=9;
                break;
            case 'J':
                A_score[i][1]=10;
                break;
            case 'Q':
                A_score[i][1]=11;
                break;
            case 'K':
                A_score[i][1]=12;
                break;
            case 'A':
                A_score[i][1]=13;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        A_sum[i]=A_score[i][0]+A_score[i][1];

        switch(B[i][0])
        {
            case 'H':
                B_score[i][0]=400;
                break;
            case 'S':
                B_score[i][0]=300;
                break;
            case 'D':
                B_score[i][0]=200;
                break;
            case 'C':
                B_score[i][0]=100;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        switch(B[i][1])
        {
            case '2':
                B_score[i][1]=1;
                break;
            case '3':
                B_score[i][1]=2;
                break;
            case '4':
                B_score[i][1]=3;
                break;
            case '5':
                B_score[i][1]=4;
                break;
            case '6':
                B_score[i][1]=5;
                break;
            case '7':
                B_score[i][1]=6;
                break;
            case '8':
                B_score[i][1]=7;
                break;
            case '9':
                B_score[i][1]=8;
                break;
            case '9'+1:
                B_score[i][1]=9;
                break;
            case 'J':
                B_score[i][1]=10;
                break;
            case 'Q':
                B_score[i][1]=11;
                break;
            case 'K':
                B_score[i][1]=12;
                break;
            case 'A':
                B_score[i][1]=13;
                break;
            default:
                printf("Input Error!\n");
                return 0;
        }
        B_sum[i]=B_score[i][0]+B_score[i][1];
    }

//有了前面的铺垫，这里就是一个简单的冒泡排序，需要关注的就是对于数字和字符的分离但同步的处理
    for(i=0;i<2;i++)
    {
        if(A_sum[i]==A_sum[i+1]||B_sum[i]==B_sum[i+1])
        {
            printf("Input Error!\n");
            return 0;
        }
        for(j=0;j<2-i;j++)
        {
            if(A_sum[j]<A_sum[j+1])
            {
                temp=A_sum[j];
                A_sum[j]=A_sum[j+1];
                A_sum[j+1]=temp;
                
                ctemp1=A[j][0];
                ctemp2=A[j][1];
                A[j][0]=A[j+1][0];
                A[j][1]=A[j+1][1];
                A[j+1][0]=ctemp1;
                A[j+1][1]=ctemp2;
            }
            if(B_sum[j]<B_sum[j+1])
            {
                temp=B_sum[j];
                B_sum[j]=B_sum[j+1];
                B_sum[j+1]=temp;
                
                ctemp1=B[j][0];
                ctemp2=B[j][1];
                B[j][0]=B[j+1][0];
                B[j][1]=B[j+1][1];
                B[j+1][0]=ctemp1;
                B[j+1][1]=ctemp2;
            }
        }
        
    }

    if(A_sum[0]==B_sum[0])
    {
        if(A_sum[1]==B_sum[1])
        {
            if(A_sum[2]==B_sum[2])
            {
                printf("Winner is X!\n");
            }
            else if(A_sum[2]>B_sum[2])
            {
                printf("Winner is A!\n");
            }
            else
            {
                printf("Winner is B!\n");
            }
        }
        else if(A_sum[1]>B_sum[1])
        {
            printf("Winner is A!\n");
        }
        else
        {
            printf("Winner is B!\n");
        }
    }
    else if(A_sum[0]>B_sum[0])
    {
        printf("Winner is A!\n");
    }
    else if(A_sum[0]<B_sum[0])
    {
        printf("Winner is B!\n");
    }

//这一步也至关重要，是对第一步处理的还原，将'9'+1还原为'10'
    for(i=0;i<3;i++)
    {
        if(A[i][1]=='9'+1)
        {
            A[i][1]='1';
            A[i][2]='0';
        }
        if(B[i][1]=='9'+1)
        {
            B[i][1]='1';
            B[i][2]='0';
        }
    }
    
//输出结果
    printf("A:"); 
    for(i=0;i<3;i++)
    {
        if(A[i][2]=='0')
            printf(" %c%c%c",A[i][0],A[i][1],A[i][2]);
        else
            printf(" %c%c",A[i][0],A[i][1]);
    }
    printf("\n");
    printf("B:");
    for(i=0;i<3;i++)
    {
        if(B[i][2]=='0')
            printf(" %c%c%c",B[i][0],B[i][1],B[i][2]);
        else
            printf(" %c%c",B[i][0],B[i][1]);
    }
    printf("\n");
    return 0;
}

以上就是本次分享的全部内容啦，此题当然还有很多种解法，小橘也还在学习中，水平有限，如有考虑不周之处烦请各位不吝赐教：）

吃葡萄不吐橘子皮yeah
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
48.网络安全渗透测试—[穷举篇11]—[webshell密码破解(asp/aspx/php)]
qwsn
08-07 87万+
我认为：无论是学习安全还是从事安全的人，多多少少都有些许的情怀和使命感！！！ 文章目录 一、burpsuite2.0 webshell密码破解办法 1、目标1： `http://www.yijuhua.com/b.asp` 2、目标2：`http://www.yijuhua.com/b.php` 3、目标3：`http://www.yijuhua.com/b.aspx`
POKER TIME.C
12-16
POKER TIME.C
Poker time 2 (enhanced version) 北理乐学作业题
m0_74603887的博客
04-17 387
背景：两个人每人发3张牌（各从一副牌中），每张牌包括花色（红桃(Heart)>黑桃(Spade)>方块(Diamond)>梅花(Club））和大小（从小到大依次是：2-10、J、Q、K、A），胜负规则如下：同花顺（3张同花色的连牌，先比大小，再比花色，后同）>炸弹（3张相同大小的牌）>连牌（3张不同花色的连牌）>对子（两张相同大小的牌）>单牌。例如，红桃QKA>黑桃QKA>梅花567>方块234>AAA（红桃、方块、梅花）>AAA（黑桃、方块、梅花）>JQK（红桃、红桃、方块）>JQK
（BOSS）Poker time （20 xp）
yorunouta的博客
04-30 1219
两个人每人发3张牌（各从一副牌中），每张牌包括花色（红桃(Heart)>黑桃(Spade)>方块(Diamond)>梅花(Club））和大小（从小到大依次是：2-10、J、Q、K、A），谁手上有最大的一张或多张（如果有相同的牌）牌谁获胜。 输入：A的3张牌（未排序）和B的3张牌（未排序）。 输出：A的3张牌的排序后的输出和B的3张牌的排序后的输出，以及A和B谁获胜。
Poker Time
ChenGengru的博客
11-29 4623
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; /* Poker Time */ /* written by Chen Gengru */ /* updated on 2018-11-22 */ int main() { char A[3][2]; char B[3][2]; int i, ...
【选作】Poker time 2 (enhanced version)
最新发布
Alexanderabc的博客
08-10 565
我见青山多妩媚，料青山见我应如是”嗨嗨嗨！有了Poker time基础版做铺垫，小橘相信解决这个enhanced版本也就不是很困难啦。如果还没有了解过基础版的同学，可以先看看这篇文章这样再看这题就会易懂得多。话不多说，咱们进入正题！
Bugku misc wp
God_of_fear的博客
10-22 2364
一个小白的学习之旅
C++面试题
热门推荐
backard的专栏
01-20 5万+
1.构造一个类MySingleton,使该类只能存在一个实例. 思路:     将构造函数写为private的，然后通过一个成员静态函数来调用构造函数即可:) 例: #include "iostream.h" class MySingleton { private: static MySingleton* _instance; MySingleton(){ cout ~MyS
Rogue Guide
幽客独往
02-16 6134
Guide to Playing a Rogue v2.0 Written By Osiris WHAT’S NEW IN VERSION 2.0 I started to make an index of everything I changed since my last rogue guide. When I realized it would be more than 2 pages
Static_Poker.rar_poker
09-14
标题中的"Static_Poker.rar_poker"暗示了这是一个与扑克牌和编程相关的任务，具体来说，是一个静态处理扑克牌的算法问题。描述中提到的"54张扑克牌，把最上面的牌插到最下面，每插三张扔掉一张，输出最后一张牌的...
poker II 常用固件.zip
07-22
标题中的“poker II 常用固件.zip”指的是针对老款Poker II机械键盘的常用固件集合，这通常包含了一系列优化和更新的软件程序，用于改善键盘的性能、功能或者解决某些已知问题。固件是硬件设备的灵魂，它相当于键盘...
pokeR:使用SignalR规划扑克
05-17
扑克 使用实时规划扑克。 查看！ PokeR是使用.NET Core和Angular构建的实时... docker run -- name poker -- restart always - d - p 80 : 80 halomademeapc / poker概述 您可以选择尚未用作房间号的任何整数。 该号
poker-card-dataset.rar
09-19
"poker-card-dataset.rar"是一个专门针对扑克牌的数据库，包含了训练、验证和测试三个部分的数据，对于机器学习和人工智能在扑克牌领域的研究具有重要意义。 一、数据集简介 这个数据集以".rar"压缩格式提供，名为...
P1145 约瑟夫
zty20120913的博客
08-06 400
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
day 9 回溯算法
m0_73924943的博客
08-08 204
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 556
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
嵌入式初学-C语言-十五
MaBaB的博客
08-05 645
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
[算法] 第二集 二叉树中的深度搜索
2301_80017277的博客
08-09 424
一、（DFS，全称为 Depth First Traversal），是我们树或者图这样的数据结构中常⽤的⼀种遍历算法。这个算法会尽可能深的搜索树或者图的分支，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上⼀层，继续找⼀条路遍历。在⼆叉树中，常见的深度优先遍历为：前序遍历、中序遍历以及后序遍历。因为树的定义本⾝就是递归定义，因此采⽤递归的方法去实现树的三种遍历不仅容易理解⽽且代码很简洁。
unity poker 联机 例子
07-31
Unity Poker是一个基于Unity引擎的联机扑克游戏的例子。它通过网络连接，使得玩家可以与其他玩家一起玩扑克游戏，体验真实的多人游戏体验。 在Unity Poker游戏中，玩家可以通过创建房间或加入已有的房间来开始游戏。房间可以设置不同的规则和限制，如玩家人数、下注限制等，以满足不同玩家的需求。 在游戏开始之前，玩家可以选择自己的角色和头像，以与其他玩家区分。一旦游戏开始，各个玩家会分发扑克牌，并且在自己的回合中进行下注、跟注、加注等操作。游戏通过结合规则和策略，以及运气的成分来决定胜负。 Unity Poker还拥有一个实用的聊天系统，使得玩家可以在游戏中与其他玩家进行实时交流。这个聊天系统可以帮助玩家互相讨论策略、传递信息，提高游戏的乐趣和社交性。 Unity Poker游戏的美术效果、音效、动画等方面非常细致，为玩家营造出一个逼真的扑克牌局氛围。此外，游戏还提供了排行榜、成就系统等功能，让玩家可以和其他玩家进行竞争和比较。 通过Unity Poker这个例子，我们可以看到联机游戏的娱乐性和社交性。它不仅可以给玩家带来娱乐，而且可以通过实时的交流和竞争培养玩家的策略思维和团队合作能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值