如何用c写一个算24的小游戏

alyroot

上面两个程序，第一个修改了个笔误，调试倒是通过了。但是有点问题。
结果如下:
(9-8)*6+6=24
浮点数例外，为什么会有浮点数例外啊?
最近才开始linux下面的c/c++编程。
第二个编译也通过，不过运行结果如下:
[root@localhost cpp]# ./24-2
Enter four number!
6
9
8
3
段错误

段错误是什么意思啊?

我是在红旗4.0下做的。
请各位指点一下。

fog_proxy

楼主的程序似乎复杂了一点，不过精神可嘉。程序首先就是要能正常的工作，然后才考虑到算法的问题，如果工作都不正常，算法再好也是徒然。
后来的一位兄弟帖的算法，恕小弟愚昧，实在是看不懂的说，竟然还有从ARRAY[-N]中读值的！
我自己调试了一个，工作似乎还正常，大家测试测试吧。

1. 
   
2. /*
   
3. * This is just a game,to calculate 24,only support +,-,*,/
   
4. *
   
5. * Suppose A,B,C,D are numbers, a,b,c are operaters,there are cases as
   
6. * follow:
   
7. *
   
8. * (A a B) b C c D -> (E b C) c D, E b (C c D)
   
9. * A a (B b C) c D -> (A a E) c D, A a (E c D)
   
10. * A a B b (C c D) -> A a (B b E), (A a B) b E
    
11. *
    
12. * because E b (C c D) == (A a B) b E,there are only 5 cases.
    
13. *
    
14. * Fog,Sun Dec 28 03:13:15 2003
    
15. *
    
16. */
    
17. 
    
18. #include "stdio.h"
    
19. 
    
20. #define false 0
    
21. #define true  1
    
22. 
    
23. /* ((A a B) b C) c D */
    
24. #define DUMP_RESULT1()                                      \
    
25. {                                                           \
    
26.     printf("((%1.0f %c %1.0f) %c %1.0f) %c %1.0f = 24\n",   \
    
27.        a[p1],op[o1-1],                                      \
    
28.        a[p2],op[o2-1],                                      \
    
29.        a[p3],op[o3-1],                                      \
    
30.        a[p4]);                                              \
    
31.     found=true;                                             \
    
32. }
    
33. 
    
34. /* (A a (B b C)) c D */
    
35. #define DUMP_RESULT2()                                      \
    
36. {                                                           \
    
37.     printf("(%1.0f %c (%1.0f %c %1.0f)) %c %1.0f = 24\n",   \
    
38.        a[p1],op[o1-1],                                      \
    
39.        a[p2],op[o2-1],                                      \
    
40.        a[p3],op[o3-1],                                      \
    
41.        a[p4]);                                              \
    
42.     found=true;                                             \
    
43. }
    
44. 
    
45. /* A a ((B b C) c D) */
    
46. #define DUMP_RESULT3()                                      \
    
47. {                                                           \
    
48.     printf("%1.0f %c ((%1.0f %c %1.0f) %c %1.0f) = 24\n",   \
    
49.        a[p1],op[o1-1],                                      \
    
50.        a[p2],op[o2-1],                                      \
    
51.        a[p3],op[o3-1],                                      \
    
52.        a[p4]);                                              \
    
53.     found=true;                                             \
    
54. }
    
55. 
    
56. /* A a (B b (C c D)) */
    
57. #define DUMP_RESULT4()                                      \
    
58. {                                                           \
    
59.     printf("%1.0f %c (%1.0f %c (%1.0f %c %1.0f)) = 24\n",   \
    
60.        a[p1],op[o1-1],                                      \
    
61.        a[p2],op[o2-1],                                      \
    
62.        a[p3],op[o3-1],                                      \
    
63.        a[p4]);                                              \
    
64.     found=true;                                             \
    
65. }
    
66. 
    
67. /* (A a B) b (C c D) */
    
68. #define DUMP_RESULT5()                                      \
    
