开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 控制台编程 > 查看源码
24game.c
资源名称：C数据结构课程设计.rar　[点击查看]
上传用户：janny_wxd
上传日期：2010-02-03
资源大小：261k
文件大小：25k
源码类别：

控制台编程

开发平台：

C/C++

24game.c：源码内容
  1. #include"24.h"
  2. int oper[7]={43,45,42,47,40,41,35};//七种字符的ASCII码
  3. unsigned char Prior[7][7] = {     // 表3.1  算符间的优先关系
  4.      '>','>','<','<','<','>','>',
  5.   '>','>','<','<','<','>','>',
  6.   '>','>','>','>','<','>','>',
  7.   '>','>','>','>','<','>','>',
  8.   '<','<','<','<','<','=',' ',
  9.   '>','>','>','>',' ','>','>',
  10.   '<','<','<','<','<',' ','='
  11. };
  13. char OPSET[OPSETSIZE]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'};
  15. status init_sq(sqlist *l){//初始化链表
  16. l=(sqlist*)malloc(sizeof(sqlist));
  17. if(l==NULL){
  18. exit(OVERFLOW);
  19. }
  20. l->next=NULL;
  21. return OK;
  22. }
  24. status insert_sq(sqlist **p,int e,int bl){
  25. //链表插入操作,*p一直指向链表的最后一个结点
  26. //由于这里要求修改外部指针,因此要用指向指针的指针
  27. //将插入到链表的末尾
  28. sqlist *q;
  29. q=(sqlist*)malloc(sizeof(sqlist));
  30. q->num_ch=e;
  31. q->bol=bl;
  32. q->next=NULL;
  33. (*p)->next=q;
  34. (*p)=(*p)->next;
  35.  //  PR("insert %d ,%dis succssed!n",e,bl);
  36. return OK;
  37. }
  39. int check(sqlist l)//保证输入的数字是给出的四个数字
  40. {
  41. int right=1,find=0,i;
  42. sqlist *q=&l;
  43. q=q->next ;
  44. for (;q->next!=NULL;q=q->next){
  45. if(q->bol==1){
  46. if(q->num_ch <=39||q->num_ch>57||q->num_ch==44||q->num_ch==46){
  47. //有效运算符的判断
  48. right=0;
  49. PR("%c不是有效的运算符!n");
  50. }
  51. }
  52. else {
  53. find=0;
  54. for(i=0;i<4;i++){
  55. if(number[1][i]==0&&number[0][i]==q->num_ch ){
  56. //控制使给出的四个数字出现且仅出现一次
  57. number[1][i]=1;
  58. find=1;
  59. break;
  60. }
  61. }
  62. if(find==0){
  63. PR("%d 不在给出的四个数字中!n",q->num_ch );
  64. right=0;
  65. }
  66. }
  67. }//end for
  68. for (i=0;i<4;i++){
  69. if(number[1][i]==0){
  70. PR("%d没有用上!n",number[0][i]);
  71. right=0;
  72. }
  73. }
  74. return right;
  75. }
  77. int chang(char *s,sqlist *l){
  78. //将用户的输入转化为单链表
  79. int t=0;
  80. unsigned int i=0;
  81.      int bl,ch;
  82. int a1,a2,a;
  83. sqlist *p=l;
  84. for (;i<strlen(s);i++){
  85. if(s[i]>47&&s[i]<58&&t==0){
  86. a1=(int)s[i]-48;
  87. t++;
  88. }
  89. else if(s[i]>47&&s[i]<58&&t==1){
  90. a2=(int)s[i]-48;
  91. a=a1*10+a2;
  92. t++;
  93.             }
  94. else if(s[i]<48&&s[i]>39&&s[i]!=44&&s[i]!=46){
  95. if(t==1){
  96.                         bl=0;
  97. insert_sq(&p,a1,bl);
  98.                 t=0;
  99. }
  100. else if(t==2){
  101. bl=0;
  102. insert_sq(&p,a,bl);
  103.                 t=0;
  104. }
  105. bl=1;
  106. ch=(int)s[i];
  107. insert_sq(&p,ch,bl);
  108.             t=0;
  109. }
  110. else {
  111. PR("%c不是有效的运算符!n",s[i]);
  112. }
  113. }   //end for
  114. i=strlen(s)-1;
  115. if(s[i]>47&&s[i]<58){
  116. if(s[i-1]>47&&s[i-1]<58){
  117.            bl=0;
  118.    insert_sq(&p,a,bl);
  119.    }
  120. else {
  121. bl=0;
  122. insert_sq(&p,a1,bl);
  123. }
  124. }
  125. bl=1;
  126. a=35;
  127. insert_sq(&p,a,bl);
  128. //   PR("chang is OKn");
  129. return (check(*l));//转化完成了之后判断是否合法
  130. }
  132. int Operate(int a,int theta, int b) {//计算a theta b
  133. // PR("a=%d,theta=%c,b=%dn",a,theta,b);
  134.    switch(theta) {
  136.       case 43: return a+b;
  137.       case 45: return a-b;
  138.       case 42: return a*b;
  139.       case 47:
  140.   {
  141.   if(b==0){
  142. return -2000;
  143. }
  144.   if (a%b==0){
  145.   return a/b;
  146.   }
  147.   else {//PR("不能为小数n");   
  148. return -10000;
  149.   }
  150.   }
  151.       default : return 0;
  152.    } 
  153. }
  155. int ReturnOpOrd(char op,char* TestOp) {
  156. //被char precede(char Aop, char Bop)所调用来求优先级
  157.    int i;
  158.    for(i=0; i< OPSETSIZE; i++) {
  159.       if (op == TestOp[i]) return i;
  160.    }
  161.    return 0;
  162. }
  164. char precede(char Aop, char Bop) {//返回优先级
  165. return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];   
  166. }
  168. status initstack(sqstack *s){
  169. (s)->base = (int*)malloc(STACK_INIF_SIZE*sizeof(int));
  170. if((s)->base==NULL) exit(OVERFLOW);
  171. (s)->top=(s)->base;
  172. (s)->stacksize = STACK_INIF_SIZE;
  173. // PR("栈初始化完成!n");
  174. return OK;
  175. }
  177. int gettop(sqstack *s){//取栈顶元素
  178. int e;
  179. if(s->top==s->base){
  180. PR("栈空,无法取得栈顶元素!n");
  181.  return 0;
  182.  }
  183. e=*(s->top-1);
  184. // PR("取得栈顶元素: %d n",e);
  185. return e;
  186. }
  188. status push(sqstack *s,int e){//把 e 压栈
  189. if(s->top-s->base>=s->stacksize){
  190. s->base=(int*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(int));
  191. if(!s->base) exit(OVERFLOW);
  192. s->stacksize+= STACKINCREMENT;
  193. }
  194. *(s->top++)=e;
  195.  //  PR("把 %d 压栈 is OKn",e);
  196. return OK;
  197. }
  199. status pop(sqstack *s,int *e){//出栈,用e 保存
  200. if(s->top==s->base){
  201. PR("栈空,出栈错误!n");
  202. return ERROR;
  203. }
  204. *e=*(--s->top);
  205. //   PR(" %d出栈成功 !n",*e);
  206. return OK;
  207. }
  209. int EvaluateExpression(char* MyExpression) {  // 算法3.4
  210.    // 算术表达式求值的算符优先算法。
  211.    // 设OPTR和&&OPND分别为运算符栈和运算数栈，OP为运算符集合。
  212. int result;
  213. sqstack  OPTR;    // 运算符栈，字符元素
  214.    sqstack  OPND;    // 运算数栈，实数元素
  215.    int c,bl,a,b,theta,top;
  216.    sqlist *q,l;  
  217.    char *s=MyExpression;
  218.    init_sq(&l);
  219.    if(chang(s,&l)!=0){
  220.    q=&l;
  221.    initstack(&OPTR);
  222.    push(&OPTR, 35);
  223.    initstack (&OPND);
  224.    q=q->next;
  225.    c=q->num_ch;
  226.    bl=q->bol;
  227.    while ((c!= 35 || gettop(&OPTR)!=35)){
  228.       if (bl!=1) {
  229.          push(&OPND, c);
  230.  q=q->next;
  231.  c=q->num_ch;
  232.  bl=q->bol;
  233.          } // 不是运算符则进栈
  234.      else {  
  235.  top=gettop(&OPTR);
  236. // PR("top  %c",top);
  237.  switch (precede(top, c)) { 
  238.             case '<': // 栈顶元素优先权低   
  239.                  push(&OPTR, c);    
  240.  q=q->next;
  241.  c=q->num_ch;  
  242.  bl=q->bol; 
  243.                  break;
  244.             case '=':   // 脱括号并接收下一字符
  245.                  pop(&OPTR, &c);     
  246.  q=q->next;
  247.  c=q->num_ch;  
  248.  bl=q->bol; 
  249.                  break;
  250.             case '>':   // 退栈并将运算结果入栈
  251.                  pop(&OPTR, &theta);
  252.                  pop(&OPND, &b);  
  253.                  pop(&OPND, &a);
  254. // PR("q->num_ch is %dn",q->num_ch);
  255.                  push(&OPND, Operate(a, theta, b)); 
  256.                  break;
  257. default :
  258. PR("没有这个运算符!n");
  259. return 0;
  260.          } // switch
  261.       }//else
  262.    } // while
  263.    result=gettop(&OPND);
  264.    return result;
  265.    }
  266.    else {
  267.   PR("你的输入有错误!n");
  268.    return 0;
  269.    }
  270. } // EvaluateExpression
  272. int randomm()//产生四个随机数
  273. {
  275. int i=0;
  276. srand((unsigned)time(NULL));
  277. for (;i<4;i++){
  278. number[0][i]=0;
  279. number[0][i]=rand();
  280. number[0][i]%=13;
  281. number[0][i]++;
  282. number[1][i]=0;
  283. }
  284. return number[2][4];
  285. }
  287.  int CalcOneExpress(int expression[][2])
  288.  {
  289.     // 算术表达式求值的算符优先算法。
  290.    // 设OPTR和&&OPND分别为运算符栈和运算数栈，OP为运算符集合。
  291. int index=0,result,c,theta,a,b;
  292. sqstack  OPTR;    // 运算符栈，字符元素
  293.    sqstack  OPND;    // 运算数栈，实数元素
  294.    initstack(&OPTR);
  295.    push(&OPTR, 35);
  296.    initstack (&OPND);
  297.    c=expression[index][0];
  298.    while (c!= 35 || gettop(&OPTR)!=35){
  299.       if (expression[index][1]!=1) {
  300.          push(&OPND, c);
  301.  index++;
  302.  c=expression[index][0];
  303.          } // 不是运算符则进栈
  304.      else {    
  305.  switch (precede(gettop(&OPTR), c)) { 
  306.             case '<': 
  307.   // 栈顶元素优先权低
  308.                  push(&OPTR, c);    
  309.  index++;
  310.  c=expression[index][0];     
  311.                  break;
  312.             case '=':   // 脱括号并接收下一字符
  313.                  pop(&OPTR, &c);     
  314.  index++;
  315.  c=expression[index][0];     
  316.                  break;
  317.             case '>':   // 退栈并将运算结果入栈
  318.                  pop(&OPTR, &theta);
  319.                  pop(&OPND, &b);  
  320.                  pop(&OPND, &a);
  321.                  push(&OPND, Operate(a, theta, b)); 
  322.                  break;
  323. default :
  324. PR("没有这个运算符n");
  325. return 0;
  326.          } // switch
  327.       }//else
  328.    } // while
  329.    result=gettop(&OPND);
  330.    return result;
  331. } // EvaluateExpression
  333.  /****************计算机计算模块*******************************/
  334.  int Equal24(int n)
  335.  {
  336.  if(n==24){
  337. // PR("the result is %dn",n);
  338.  return TRUE;
  339.  }
  340.  else    return FALSE;
  341.  }
  343.   //括号的几种情况
  344. //1 无括号
  345. //2 (a b) c d 同a b (c d), 下省略
  346. //3 (a b c) d
  347. //4 a (b c) d
  348. //5 (a b) (c d)
  349. //6 ((a b) c) d
  350. //7 (a (b c)) d
  351. int CalcArray1(int iNumInput[2][4])
  352. {
  353. // a * b * c * d //7 number
  354. int expression[8][2],ii,jj,kk;
  355. int i,j,k,l,dRes;
  356.     for(i=0;i<4;i++)
  357.     {
  358.         for(j=0;j<4;j++)    
  359.         {
  360.             if(j==i)
  361.             {
  362.                 continue;
  363.             }
  364.             for(k=0;k<4;k++)
  365.             {
  366.                 if(k==i||k==j)
  367.                 {
  368.                     continue;
  369.                 }
  370.                 for(l=0;l<4;l++)
  371.                 {
  372.                     if(l==i||l==j||l==k)
  373.                     {
  374.                         continue;
  375.                     }
  376.                     expression[0][0]=iNumInput[0][i];
  377.                     expression[2][0]=iNumInput[0][j];
  378.                     expression[4][0]=iNumInput[0][k];
  379.                     expression[6][0]=iNumInput[0][l];
  381. expression[0][1]=eNumber;
  382. expression[2][1]=eNumber;
  383. expression[4][1]=eNumber;
  384. expression[6][1]=eNumber;
  385. for (ii=0;ii<4;ii++)
  386. {
  387. for (jj=0;jj<4;jj++)
  388. {
  389. for (kk=0;kk<4;kk++)
  390. {
  392. expression[1][0] = oper[ii];
  393. expression[1][1] = eOperator;
  394. expression[3][0] = oper[jj];
  395. expression[3][1] = eOperator;
  396. expression[5][0] = oper[kk];
  397. expression[5][1] = eOperator;
  398. expression[7][0] = oper[6];
  399. expression[7][1] = eOperator;
  400. dRes = CalcOneExpress(expression);
  401. if(Equal24(dRes))
  402. {
  403. PR("可以这样运算:%d%c%d%c%d%c%dn",expression[0][0],oper[ii],expression[2][0],oper[jj],expression[4][0],oper[kk],expression[6][0]);
  404. return TRUE;
  405. }
  406. }
  407. }
  408. }//end of for oper
  409. }
  410. }
  411. }
  412. }
  413. return FALSE;
  414. }
  416. int CalcArray2(int iNumInput[2][4])
  417. {
  418. // (a * b) * c * d //9 number
  419. int expression[10][2];
  420. int ii,jj,i,j,k,l,kk;
  421. int dRes;
  422. // PR("CalcArray2n");
  423.     for(i=0;i<4;i++)
  424.     {
  425.         for(j=0;j<4;j++)    
  426.         {
  427.             if(j==i)
  428.             {
  429.                 continue;
  430.             }
  431.             for(k=0;k<4;k++)
  432.             {
  433.                 if(k==i||k==j)
  434.                 {
  435.                     continue;
  436.                 }
  437.                 for(l=0;l<4;l++)
  438.                 {
  439.                     if(l==i||l==j||l==k)
  440.                     {
  441.                         continue;
  442.                     }
  443.                     expression[1][0]=iNumInput[0][i];
  444.                     expression[3][0]=iNumInput[0][j];
  445.                     expression[6][0]=iNumInput[0][k];
  446.                     expression[8][0]=iNumInput[0][l];
  448. expression[1][1]=eNumber;
  449. expression[3][1]=eNumber;
  450. expression[6][1]=eNumber;
  451. expression[8][1]=eNumber;
  452. for (ii=0;ii<4;ii++)
  453. {
  454. for (jj=0;jj<4;jj++)
  455. {
  456. for (kk=0;kk<4;kk++)
  457. {
  459. expression[2][0] = oper[ii];
  460. expression[2][1] = eOperator;
  461. expression[5][0] = oper[jj];
  462. expression[5][1] = eOperator;
  463. expression[7][0] = oper[kk];
  464. expression[7][1] = eOperator;
  465. expression[9][0] = oper[6];
  466. expression[9][1] = eOperator;
  467. expression[0][0] = oper[4];
  468. expression[0][1] = eOperator;
  469. expression[4][0] = oper[5];
  470. expression[4][1] = eOperator;
  472. dRes = CalcOneExpress(expression);
  473. if(Equal24(dRes))
  474. {
  475. PR("可以这样运算:%c%d%c%d%c%c%d%c%dn",oper[4],expression[1][0],oper[ii],expression[3][0],oper[5],oper[jj],expression[6][0],oper[kk],expression[8][0]);
  476. return TRUE;
  477. }
  478. }
  479. }
  480. }//end of for oper
  481. }
  482. }
  483. }
  484. }
  485. return FALSE;
  486. }
  488. int CalcArray3(int iNumInput[2][4])
  489. {
  490. // (a * b * c) * d //9 number
  491. int expression[10][2];
  492. int ii,jj,i,j,k,l,kk;
  493. int dRes;
  494. // PR("CalcArray3n");
  495.     for(i=0;i<4;i++)
  496.     {
  497.         for(j=0;j<4;j++)    
  498.         {
  499.             if(j==i)
  500.             {
  501.                 continue;
  502.             }
  503.             for(k=0;k<4;k++)
  504.             {
  505.                 if(k==i||k==j)
  506.                 {
  507.                     continue;
  508.                 }
  509.                 for(l=0;l<4;l++)
  510.                 {
  511.                     if(l==i||l==j||l==k)
  512.                     {
  513.                         continue;
  514.                     }
  515.                     expression[1][0]=iNumInput[0][i];
  516.                     expression[3][0]=iNumInput[0][j];
  517.                     expression[5][0]=iNumInput[0][k];
  518.                     expression[8][0]=iNumInput[0][l];
  520. expression[1][1]=eNumber;
  521. expression[3][1]=eNumber;
  522. expression[5][1]=eNumber;
  523. expression[8][1]=eNumber;
  524. for (ii=0;ii<4;ii++)
  525. {
  526. for (jj=0;jj<4;jj++)
  527. {
  528. for (kk=0;kk<4;kk++)
  529. {
  531. expression[2][0] = oper[ii];
  532. expression[2][1] = eOperator;
  533. expression[4][0] = oper[jj];
  534. expression[4][1] = eOperator;
  535. expression[7][0] = oper[kk];
  536. expression[7][1] = eOperator;
  537. expression[9][0] = oper[6];
  538. expression[9][1] = eOperator;
  539. expression[0][0] = oper[4];
  540. expression[0][1] = eOperator;
  541. expression[6][0] = oper[5];
  542. expression[6][1] = eOperator;
  543. dRes = CalcOneExpress(expression);
  544. if(Equal24(dRes))
  545. {
  546. PR("可以这样运算:%c%d%c%d%c%d%c%c%dn",oper[4],expression[1][0],oper[ii],expression[3][0],oper[jj],expression[5][0],oper[5],oper[kk],expression[8][0]);
  547. return TRUE;
  549. }
  550. }
  551. }
  552. }//end of for oper
  553. }
  554. }
  555. }
  556. }
  557. return FALSE;
  558. }
  560. int CalcArray4(int iNumInput[2][4])
  561. {
  562. // (a * b * c) * d //9 number
  563. int expression[10][2];
  564. int ii,jj,i,j,k,l,kk;
  565. int dRes;
  566. // PR("CalcArray4n");
  567.     for(i=0;i<4;i++)
  568.     {
  569.         for(j=0;j<4;j++)    
  570.         {
  571.             if(j==i)
  572.             {
  573.                 continue;
  574.             }
  575.             for(k=0;k<4;k++)
  576.             {
  577.                 if(k==i||k==j)
  578.                 {
  579.                     continue;
  580.                 }
  581.                 for(l=0;l<4;l++)
  582.                 {
  583.                     if(l==i||l==j||l==k)
  584.                     {
  585.                         continue;
  586.                     }
  587.                     expression[0][0]=iNumInput[0][i];
  588.                     expression[3][0]=iNumInput[0][j];
  589.                     expression[5][0]=iNumInput[0][k];
  590.                     expression[8][0]=iNumInput[0][l];
  592. expression[0][1]=eNumber;
  593. expression[3][1]=eNumber;
  594. expression[5][1]=eNumber;
  595. expression[8][1]=eNumber;
  596. for (ii=0;ii<4;ii++)
  597. {
  598. for (jj=0;jj<4;jj++)
  599. {
  600. for (kk=0;kk<4;kk++)
  601. {
  602. expression[1][0] = oper[ii];
  603. expression[1][1] = eOperator;
  604. expression[4][0] = oper[jj];
  605. expression[4][1] = eOperator;
  606. expression[7][0] = oper[kk];
  607. expression[7][1] = eOperator;
  608. expression[9][0] = oper[6];
  609. expression[9][1] = eOperator;
  610. expression[2][0] = oper[4];
  611. expression[2][1] = eOperator;
  612. expression[6][0] = oper[5];
  613. expression[6][1] = eOperator;
  615. dRes = CalcOneExpress(expression);
  616. if(Equal24(dRes))
  617. {
  618. PR("可以这样运算:%d%c%c%d%c%d%c%c%dn",expression[0][0],oper[ii],oper[4],expression[3][0],oper[jj],expression[5][0],oper[5],oper[kk],expression[8][0]);
  619. return TRUE;
  621. }
  622. }
  623. }
  624. }//end of for oper
  625. }
  626. }
  627. }
  628. }
  629. return FALSE;
  630. }
  632. int CalcArray5(int iNumInput[2][4])
  633. {
  634. // (a * b) * (c * d) //11 number
  635. int expression[12][2];
  636. int ii,jj,i,j,k,l,kk;
  637. int dRes;
  638. // PR("CalcArray5n");
  639.     for(i=0;i<4;i++)
  640.     {
  641.         for(j=0;j<4;j++)    
  642.         {
  643.             if(j==i)
  644.             {
  645.                 continue;
  646.             }
  647.             for(k=0;k<4;k++)
  648.             {
  649.                 if(k==i||k==j)
  650.                 {
  651.                     continue;
  652.                 }
  653.                 for(l=0;l<4;l++)
  654.                 {
  655.                     if(l==i||l==j||l==k)
  656.                     {
  657.                         continue;
  658.                     }
  659.                     expression[1][0]=iNumInput[0][i];
  660.                     expression[3][0]=iNumInput[0][j];
  661.                     expression[7][0]=iNumInput[0][k];
  662.                     expression[9][0]=iNumInput[0][l];
  664. expression[1][1]=eNumber;
  665. expression[3][1]=eNumber;
  666. expression[7][1]=eNumber;
  667. expression[9][1]=eNumber;
  668. for (ii=0;ii<4;ii++)
  669. {
  670. for (jj=0;jj<4;jj++)
  671. {
  672. for (kk=0;kk<4;kk++)
  673. {
  674. expression[2][0] = oper[ii];
  675. expression[2][1] = eOperator;
  676. expression[5][0] = oper[jj];
  677. expression[5][1] = eOperator;
  678. expression[8][0] = oper[kk];
  679. expression[8][1] = eOperator;
  680. expression[11][0] = oper[6];
  681. expression[11][1] = eOperator;
  682. expression[0][0] = oper[4];
  683. expression[0][1] = eOperator;
  684. expression[6][0] = oper[4];
  685. expression[6][1] = eOperator;
  686. expression[4][0] = oper[5];
  687. expression[4][1] = eOperator;
  688. expression[10][0] = oper[5];
  689. expression[10][1] = eOperator;
  692. dRes = CalcOneExpress(expression);
  693. if(Equal24(dRes))
  694. {
  695. PR("可以这样运算:%c%d%c%d%c%c%c%d%c%d%cn",oper[4],expression[1][0],oper[ii],expression[3][0],oper[5],oper[jj],oper[4],expression[7][0],oper[kk],expression[9][0],oper[5]);
  696. return TRUE;
  698. }
  699. }
  700. }
  701. }//end of for oper
  702. }
  703. }
  704. }
  705. }
  706. return FALSE;
  707. }
  709. int CalcArray6(int iNumInput[2][4])
  710. {
  711. // ((a * b) * c) * d //11 number
  712. int expression[12][2];
  713. int ii,jj,i,j,k,l,kk;
  714. int dRes;
  715. // PR("CalcArray6n");
  716.     for(i=0;i<4;i++)
  717.     {
  718.         for(j=0;j<4;j++)    
  719.         {
  720.             if(j==i)
  721.             {
  722.                 continue;
  723.             }
  724.             for(k=0;k<4;k++)
  725.             {
  726.                 if(k==i||k==j)
  727.                 {
  728.                     continue;
  729.                 }
  730.                 for(l=0;l<4;l++)
  731.                 {
  732.                     if(l==i||l==j||l==k)
  733.                     {
  734.                         continue;
  735.                     }
  736.                     expression[2][0]=iNumInput[0][i];
  737.                     expression[4][0]=iNumInput[0][j];
  738.                     expression[7][0]=iNumInput[0][k];
  739.                     expression[10][0]=iNumInput[0][l];
  741. expression[2][1]=eNumber;
  742. expression[4][1]=eNumber;
  743. expression[7][1]=eNumber;
  744. expression[10][1]=eNumber;
  745. for (ii=0;ii<4;ii++)
  746. {
  747. for (jj=0;jj<4;jj++)
  748. {
  749. for (kk=0;kk<4;kk++)
  750. {
  752. expression[3][0] = oper[ii];
  753. expression[3][1] = eOperator;
  754. expression[6][0] = oper[jj];
  755. expression[6][1] = eOperator;
  756. expression[9][0] = oper[kk];
  757. expression[9][1] = eOperator;
  758. expression[11][0] = oper[6];
  759. expression[11][1] = eOperator;
  760. expression[0][0] = oper[4];
  761. expression[0][1] = eOperator;
  762. expression[1][0] = oper[4];
  763. expression[1][1] = eOperator;
  764. expression[5][0] = oper[5];
  765. expression[5][1] = eOperator;
  766. expression[8][0] = oper[5];
  767. expression[8][1] = eOperator;
  769. dRes = CalcOneExpress(expression);
  770. if(Equal24(dRes))
  771. {
  772. PR("可以这样运算:%c%c%d%c%d%c%c%d%c%c%dn",oper[4],oper[4],expression[2][0],oper[ii],expression[4][0],oper[5],oper[jj],expression[7][0],oper[5],oper[kk],expression[10][0]);
  773. return TRUE;
  774. }
  775. }
  776. }
  777. }//end of for oper
  778. }
  779. }
  780. }
  781. }
  782. return FALSE;
  783. }
  785. int CalcArray7(int iNumInput[2][4])
  786. {
  787. // (a * b * c) * d //9 number
  788. int expression[12][2];
  789. int ii,jj,i,j,k,l,kk;
  790. int dRes;
  791. // PR("CalcArray7n");
  792.     for(i=0;i<4;i++)
  793.     {
  794.         for(j=0;j<4;j++)    
  795.         {
  796.             if(j==i)
  797.             {
  798.                 continue;
  799.             }
  800.             for(k=0;k<4;k++)
  801.             {
  802.                 if(k==i||k==j)
  803.                 {
  804.                     continue;
  805.                 }
  806.                 for(l=0;l<4;l++)
  807.                 {
  808.                     if(l==i||l==j||l==k)
  809.                     {
  810.                         continue;
  811.                     }
  812.                     expression[1][0]=iNumInput[0][i];
  813.                     expression[4][0]=iNumInput[0][j];
  814.                     expression[6][0]=iNumInput[0][k];
  815.                     expression[10][0]=iNumInput[0][l];
  817. expression[1][1]=eNumber;
  818. expression[4][1]=eNumber;
  819. expression[6][1]=eNumber;
  820. expression[10][1]=eNumber;
  821. for (ii=0;ii<4;ii++)
  822. {
  823. for (jj=0;jj<4;jj++)
  824. {
  825. for (kk=0;kk<4;kk++)
  826. {
  827. expression[2][0] = oper[ii];
  828. expression[2][1] = eOperator;
  829. expression[5][0] = oper[jj];
  830. expression[5][1] = eOperator;
  831. expression[9][0] = oper[kk];
  832. expression[9][1] = eOperator;
  833. expression[11][0] = oper[6];
  834. expression[11][1] = eOperator;
  835. expression[0][0] = oper[4];
  836. expression[0][1] = eOperator;
  837. expression[3][0] = oper[4];
  838. expression[3][1] = eOperator;
  839. expression[7][0] = oper[5];
  840. expression[7][1] = eOperator;
  841. expression[8][0] = oper[5];
  842. expression[8][1] = eOperator;
  844. dRes = CalcOneExpress(expression);
  845. if(Equal24(dRes))
  846. {
  847. PR("可以这样运算:%c%d%c%c%d%c%d%c%c%c%dn",oper[4],expression[1][0],oper[ii],oper[4],expression[4][0],oper[jj],expression[6][0],oper[5],oper[5],oper[kk],expression[10][0]);
  848. return TRUE;
  849. }
  850. }
  851. }
  852. }//end of for oper
  853. }
  854. }
  855. }
  856. }
  857. return FALSE;
  858. }
  860. int Calc24(int number[2][4])
  861. {
  862. //括号的几种情况
  863. //1 无括号
  864. //2 (a b) c d 同a b (c d), 下省略
  865. //3 (a b c) d
  866. //4 a (b c) d
  867. //5 (a b) (c d)
  868. //6 ((a b) c) d
  869. //7 (a (b c)) d
  871. if (CalcArray1(number))//计算不含括号的情况
  872. return TRUE;
  873. if (CalcArray2(number))
  874. {  
  875. return TRUE;
  876. }
  877. if (CalcArray3(number))
  878. {  
  879. return TRUE;
  880. }
  881. if (CalcArray4(number))
  882. {  
  883. return TRUE;
  884. }
  885. if (CalcArray5(number))
  886. {  
  887. return TRUE;
  888. }
  889. if (CalcArray6(number))
  890. {  
  891. return TRUE;
  892. }
  893. if (CalcArray7(number))
  894. {  
  895. return TRUE;
  896. }
  897. PR("这四个数字不能算出24点.n");
  898. return FALSE;
  899. }
  900. /****************计算机计算模块*******************************/
  902. void game_24_main(){
  903. char s[40],ch,mood;
  904. int result,t=1,t0=1,nall=0,nright=0,t1=1;
  905. double right;
  906. while(t==1){
  907. PR("你想采用什么模式?n");
  908. PR("    ****************************************************n");
  909. PR("    *-------24点游戏菜单-------------------------------*n");
  910. PR("    *   计算机给出四个数字,你来算直到你想退出:-----0   *n");  
  911. PR("    *自己给出四个数字,要计算机来算,直到想退出:-----1   *n");
  912. PR("    *                            退出24点游戏:-----2   *n");
  913. PR("    ****************************************************n");
  914. PR("请选择模式：");
  915. mood=getch();
  916. PR("%cn",ch);
  917. // scanf( "  %c",&mood);
  918. if (mood=='0'){
  919. nall=0;
  920. nright=0;
  921. t0=1;
  922. while(t0==1){
  923. number[2][4]=randomm();
  924. PR("这四个数字是: %d   %d    %d   %dn",number[0][0],number[0][1],number[0][2],number[0][3]);
  925. PR("请输入算式n做上5道看看会有什么结果……n");
  926. PR("如果你认为这四个数算不出24点,请输入 ?n");
  927. PR("计算机将会给出答案,算不出也是一种答案!n");
  928. PR("你的算式是:");
  929. scanf ("%s",s);
  930. if(s[0]=='?'){
  931. if (Calc24(number)==1){
  932. nall++;
  933. }
  934. }
  935. else {
  936. result=EvaluateExpression(s);
  937. PR("你输入的算式的结果是: %d n",result);
  938. if(result==24){
  939. PR("恭喜您,你算对了!n");
  940. nright++;
  941. nall++;
  942.                     }
  943. else {
  944. PR("对不起,你算错了,谢谢!n");
  945. Calc24(number);
  946. nall++;
  947. }
  948. }//else
  949. PR("你共做了%d道,做对了%d道n",nall,nright);
  950. if (nall%5==0&&nall!=0){
  951. right=(double)nright/nall;
  952. PR("你的正确率为: %fn",right);
  953. if (right<0.5){
  954. PR("训练尚未成功,同志仍须努力!n");
  955. }
  956. else if(right>=0.5&&right<0.7){
  957. PR("不错不错,假以时日,必成良材!n");
  958. }
  959. else if(right>=0.7&&right<0.8){
  960. PR("将遇良材,非大战三百回合不可!n");
  961. }
  962. else if(right>=0.8&&right<0.96){
  963. PR("对你的敬佩之情,如滔滔江水,绵绵不绝---^^n");
  964. }
  965. else {
  966. PR("如此才智,老夫自愧不如n");
  967. }
  968. }
  969. PR("继续这个模式吗?请选择: 'y':继续 'n':退出?n");
  970. ch=getch();
  971.     // scanf(" %c",&ch);
  972. if(ch=='n'||ch=='N'){
  973. t0=0;
  974. }
  975. else  if (ch=='Y'||ch=='y')   t0=1;
  976. else{
  977. PR("你的选择(输入)有误!n"); 
  978. // t0=0;
  979.         }
  980. }//while mood 0
  981. }//end if mood 0
  982. else if (mood=='1'){
  983. t1=1;
  984. while (t1==1){
  985. PR("请输入四个正整数1-13:（用逗号隔开） ");
  986. scanf("%d,%d,%d,%d",&number[0][0],&number[0][1],&number[0][2],&number[0][3]);
  987. Calc24(number);
  988. PR("继续这个模式吗?请选择: 'y':继续 'n':退出?n");
  989. ch=getch();
  990. // scanf(" %c",&ch);
  991. if(ch=='n'||ch=='N'){
  992. t1=0;
  993. }
  994. else  if (ch=='Y'||ch=='y')   t1=1;
  995. else{
  996. PR("你的选择(输入)有误!n"); 
  997. t1=0;
  998.   }
  999. }
  1000. }//end mood 1
  1001. else if (mood=='2'){
  1002. // PR(" 再见!n");
  1003. t=0;
  1004. }
  1005. else {
  1006. PR("mood =%cn",mood);
  1007. PR("你的选择(输入)有误!n");
  1008. // t=0;
  1009. }
  1010. }//end big while 
  1011. }