有关牌的题目

最新推荐文章于 2024-04-24 16:14:41 发布
最新推荐文章于 2024-04-24 16:14:41 发布
阅读量570 收藏
点赞数
分类专栏： 数据结构 文章标签： list null 游戏 struct 测试 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stella_java/article/details/4386581
版权

 

电子游戏中的数学

近年来，随着电子游戏的日益普及，电子游戏业已成为横跨信息技术和文化的重要产业。对电子游戏中的一些数学问题进行研究，成为数学界和相关人士的一个热门话题。

在某电子游戏中，玩家每次下注一元，由机器随机分配给玩家五张扑克牌，然后允许玩家有一次换牌的机会，即可以放弃其中的某几张牌，放弃的牌留下的空缺由机器在剩下的47张牌中再次随机分配。玩家的奖金依据其最后所持有的牌型而定。下面是一份典型的奖金分配表：

牌型

奖金（元）

同花大顺（10到A）

800

同花顺

50

四张相同点数的牌

25

满堂红（三张同点加一对）

8

同花

5

顺子

4

三张相同点数的牌

3

两对

2

一对高分对（J及以上）

1

其它

0

在上表中，玩家的牌型属于某一类型且不属于任何更高的类型，则赢得该牌型相应的奖金。

若某玩家采取以下策略，当原始的牌型构成一个顺子或更高的牌型时，则放弃换牌的机会；否则，除保留对子或三张相同点数的牌外，将手中其余的牌放弃，由机器再次随机分配。根据上述游戏规则和策略，分析各类牌型出现的可能性，计算采取该策略能获得的期望奖金金额。

用C语言编程模拟情况如下：

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<time.h>

 

typedef struct node
{
    int Number;
    char Color;
    int IsSame;
    struct node *link;
}Node,*List;

 


void Welcome();                                /*欢迎界面*/
void FaPai(List H);                            /*发牌(并且已经按照玩家的策略进行了换牌)*/
void FuZhi_IsSame(List H);                     /*对IsSame进行赋值*/
int  Type(List H);                             /*判断牌型*/
void JiangLi(int type);                        /*得到奖励*/
void InitList(List *p);                        /*初始化链表*/
void InsertList(List H,char color,int number); /*插入链表*/
void DeleteList(List H);                       /*删除链表*/


void main()
{
    List H,p;
    int i;
    int ans;
    char answer='y';
    srand(time(NULL));
    Welcome();
    while(answer=='y')
    {

        for(i=0;i<1;i++)      /*控制进行多少次游戏*/
        {
           /* printf(" %d",i+1); */
           InitList(&H);
            /*printf("/nYour pai is :/n/n");*/
            FaPai(H);
            while(H->link!=NULL)
            {
                p=H->link;
                H->link=p->link;
                free(p);
            }
        }
        printf("/n Do you want to test angain?/n");
        answer=getch();
        putch(answer);
    }

 

    getch();
    return;
}

 

void InitList(List *p)
{
    List q;
    q =(List)malloc(sizeof(Node));
    q->Color=0;
    q->Number=0;
    q->IsSame=0;
    q->link=NULL;
    *p = q;

    return;
}


void InsertList(List H,char color,int number)
{
    List p,q;
    int i=0;


    q =(List)malloc(sizeof(Node));
    q->Color=color;
    q->Number=number;
    q->IsSame=1;

    p=H;

    while(H->link!=NULL)
    {
        p=H->link;
        if(q->Number>=p->Number)
        {
            H=H->link;
            continue;
        }
        else
        {
           i=1;
           break;
        }
        H=H->link;
    }
    if(i==0)
    {
        q->link=p->link;
        p->link=q;
    }
    else
    {
        q->link=H->link;
        H->link=q;
    }
    return;
}


void DeleteList(List H)
{
    List p,q;
    p=H->link;
    q=H;

    while(p!=NULL)
    {
        if(p->IsSame==1)
        {
            q->link=p->link;
            p=p->link;
        }
        else
        {
            p=p->link;
            q=q->link;
        }
    }

 

    return;
}

 

void Welcome()
{
    printf("************Welcome our game's room************/n");
    printf("*                                             */n");
    printf("*                                             */n");
    printf("*                Fa Pai Game                  */n");
    printf("*                                             */n");
    printf("*                                             */n");
    printf("***********************************************/n");

    return;
}