69. {                                                           \
    
70.     printf("(%1.0f %c %1.0f) %c (%1.0f %c %1.0f) = 24\n",   \
    
71.        a[p1],op[o1-1],                                      \
    
72.        a[p2],op[o2-1],                                      \
    
73.        a[p3],op[o3-1],                                      \
    
74.        a[p4]);                                              \
    
75.     found=true;                                             \
    
76. }
    
77. 
    
78. float r(float a0, float a1, int o)
    
79. {
    
80.     if (o == 1)
    
81.         return a0+a1;
    
82.     else if (o == 2)
    
83.         return a0-a1;
    
84.     else if (o == 3)
    
85.         return a0*a1;
    
86.     else if (o == 4)
    
87.         return a0/a1;
    
88. 
    
89.     return 0;
    
90. }   
    
91. 
    
92. int main()
    
93. {
    
94.     float a[4];
    
95.     char found = false;
    
96.     char op[4];
    
97.     int p1, p2, p3, p4;
    
98.     int o1,o2,o3;
    
99.    
    
100.     printf("Enter four number!\n");
     
101.     scanf("%f%f%f%f",&a[0],&a[1],&a[2],&a[3]);
     
102. 
     
103.     op[0] = '+';
     
104.     op[1] = '-';
     
105.     op[2] = '*';
     
106.     op[3] = '/';
     
107.    
     
108.     for(p1=0; p1<=3; p1++)
     
109.     {
     
110.         for(p2=0; p2<=3; p2++)
     
111.         {
     
112.             if (p2==p1)
     
113.                 continue;
     
114.             else
     
115.                 for(p3=0; p3<=3; p3++)
     
116.                 {
     
117.                     if ((p3==p2)||(p3==p1))
     
118.                         continue;
     
119.                     else{
     
120.                         p4 = 6 - p1 - p2 - p3;
     
121.                         for(o1=1; o1<=4; o1++)
     
122.                         {
     
123.                             if (found == true) break;
     
124.                             for(o2=1; o2<=4; o2++)
     
125.                             {
     
126.                                 if (found==true) break;   
     
127.                                 for(o3=1; o3<=4; o3++)
     
128.                                 {
     
129.                                     if (found == true) break;
     
130.                                     if (r(r(r(a[p1],a[p2],o1),a[p3],o2),a[p4],o3)==24)
     
131.                                     {
     
132.                                         DUMP_RESULT1();
     
133.                                         break;
     
134.                                     }
     
135.                                     if (r(r(a[p1],r(a[p2],a[p3],o2),o1),a[p4],o3)==24)
     
136.                                     {  
     
137.                                         DUMP_RESULT2();
     
138.                                         break;
     
139.                                     }
     
140.                                     if (r(a[p1],r(r(a[p2],a[p3],o2),a[p4],o3),o1)==24)
     
141.                                     {  
     
142.                                         DUMP_RESULT3();
     
143.                                         break;
     
144.                                     }                                    
     
145.                                     if (r(a[p1],r(a[p2],r(a[p3],a[p4],o3),o2),o1)==24)
     
146.                                     {
     
147.                                         DUMP_RESULT4();
     
148.                                         break;
     
149.                                     }
     
150.                                     if (r(r(a[p1],a[p2],o1),r(a[p3],a[p4],o3),o2)==24)
     
151.                                     {
     
152.                                         DUMP_RESULT5();
     
153.                                         break;
     
154.                                     }
     
155.                                 }
     
156.                             }
     
157.                         }        
     
158.                     }
     
159.                     if (found == true) break;            
     
160.                 }
     
161.         }
     
162.     }
     
163.    
     
164.     if (found == false)
     
165.         printf("Ask god for the solution :-)\n");
     
166. 
     
167.     return 0;
     
168. }
     

复制代码

alyroot

测试正常。学习中。

alyroot

else if (o == 4)
        return a0/a1;
应该修改为
else if (o == 4&&a1!=0)
        return a0/a1;
否则对于5，5，5，5结果为
(5-5)/(5-5)=24拉。呵呵

fog_proxy

不错，bug一个。Thanks.

liaoya

