24点游戏

最新推荐文章于 2025-03-10 12:30:00 发布

原创最新推荐文章于 2025-03-10 12:30:00 发布 · 472 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一款24点游戏的实现算法，利用时间随机函数生成四个数字，并通过穷举法找出所有可能达到24点的计算组合。文章详细展示了如何将数值转化为扑克牌面值，以及如何通过不同的运算符组合来寻找解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

24点游戏需要把1，11，12，13转化为相应A，J，Q，K

为实现随机发牌，利用当前系统时间进行随机取牌

/*  
文件名：24点 
作者：Key-不会挖洞的猫鼬 
版本号：20170412.1.01 
完成日期：2017.4.12 
主要功能：利用时间随机函数随机生成4个数字，程序可自行计算所有的解  
漏洞不足：无法完成用户输入及正确性验证 
*/
   
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <math.h>  
 #include <time.h>  

  
  //1,10,11,12,13显示的处理  
 char getPokerCard(int value)  
 {
     if(value==1)  
     {  
         return 'A';  
     }  
     else if(value < 10)  
     {  
        return value+'0';  
     }  
     else if(value==10)  
     {  
        return '0';  
     }  
     else if(value==11)  
     {  
        return 'J';  
     }  
     else if(value==12)  
     {  
        return 'Q';  
     }  
     else if(value==13)  
     {  
        return 'K';  
     }  
 }  
   
 void printAnswer(int flag,int *poker,char *oper,char *answer)  
 {  
     char a=getPokerCard(poker[0]);  
     char b=getPokerCard(poker[1]);  
     char c=getPokerCard(poker[2]);  
     char d=getPokerCard(poker[3]);  
       
     switch(flag)  
     {  
         //1.((A*B)*C)*D  
         case 1:  
             printf("((%c%c%c)%c%c)%c%c\n",a,oper[0],b,oper[1],c,oper[2],d);  
             break;  
         //2.(A*(B*C))*D  
         case 2:  
             printf("(%c%c(%c%c%c))%c%c\n",a,oper[0],b,oper[1],c,oper[2],d);  
             break;  
         //3.(A*B)*(C*D)  
         case 3:  
             printf("(%c%c%c)%c(%c%c%c)\n",a,oper[0],b,oper[1],c,oper[2],d);  
             break;  
         //4.A*(B*(C*D))  
         case 4:  
             printf("%c%c(%c%c(%c%c%c))\n",a,oper[0],b,oper[1],c,oper[2],d);  
             break;  
         //5.A*((B*C)*D)   
         case 5:  
             printf("%c%c((%c%c%c)%c%c)\n",a,oper[0],b,oper[1],c,oper[2],d);  
             break;  
         default:  
             break;  
     }  
       
     //存储answer  
     
     return ;   
 }  
   
  double getValue(double num1,double num2,char oper)  
 {  
     double result;  
      
	  //四则运算的符号记录 
     switch(oper)  
     {  
         case '+':  
         result=num1+num2;  
         break;  
         case '-':  
         result=fabs(num1-num2);  
         break;  
         case '*':  
         result=num1*num2;  
         break;  
         case '/':  
         result=num1/num2;  
         break;  
         default :  
            break;  
     }   
     return result;  
 }  
   
 int getResult(int *poker,char *oper,char *answer)  
 {  
     double t;  
     //将计算值取到   
     int a=poker[0]>10?1:poker[0];  
     int b=poker[1]>10?1:poker[1];  
     int c=poker[2]>10?1:poker[2];  
     int d=poker[3]>10?1:poker[3];  
       
     //穷举运算次序  
    //1.((A*B)*C)*D  
    t=0;  
    t=getValue(a,b,oper[0]);  
    t=getValue(t,c,oper[1]);  
    t=getValue(t,d,oper[2]);  
      
    if(fabs(t-24)<0.000001)  //t-24的绝对值小于0.000001 
    {  
        printAnswer(1,poker,oper,answer);  
        return 1;  
    }  
      
    //2.(A*(B*C))*D  
    t=0;  
    t=getValue(b,c,oper[1]);  
    t=getValue(a,t,oper[0]);  
    t=getValue(t,d,oper[2]);  
      
    if(fabs(t-24)<0.000001)  
    {  
        printAnswer(2,poker,oper,answer);  
        return 1;  
    }  
      
    //3.(A*B)*(C*D)  
    t=0;  
    t=getValue(getValue(a,b,oper[0]),getValue(c,d,oper[2]),oper[1]);  
      
    if(fabs(t-24)<0.000001)  
    {  
        printAnswer(3,poker,oper,answer);  
        return 1;  
    }  
      
    //4.A*(B*(C*D))  
    t=0;  
    t=getValue(c,d,oper[2]);  
    t=getValue(b,t,oper[1]);  
    t=getValue(a,t,oper[0]);  
      
    if(fabs(t-24)<0.000001)  
    {  
        printAnswer(4,poker,oper,answer);  
        return 1;  
    }  
      
    //5.A*((B*C)*D)   
    t=0;  
     t=getValue(b,c,oper[1]);  
    t=getValue(t,d,oper[2]);  
    t=getValue(a,t,oper[0]);  
      
    if(fabs(t-24)<0.000001)  
    {  
        printAnswer(5,poker,oper,answer);  
        return 1;  
    }  
      
     return 0;  
 }  
   
 void printResult(int *poker,char *answer)  
 {  
     char OperKey[4]={'+','-','*','/'};  
     char oper[3];  
     int i,j,k;  
     int count=0;  
       
     for(i=0;i<4;i++)  
     {
	    for(j=0;j<4;j++)  
        {
		    for(k=0;k<4;k++)  
            {  
                oper[0]=OperKey[i];  
                oper[1]=OperKey[j];  
                oper[2]=OperKey[k];  
                if(getResult(poker,oper,answer))  
                {
				    count++;
				}
		    }
		}
	}
      
     if(count)  
     {  
         printf("共%d种解法\n",count);  
     }  
     else  
     {  
         printf("该情况无解\n");  
     }    
     return ;  
 }  
   
   void printPoker(int *poker)  
 {      
     int i;  
     for(i=0;i<4;i++)  
     {  
         printf("%c ",getPokerCard(poker[i]));  
     }  
     printf("\n");  
       
     return ;  
 }  
   
 void getRandomPokers(int *poker)  
 {  
     int i;  
       
     //利用系统时间作为种子产生随机数 ，函数srand()，rand()=>stdlib.h ，
     //函数time()=>time.h   
    srand((unsigned)time(NULL));  
    for(i=0;i<4;i++)  
    {  
        poker[i]=rand()%13+1;  
    }  
      
    return ;      
 }  
   
 int main()  
 {   
     int poker[4];  
     char answer[20];  
     char c;  
       
     printf("纸牌计算24点\n");  
     printf("*****************************\n");
     do  
     {  
         printf("牌中的10以0代替，减法得数均为正数\n");
         //生成随机纸牌   
         getRandomPokers(poker);  
           
         printf("随机生成的纸牌为：\n");  
  
         //输出生成的纸牌   
         printPoker(poker);  
           
         printf("\n回车键获得结果...\n");  
         getchar();   
           
         //输出计算结果  
         printResult(poker,answer);  
           
         printf("\n回车键继续，其他键并回车退出...\n");  
         c=getchar();  
           
         printf("****************************************\n");  
     }  
     while(c=='\n');  
       
     return 0;  
 }