void FaPai(List H)
{

    int i,j,card[52];
    int display;
    int count;
    int no;              /*随机的牌*/
    int number=0;        /*控制显示几张牌*/
    int type;
    List p;

 

    for(count=0;count<52;count++)
        card[count]=count;

    for(i=0;i<52;i++)
    {
        no=rand()%52;
           /*the value of no is from 0 to 53*/
        if(card[no]==-1)
        {
            i--;
            continue;
        }
        display=no;
        card[no]=-1;
        InsertList(H,display/13+3,(display+1)%13+2);
        number++;
        if(number==5)
         {
            p=H->link;
            printf("/n/n");
            printf("/nBefore changing!");
             printf("/n/n");
            while(p!=NULL)
            {
                printf("%c%d  /t",p->Color,p->Number);
                p=p->link;
            }
            printf("/n/n");
            FuZhi_IsSame(H);
            type=Type(H);

            if(type<=6)             /*玩家策略在顺子以上不换牌*/
            {

                break;
            }
            else if(type==7)        /*玩家策略在三张相同点数的牌要换剩下的俩张牌*/
            {
                DeleteList(H);      /*删除链表中IsSame为1的链接点*/

                for(j=0;j<2;j++)    /*随机产生新的俩张牌*/
                {
                    no=rand()%52;
                    if(card[no]==-1)
                    {
                        j--;
                        continue;
                    }
                    display=no;
                    card[no]=-1;
                    InsertList(H,display/13+3,(display+1)%13+2);
                }
                FuZhi_IsSame(H);
                type=Type(H);

                break;
            }
            else if(type==8)        /*玩家策略在俩个对子的牌要换剩下的俩张牌*/
            {
                DeleteList(H);      /*删除链表中IsSame为1的链接点*/

                for(j=0;j<1;j++)    /*随机产生新的一张牌*/
                {
                    no=rand()%52;
                    if(card[no]==-1)
                    {
                        j--;
                        continue;
                    }
                    display=no;
                    card[no]=-1;
                    InsertList(H,display/13+3,(display+1)%13+2);
                }
                FuZhi_IsSame(H);
                type=Type(H);

                break;
            }
            else if(type==9)        /*玩家策略在一个高分对子的牌要换剩下的三张牌*/
            {
                DeleteList(H);      /*删除链表中IsSame为1的链接点*/

                for(j=0;j<3;j++)    /*随机产生新的三张牌*/
                {
                    no=rand()%52;
                    if(card[no]==-1)
                    {
                        j--;
                        continue;
                    }
                    display=no;
                    card[no]=-1;
                    InsertList(H,display/13+3,(display+1)%13+2);
                }
                FuZhi_IsSame(H);
                type=Type(H);

                break;
            }
            else if(type==10)        /*玩家策略在一个低分对子的牌要换剩下的三张牌*/
            {
                DeleteList(H);      /*删除链表中IsSame为1的链接点*/

                for(j=0;j<3;j++)    /*随机产生新的三张牌*/
                {
                    no=rand()%52;
                    if(card[no]==-1)
                    {
                        j--;
                        continue;
                    }
                    display=no;
                    card[no]=-1;
                    InsertList(H,display/13+3,(display+1)%13+2);
                }
                FuZhi_IsSame(H);
                type=Type(H);

                break;
            }
            else if(type==11)        /*玩家策略在一个什么都不是的牌要换所有的五张牌*/
            {
                DeleteList(H);      /*删除链表中IsSame为1的链接点*/

                for(j=0;j<5;j++)    /*随机产生新的五张牌*/
                {
                    no=rand()%52;
                    if(card[no]==-1)
                    {
                        j--;
                        continue;
                    }
                    display=no;
                    card[no]=-1;
                    InsertList(H,display/13+3,(display+1)%13+2);
                }
                FuZhi_IsSame(H);
                type=Type(H);

                break;
            }
        }
    }

    /*测试插入是否成功,插入好以后就已经按照升序排序了*/
    p=H->link;
     printf("/n/n");
    printf("/nThe result:!");
     printf("/n/n");
    while(p!=NULL)
    {
        printf("%c%d  /t",p->Color,p->Number);
        p=p->link;
    }

     printf("/n/n");


    JiangLi(type);

    return;
}

void FuZhi_IsSame(List H)
{
    List p,q,w;
    w=H->link;
    p=H->link;
    q=H->link;

    while(w!=NULL)
    {
        w->IsSame=1;
        w=w->link;
    }

    while(p->link!=NULL)
    {
        while(q->link!=NULL)
        {
            if(p->Number==q->link->Number)
            {
                p->IsSame++;
                q->link->IsSame++;
            }
            q=q->link;
        }
        p=p->link;
        q=p;
    }

    /*测试IsSame是否赋值成功*/
   /* p=H->link;
    while(p!=NULL)
    {
        printf("[%c%d]%d/t",p->Color,p->Number,p->IsSame);
        p=p->link;
    }
    printf("/n"); */


    return;
}