注意程序是用后缀表达式计算，思路非常简单，穷举所有的数(这里会有重复)，产生所有的后缀表达式的排列，计算后缀表达式我想大家没有任何的疑义，只是我没有写从后缀表达式转化韦中缀表达式的函数，因为我觉得这个不时算法的关键，这个代码穷举了所有的能够产生结果韦24的数据组合。

include <stdio.h>

#include <stdlib.h>



#define dim(list) (sizeof(list) / sizeof(list[0]))



/* typedef enum {add = 0, sub, multi, div}operator; */

static unsigned char operatortable[4] = {'+', '-', '*', '/'};

static unsigned char operatorlist[64][4];

static unsigned int operand[4];



static void genrate_operatorlist();

static void print_operatorlist();

static void genrate_operand();

static void test();

static float cal_expr(char operatorstack[4], const int size);

static void print_expr(char operatorstack[4]);



int main(){

    genrate_operatorlist();

    /* print_operatorlist(); */

    genrate_operand();

    test();

    return 0;

}



void genrate_operatorlist(){

    int i = 0, j = 0, k = 0, cnt =0;

    for (i = 0; i < dim(operatortable); ++i){

        for (j = 0; j < dim(operatortable); ++j){

                for (k = 0; k < dim(operatortable); ++k){

                        operatorlist[cnt][0] = operatortable;

                        operatorlist[cnt][1] = operatortable[j];

                        operatorlist[cnt][2] = operatortable[k];

                        operatorlist[cnt][3] = '\0';

                        cnt++;

                }

        }

    }

}



void print_operatorlist(){

        int i = 0, j = 0;

        for (i = 0; i < dim(operatorlist); ++i){

                for (j = 0; j < dim(operatorlist[0]); ++j){

                        printf("%c", operatorlist[j]);

                  }

                  printf("\n");

        }

}



void genrate_operand(){

        const int maxnum = 10;

    int i = 0, j = 0, k = 0, l = 0, cnt = 0;

    for (i = 1; i <= maxnum; ++i){

        for (j = 1; j <= maxnum; ++j){

                for (k = 1; k <= maxnum; ++k){

                        for (l = 1; l <= maxnum; ++l){

                                operand[0] = i;

                                operand[1] = j;

                                operand[2] = k;

                                operand[3] = l;

                                for(cnt = 0; cnt < dim(operatorlist); ++cnt){

                                        if (cal_expr(operatorlist[cnt], 3) == 24)

                                                print_expr(operatorlist[cnt]);

                                   }

                          }

                }

        }

    }       

}



void test(){

        FILE *fp;

        int cnt;

        if (!(fp = fopen("input.txt", "r"))){

                printf("\nCan not open input.txt\n");

                exit(-1);

        }

        while(!feof(fp)){

                if(1 > fscanf(fp, "%d %d %d %d", &operand[0], &operand[1], &operand[2], &operand[3]))

                                break;

        else{

                for(cnt = 0; cnt < dim(operatorlist); ++cnt){

                        if (cal_expr(operatorlist[cnt], 3) == 24)

                                print_expr(operatorlist[cnt]);

                }

                }

        }

        fclose(fp);

}



float cal_expr(char operatorstack[4], const int size){

        int i = 0, j = size;

        float result = operand[j--];

        for(i = 0; i < size; ++i, --j){

                switch(operatorstack){

                        case '+' : result += operand[j]; break;

                        case '-' : result -= operand[j]; break;

                        case '*' : result *= operand[j]; break;

                        case '/' : result /= operand[j]; break;

                        default : break;

                  }

        }

        return result;

}



void print_expr(char operatorstack[4]){

        int i = 0;

        for (i = 0; i < dim(operand); ++i){

                printf("%d", operand);

        }

        printf("%s\n", operatorstack);

}

liaoya

很容易改造成判断四个数能否组合出24.

CSD

罗列全部是最容易想到的方法,24点问题很明显是用来练算法的,至于要来软件工程的那一套,似乎小题大作了吧.
我还是一个学生,希望前辈指点.

simplelife

果然还是穷举

simplelife

果然还是穷举