int Type(List H)
{
    List p;
    int i,j,temp,max,type;
    int same[5]={0};
    p=H->link;

    /*将所有的IsSame赋值到数组same中*/
    for(i=0;i<5;i++)
    {
        same[i]=p->IsSame;
        p=p->link;

    }

    p=H->link;/*为了下面判断type*/

    /*对数组same进行降序排序，找到最大值和第二大值*/
    for(i=0;i<5;i++)
    {
        for(j=i;j<5;j++)
        {
            if(same[i]<same[j])
            {
                temp=same[i];
                same[i]=same[j];
                same[j]=temp;
            }
        }
    }

    /*测试IsSame按照升序排序好后的数组same*/
    /*printf("/n/n");
    printf("The IsSame is :/n/n");
    for(i=0;i<5;i++)
        printf("%d ",same[i]); */


    if(same[0]==4)
        type=3;      /*四张相同点数的牌*/

    else if(same[0]==3)
    {
        if(same[3]==2)
            type=4;  /*满堂红*/
        else
            type=7;  /*三张相同点数的牌*/
    }

    else if(same[0]==2)
    {
        if(same[2]==2)
            type=8;  /*俩对*/
        else
        {
            while(p!=NULL)
            {
                if(p->Number>=11&&p->IsSame==2)
                {
                    type=9; /*一对高分对*/
                    break;
                }
                p=p->link;
            }
            if(p==NULL)
                type=10;    /*一对小对，属于其它*/
        }
    }

    else if(same[0]==1)
    {
        if(p->link->link->link->link->Number - p->Number == 4)
        {
            if(p->Number==10)
            {
                if(p->Color==p->link->Color && p->Color==p->link->link->Color && p->Color==p->link->link->link->Color && p->Color==p->link->link->link->link->Color)
                    type=1;  /*同花大顺*/
                else
                    type=6;  /*顺子*/
            }
            else
            {
                if(p->Color==p->link->Color && p->Color==p->link->link->Color && p->Color==p->link->link->link->Color && p->Color==p->link->link->link->link->Color)
                    type=2; /*同花顺*/
                else
                    type=6;  /*顺子*/
            }
        }
        else
        {
            if(p->Color==p->link->Color && p->Color==p->link->link->Color && p->Color==p->link->link->link->Color && p->Color==p->link->link->link->link->Color)
                type=5;  /*同花*/
            else
                type=11;  /*其它*/
        }
    }


    return type;
}


void JiangLi(int type)
{
    switch(type)
    {
        case 1:
            printf("/n/nYour reward is : 800");
            break;
        case 2:
            printf("/n/nYour reward is : 50");
            break;
        case 3:
            printf("/n/nYour reward is : 25");
            break;
        case 4:
            printf("/n/nYour reward is : 8");
            break;
        case 5:
            printf("/n/nYour reward is : 5");
            break;
        case 6:
            printf("/n/nYour reward is : 4");
            break;
        case 7:
            printf("/n/nYour reward is : 3");
            break;
        case 8:
            printf("/n/nYour reward is : 2");
            break;
        case 9:
            printf("/n/nYour reward is : 1");
            break;
        case 10:
            printf("/n/nYour reward is : 0");
            break;
        case 11:
            printf("/n/nYour reward is : 0");
            break;
        default:
            break;
    }
    return;
}

结果截屏如下：

 

 

 

Stella_java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
STELLA 练习题
09-01
stella 系统管理软件 操作运行 练习题 详解
华为OJ题目 扑克牌大小
09-10
华为OJ难题 扑克牌大小解答
你有4张卡片，每张卡片从1到9的数字，通过*，/，+， - ，（，）来获得24的值。
i_am_bird的博客
11-24 1908
本题源自leetcodehttps://leetcode.com/problems/24-game/description/ -----------------------------------------------   代码： bool judgePoint24(vector& nums) { sort(nums.begin(),nums.end());
Foj 1504 Play Poker
SMCwwh
05-04 1165
Accept: 90    Submit: 263Time Limit: 1000 mSec    Memory Limit : 32768 KB Problem DescriptionIn poker, you have 5 cards. There are 10 kinds of poker hands (from highest to lowest):1. royal f
C语言程序设计现代方法-第二版-第10章练习题
Huangpengyu123的博客
06-25 2144
title: C语言程序设计现代方法-第二版-第10章练习题 date: 2018-11-11 08:12:17 tags: 局部变量 外部变量 categories: C语言 1.修改10.2节的栈示例使它存储的是字符而不是整数.接下来,增加main函数,用来要求用户输入一串花括号,然后指出它们之间的嵌套是否正确: ```/* Enter parenteses and /or braces:((){}{()}} Parenteses/braces are nested properly */ #.
阿里笔试扑克牌题目 （记忆化回溯+剪枝）
12-22
阿里笔试扑克牌题目 阿里笔试扑克牌题目 （记忆化回溯+剪枝） ```python class Main(): def __init__(self): self.memo={} def main(self): lt=input().split(' ') lt=[int(i) for i in lt] def inter(lt,ind...
7-6 扑克牌题目.py
11-03
7-6 扑克牌题目.py
python模拟实现斗地主发牌
01-20
扑克牌是一种非常大众化的游戏，在计算机中有很多与扑克牌有关的游戏。例如，在Windows操作系统下自带的纸牌、红心大战等。在扑克牌类的游戏中，往往都需要执行洗牌操作，就是将一副牌完全打乱，使其排列没有规律。 ...
模具毕业设计题目推荐_吉康牌饮水瓶盖的注射模具设计.rar
09-22
模具毕业设计题目推荐_吉康牌饮水瓶盖的注射模具设计.rar
通过欧拉计划学Rust编程（第54题）
申龙斌的程序人生
02-13 389
由于研究Libra等数字货币编程技术的需要，学习了一段时间的Rust编程，一不小心刷题上瘾。 刷完欧拉计划中的63道基础题，能学会Rust编程吗？ “欧拉计划”的网址：https://projecteuler.net 英文如果不过关，可以到中文翻译的网站：http://pe-cn.github.io/ 这个网站提供了几百道由易到难的数学问题，你可以用任何办法去解决它，当然主要还得靠编程，...
Python学习～4.for循环及练习
Stella_Potter的博客
01-17 1390
1.语法： for 变量 in range(10):       循环需要执行的代码 例： #求1～100之间所有偶数之和 sum = 0 for i in range(2,101,2): sum += i print(sum) #求1～100之间所有奇数之和 sum = 0 for i in range(1,101,2): sum += i print(sum) 2....
leetcode 679. 24点游戏
sinat_30281495的博客
02-25 901
题目描述： 你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过*，/，+，-，(，)的运算得到 24。 示例 1: 输入: [4, 1, 8, 7] 输出: True 解释: (8-4) * (7-1) = 24 示例 2: 输入: [1, 2, 1, 2] 输出: False 注意: 除法运算符/表示实数除法，而不是整数除法。例如 4 / (1 - 2/3...
用链表形式存储一个字符串，插入、删除某个字符，最后按正序、逆序两种方式输出字符串
大草的博客
11-08 8445
[问题描述] 用链表形式存储一个字符串，插入、删除某个字符，最后按正序、逆序两种方式输出字符串。 [输入] 初始字符串，插入位置，插入字符，删除字符。 [输出] 已建立链表（字符串），插入字符后链表，删除字符后链表，逆转后链表。 [存储结构] 采用链式存储结构 [算法的基本思想] 建立链表：当读入字符不是结束符时，给结点分配存储空间，写数据域，将新结点插到表尾；插入字符：根据读
C++|list的模拟实现
学习笔记
04-19 449
我们模拟实现的list是带头双向循环链表，list的成员变量有指向头节点的指针。所以在实现list之前我们应该实现节点这个类型。
STL-List
欢迎来到jiantaoyab博客
04-19 1048
我们将进入到C++STL 的学习。STL在各各C++的头文件中，以源代码的形式出现，不仅要会用，还要了解底层的实现。
【第六章】集合类：List、Iterator迭代器
小火龙的博客
04-22 680
集合类就像一个容器，相当于一个动态数组。为了在程序中可以保存数目不确定的对象，Java提供了一系列特殊的类，这些类可以存储任意类型的对象，并且长度可变，这些类被统称为集合。集合类都位于java.util包中，使用时必须导包。
C++学习第九天（list及其模拟实现）
最新发布
zjx_web_c的博客
04-24 336
概念：迭代器失效即迭代器所指向的节点无效，即该节点被删除了，因为list的底层结构是带头节点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除的时候才会失效，而且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。list中的接口比较多，一下是常见的重要接口。
vivo 射频天线 面试 题目
09-13
以下是我对vivo射频天线面试题目的回答： 1. 射频天线在手机中的作用是什么？ 射频天线在手机中起到了接收和发送无线信号的作用。它负责接收基站或其他设备发出的无线信号，并将其转化为电信号传输给手机的其他部件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值