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

niuzilu

Post by scream
我的设想是这样的：首先计算机给出四个随机数，然后
*如果这四个数可以计算出24则等待直到用户按键，显示出计算方法；
*如果这四个数不能计算出24则显示impossible；

其中我想不明白的有两点：

（1）怎么实现让计算机随机给出一个数？

（2）计算机怎么自己计算24，难道是人工智能？

我觉得应该用递归回溯解决！我也写个

niuzilu

Post by winix
热情固然可嘉，但不要忘记：算法+数据结构=程序

Up till now Absolutely right.
如果有那么一天计算机的解构改变了，也就是说冯诺-依曼结构给别的××结构取代的时候，
这个定理就不一定对了，个人愚见。

chai2010

bobhuang
我以前写过一个算5个5的24点算法，临时写的，输入输出不是很规范
输出4次计算所用的算符和计算的位置（总共计算4次，在4个位置上），给楼主做参考
====================

感觉这个算法不完整
如果是(3-1)*(8+4)这种情况你如何判断呢？

chai2010

Post by doubleelec
o my god！

要是这道题要求用八个数来做，这个程序不知道要写成什么样了。


刚才没看到第三页，现在好多了。

如果要是处理数据变化的话可以考虑用递归
这样理解简单些：


// 把输入的数据看做一个集合，集合中有n个元素
// 从n个元素中取2个元素共有max组合
// 对每个组合中的2个元素进行+-*/运算
// 把运算的结果替换n集合中取出的2个元素
// 现在集合中有(n-1)个元素
// 对含有(n-1)个元素的新集合递归进行上述判断
// 如果集合只剩下1个元素，则就是最终结果

MooreChow

被jerboa感动了一下

soloforce

用C++写了一个，可以计算任意个数字，任意计算目标（未必是24），输出所有可能的计算式（但类似 a+b, b+a ; a*b, b*a 之类的只输出一种 ）。 应该是目前为止最完善最灵活的一个解决方案了:cool:

1. //--------------------------------------------------------
2. // “算24”游戏：若干个数，通过 + - * / 四则运算，求出等于目标数值的表达式。
3. // by Lolita@linuxsir.cn 2006-09-06
4. //
5. // 算法： (引用 chai2010@linuxsir.cn)
6. // 把输入的数据看做一个集合，集合中有n个元素。
7. // 从集合中任取2个元素分别进行+-*/运算，
8. // 把运算的结果替换n集合中取出的2个元素
9. // 现在集合中有(n-1)个元素
10. // 对含有(n-1)个元素的新集合递归进行上述判断
11. // 如果集合只剩下1个元素且该，则就是最终结果
12. //
13. // 实现： C++， vector， 递归
14. //
15. //--------------------------------------------------------
17. #include <iostream>
18. #include <sstream>
19. #include <vector>
20. using namespace std;
22. //参与“算24”的运算类型，最好是浮点数
23. typedef float data_t;
24. //默认为计算24
25. data_t TARGET=24;
27. #define GET_EXPR(des,src) do{     \
28.     if(src.expr.str().empty())    \
29.         des.expr<<src.data;       \
30.     else des.expr<<src.expr.str();\
31. }while(0)
33. class element{
34.     friend element operator+(element &, element &);
35.     friend element operator-(element &, element &);
36.     friend element operator*(element &, element &);
37.     friend element operator/(element &, element &);
38.     friend vector<element>& cal_target(vector<element> );
39. private:
40.     data_t data;
41.     ostringstream expr;
42. public:
43.     element(data_t const& x):data(x){ }
44.     element(element const& rhs):data(rhs.data){ expr<<rhs.expr.str(); }
45.     element& operator=(element const&);
46.     void show_expr() { cout<<expr.str(); }
47.   
48. };
50. element& element::operator=(element const& rhs)
51. {
52.     if(this!=&rhs){
53.         data=rhs.data;
54.         expr.str("");
55.         expr<<rhs.expr.str();
56.     }
57.     return *this;
58. }
60. element operator+(element& rhs1, element& rhs2)
61. {
62.     element ret(rhs1.data+rhs2.data);
63.    
64.     ret.expr<<"(";
65.     GET_EXPR(ret,rhs1);
66.     ret.expr<<"+";
67.     GET_EXPR(ret,rhs2);
68.     ret.expr<<")";
69.     return ret;
70. }
73. element operator-(element & rhs1, element & rhs2)
74. {
75.     element ret(rhs1.data-rhs2.data);
76.    
77.     ret.expr<<"(";
78.     GET_EXPR(ret,rhs1);
79.     ret.expr<<"-";
80.     GET_EXPR(ret,rhs2);
81.     ret.expr<<")";
82.     return ret;
83. }
86. element operator*(element& rhs1, element& rhs2)
87. {
88.     element ret(rhs1.data*rhs2.data);
89.    
90.     ret.expr<<"(";
91.     GET_EXPR(ret,rhs1);   
92.     ret.expr<<"*";
93.     GET_EXPR(ret,rhs2);
94.     ret.expr<<")";
95.     return ret;
96. }
99. element operator/(element& rhs1, element& rhs2)
100. {
101.     if(rhs2.data){
102.         element ret(rhs1.data/rhs2.data);
103.    
104.         ret.expr<<"(";
105.         GET_EXPR(ret,rhs1);
106.         ret.expr<<"/";
107.         GET_EXPR(ret,rhs2);
108.         ret.expr<<")";
109.         return ret;
110.     }else{
111.         cerr<<"divide by 0 error!"<<endl;
112.         abort();
113.     }
114. }
117. vector<element>& cal_target( vector<element>  vt )
118. {
119.     vector<element>::iterator it,it1,it2;
120.     static vector<element> result;
121.    
122.     if(vt.empty())return result;
123.     else if(vt.size()==1){
124.         element e=vt.back();
125.         if(e.data==TARGET)result.push_back(e);
126.     }else{
127.         for(it1=vt.begin(); it1<vt.end()-1; it1++){
128.              for(it2=it1+1; it2<vt.end(); it2++){
129.                 element e1=*it1;
130.                 element e2=*it2;                  
131.                 it2=vt.erase(it2); // remove 2 elements
132.                 it1=vt.erase(it1); // CAUTION: e2 should erase first !
133.                
134.                 vt.push_back(e1+e2);
135.                 cal_target(vt);
136.                 vt.pop_back();
137.                
138.                 vt.push_back(e1-e2);
139.                 cal_target(vt);
140.                 vt.pop_back();
141.                
142.                 vt.push_back(e2-e1);
143.                 cal_target(vt);
144.                 vt.pop_back();
145.                
146.                 vt.push_back(e1*e2);
147.                 cal_target(vt);
148.                 vt.pop_back();
149.                
150.                 if(e2.data){
151.                     vt.push_back(e1/e2);
152.                     cal_target(vt);
153.                     vt.pop_back();
154.                 }
155.                
156.                 if(e1.data){
157.                     vt.push_back(e2/e1);
158.                     cal_target(vt);
159.                     vt.pop_back();
160.                 }
161.                
162.                 it1=vt.insert(it1,e1);  // recover vector               
163.                 it2=vt.insert(it2,e2);  // CAUTION: e1 should insert first !
164.             }
165.         }
166.     }
167.     return result;
168. }
170. int main()
171. {
172.     // 参与运算的数组，个数、数值可以随意设定
173.     element arr[]={3,6,2,15};
174.     // 运算目标，默认为24, 可以随意设定
175.     TARGET=24;
176.       
177.     vector<element> vt(arr, arr+sizeof(arr)/sizeof(arr[0]));
178.     vector<element>::iterator it;
179.    
180.     vector<element> result=cal_target(vt);
181.     if(result.empty())cout<<"impossible!"<<endl;
182.     else{
183.         for(it=result.begin(); it!=result.end(); it++){
184.             it->show_expr();
185.             cout<<" = "<<TARGET<<endl;
186.         }
187.         cout<<"--------------------"<<endl;
188.         cout<<"solutions found: "<<result.size()<<endl;
189.     }
190. }

复制代码

~/coding/cpp $ g++ cal24.cc
~/coding/cpp $ ./a.out
(2*(15+(3-6))) = 24
(2*(15-(6-3))) = 24
(15+((3*6)/2)) = 24
(15+(6*(3/2))) = 24
(15+(6/(2/3))) = 24
(2*((3+15)-6)) = 24
((6*2)-(3-15)) = 24
((15-3)+(6*2)) = 24
((6*2)-(3-15)) = 24
((6*2)+(15-3)) = 24
(15-(3-(6*2))) = 24
(15+((6*2)-3)) = 24
((15+(6*2))-3) = 24
(15+(3*(6/2))) = 24
(15+(3/(2/6))) = 24
(2*(3-(6-15))) = 24
(2*(3+(15-6))) = 24
--------------------
solutions found: 17

soloforce

由于考虑的可能性比较多，所以5个元素以上的时候比较花时间。

soloforce

2. //--------------------------------------------------------
3. // 交互式“算24”游戏：若干个数，通过 + - * 四则运算（包括括号），
4. // 求出等于目标数值的表达式。 提供人机交互操作，包含两种模式： 用户输入和随机生成。
5. // by Lolita@linuxsir.cn 2006-09-07
6. //
7. // 算法： (引用 chai2010@linuxsir.cn)
8. // 把输入的数据看做一个集合，集合中有n个元素。
9. // 从集合中任取2个元素分别进行+-*/运算，
10. // 把运算的结果替换n集合中取出的2个元素
11. // 现在集合中有(n-1)个元素
12. // 对含有(n-1)个元素的新集合递归进行上述判断
13. // 如果集合只剩下1个元素且该，则就是最终结果
14. //
15. // 实现： C++， vector， 递归
16. //
17. //--------------------------------------------------------
19. #include <iostream>
20. #include <sstream>
21. #include <vector>
22. #include <cstdlib>
23. #include <ctime>
24. using namespace std;
26. //参与“算24”的运算类型，最好是浮点数
27. typedef float data_t;
29. #define GET_EXPR(des,src) do{     \
30.     if(src.expr.str().empty())           \
31.         des.expr<<src.data;             \
32.     else des.expr<<src.expr.str();   \
33. }while(0)
35. class element{
36.     friend element operator+(element &, element &);
37.     friend element operator-(element &, element &);
38.     friend element operator*(element &, element &);
39.     friend element operator/(element &, element &);
40.     friend void cal_target(vector<element> );
41.     friend class NumberGame;
42. private:
43.     data_t data;
44.     ostringstream expr;
45. public:
46.     element(data_t const& x):data(x){ }
47.     ~element(){ expr.str(""); data=0; }
48.     element(element const& rhs):data(rhs.data){ expr<<rhs.expr.str(); }
49.     element& operator=(element const&);
50.     void show_expr() { cout<<expr.str(); }
51.     void show_data() { cout<<data; }
52.   
53. };
55. element& element::operator=(element const& rhs)
56. {
57.     if(this!=&rhs){
58.         data=rhs.data;
59.         expr.str("");
60.         expr<<rhs.expr.str();
61.     }
62.     return *this;
63. }
65. element operator+(element& rhs1, element& rhs2)
66. {
67.     element ret(rhs1.data+rhs2.data);
68.    
69.     ret.expr<<"(";
70.     GET_EXPR(ret,rhs1);
71.     ret.expr<<"+";
72.     GET_EXPR(ret,rhs2);
73.     ret.expr<<")";
74.     return ret;
75. }
78. element operator-(element & rhs1, element & rhs2)
79. {
80.     element ret(rhs1.data-rhs2.data);
81.    
82.     ret.expr<<"(";
83.     GET_EXPR(ret,rhs1);
84.     ret.expr<<"-";
85.     GET_EXPR(ret,rhs2);
86.     ret.expr<<")";
87.     return ret;
88. }
91. element operator*(element& rhs1, element& rhs2)
92. {
93.     element ret(rhs1.data*rhs2.data);
94.    
95.     ret.expr<<"(";
96.     GET_EXPR(ret,rhs1);   
97.     ret.expr<<"*";
98.     GET_EXPR(ret,rhs2);
99.     ret.expr<<")";
100.     return ret;
101. }
104. element operator/(element& rhs1, element& rhs2)
105. {
106.     if(rhs2.data){
107.         element ret(rhs1.data/rhs2.data);
108.    
109.         ret.expr<<"(";
110.         GET_EXPR(ret,rhs1);
111.         ret.expr<<"/";
112.         GET_EXPR(ret,rhs2);
113.         ret.expr<<")";
114.         return ret;
115.     }else{
116.         cerr<<"divide by 0 error!"<<endl;
117.         abort();
118.     }
119. }
122. class NumberGame{
123. private:
124.     vector<element> result;
125.     vector<element> vin;
126.     data_t target;
127.     void init();
128.     void cal_target(vector<element>);
129.     void generate();
130.     void show_puzzle();
131.     void show_keypress();
132.     void show_one_answer();
133.     void show_all_answers();
134. public:
135.     NumberGame(){}
136.     ~NumberGame(){ result.clear(); vin.clear(); }
137.     bool input();
138.     bool output();
139.     bool random();
140.    
141. };
143. void NumberGame::init()
144. {
145.     vin.clear();
146.     result.clear();
147. }
149. bool NumberGame::input()
150. {
151.     data_t e;
153.     int count=0;        
154.     cout<<endl<<"How many numbers will you input( 0 to quit): ";
155.     cin>>count;
156.     if(count<1) return false;
157.     if( count>8 ){
158.         cout<<"Are you crazy? It may take a very long time to figure it out !"<<endl;
159.     }
160.    
161.     init();
162.     for(int i=1;i<=count;i++){
163.         cout<<"num"<<i<<": ";
164.         cin>>e;
165.         vin.push_back(e);
166.     }
167.     cout<<"Your TARGET number: ";
168.     cin>>target;
170.     cal_target(vin);
171.    
172.     return true;
173. }
175. bool NumberGame::output()
176. {
177.     show_all_answers();
178.     return true;
179. }
181. void NumberGame::generate()
182. {
183.     do{
184.         init();
185.         srand(time(NULL));
186.         target=10+rand()%15;
187.         int count=3+rand()%2;
188.         for(int i=1; i<=count; i++){
189.             vin.push_back( rand()%10 );
190.             //delay();
191.         }
192.         cal_target(vin);
193.     }while(result.empty());
194. }
196. void NumberGame::show_puzzle()
197. {
198.     vector<element>::iterator it;
199.     cout<<"----------------------"<<endl;
200.     for(it=vin.begin(); it!=vin.end(); it++)
201.         cout<<it->data<<" ";
202.     cout<<" = "<<target<<"  ?"<<endl<<"----------------------"<<endl;
203. }
205. void NumberGame::show_keypress()
206. {
207.     cout<<"'a': get an answer; ";
208.     cout<<"'A' all answers; ";
209.     cout<<"'n' to next puzzle; ";
210.     cout<<"'q' to quit."<<endl;
211. }
213. void NumberGame::show_one_answer()
214. {
215.     static vector<element>::iterator it;
216.    
217.     // set it to a right answer
218.     if(it<result.begin() || it>=result.end() )
219.         it=result.begin();
220.         
221.     if( it!=result.end() ){
222.         if(!it->expr.str().empty())it->show_expr();
223.         else it->show_data();
224.         cout<<" = " <<target<<endl;
225.         it++;
226.     }else cout<<"no other solutions found!"<<endl;
227.    
228. }
230. void NumberGame::show_all_answers()
231. {
232.     vector<element>::iterator it;
233.     if(result.empty())cout<<"no solutions found!"<<endl;
234.     else{
235.         for(it=result.begin();it!=result.end();it++){
236.             if(!it->expr.str().empty()) it->show_expr();
237.             else it->show_data();
238.             cout<<" = "<<target<<endl;
239.         }
240.         cout<<"--------------------"<<endl;
241.         cout<<"solutions found: "<<result.size()<<endl;
242.     }
243. }
245. bool NumberGame::random()
246. {
247.     cout<<"Generating puzzle ... "<<endl;
248.     generate();
249.     show_puzzle();
250.     show_keypress();
251.     char ch;
252.    
253.     while(1){
254.         cin.clear();
255.         cin.get(ch);
256.         switch(ch)
257.         {
258.         case 'a':
259.             show_one_answer();
260.             break;
261.         case 'A':
262.             show_all_answers();
263.             break;
264.         case 'n':
265.         case 'N':
266.             generate();
267.             show_puzzle();
268.             show_keypress();
269.             break;
270.         case 'q':
271.         case 'Q':
272.             return false;
273.             break;
274.         default:
275.             cout<<": ";
276.             break;
277.         }
278.     }
279.     return true;
280.    
281. }
283. void NumberGame::cal_target( vector<element> vt )
284. {
285.     vector<element>::iterator it,it1,it2;
286.    
287.     if(vt.empty())return;
288.     if(vt.size()==1){
289.         element e=vt.back();
290.         if(e.data==target)result.push_back(e);
291.         return;   
292.     }
293.     for(it1=vt.begin(); it1<vt.end()-1; it1++){
294.         for(it2=it1+1; it2<vt.end(); it2++){
295.             element e1=*it1;
296.             element e2=*it2;                  
297.             it2=vt.erase(it2); // remove 2 elements
298.             it1=vt.erase(it1); // CAUTION: e2 should erase first !
299.                
300.             vt.push_back(e1+e2);
301.             cal_target(vt);
302.             vt.pop_back();
303.                
304.             vt.push_back(e1-e2);
305.             cal_target(vt);
306.             vt.pop_back();
307.                
308.             vt.push_back(e2-e1);
309.             cal_target(vt);
310.             vt.pop_back();
311.                
312.             vt.push_back(e1*e2);
313.             cal_target(vt);
314.             vt.pop_back();
315.                
316.             if(e2.data){
317.                 vt.push_back(e1/e2);
318.                 cal_target(vt);
319.                 vt.pop_back();
320.             }
321.                
322.             if(e1.data){
323.                 vt.push_back(e2/e1);
324.                 cal_target(vt);
325.                 vt.pop_back();
326.             }
327.                
328.             it1=vt.insert(it1,e1);  // recover vector               
329.             it2=vt.insert(it2,e2);  // CAUTION: e1 should insert first !
330.         }
331.     }
332.     return;
333. }
335. int main()
336. {
337.     NumberGame game;
338.     cout<<"[1] user input"<<endl;
339.     cout<<"[2] random test" <<endl;
340.     cout<<"[0] quit"<<endl;
341.     cout<<"select the number(0/1/2): ";
342.     char ch;
343.     cin.get(ch);
344.     cin.clear();
345.     switch(ch){
346.     case '1':
347.         while(game.input() && game.output());
348.         break;
349.     case '2':
350.         game.random();
351.         break;
352.     default:
353.         return 0;
354.     }
355. }

复制代码

rickxbx

今天看精华,看到了这篇帖子, 找出了以前写的算 24 的程序:

2. #include <stdio.h>
4. void get_arr(int arr[][4], int numbers[], int len){
5.   int i,j,k=0;
6.   for(i=0;i<len;i++){
7.     for(j=i+1;j<len;j++){
8.       arr[k][0] = numbers[i];
9.       arr[k][1] = numbers[j];
10.       arr[k][2] = i;
11.       arr[k++][3] = j;
12.     }
13.   }
14. }
16. void fill_arr(int to[], int len, int from[], int i, int j){
17.   int _i,_j = 0;
18.   for(_i=0;_i<len;_i++){
19.     if(_i!=i && _i!=j)
20.       to[_j++] = from[_i];
21.   }
22. }
24. int calculate(int numbers[], int len, int sum){
25.   int i,arr[len*(len-1)/2][4];
27.   if(len==1){
28.     if(numbers[0]==sum)
29.       return 0;
30.     return 1;
31.   }
32.   get_arr(arr,numbers,len);
33.   for(i=0;i<len*(len-1);i++){
34.     int _numbers[len-1];
35.     fill_arr(_numbers,len,numbers,arr[i][2],arr[i][3]);
36.     _numbers[len-2] = arr[i][0]+arr[i][1];
37.     if(!calculate(_numbers,len-1,sum)){
38.       printf("%d + %d = %d\n",arr[i][0],arr[i][1],arr[i][0]+arr[i][1]);
39.       return 0;
40.     }
41.     _numbers[len-2] = arr[i][0]-arr[i][1];
42.     if(_numbers[len-2]>0){
43.       if(!calculate(_numbers,len-1,sum)){
44.         printf("%d - %d = %d\n",arr[i][0],arr[i][1],arr[i][0]-arr[i][1]);
45.         return 0;
46.       }
47.     }else{
48.       _numbers[len-2] = -_numbers[len-2];
49.     if(_numbers[len-2]>0){
50.       if(!calculate(_numbers,len-1,sum)){
51.         printf("%d - %d = %d\n",arr[i][0],arr[i][1],arr[i][0]-arr[i][1]);
52.         return 0;
53.       }
54.     }else{
55.       _numbers[len-2] = -_numbers[len-2];
56.       if(!calculate(_numbers,len-1,sum)){
57.         printf("%d - %d = %d\n",arr[i][1],arr[i][0],arr[i][1]-arr[i][0]);
58.         return 0;
59.       }
60.     }
61.     _numbers[len-2] = arr[i][0]*arr[i][1];
62.     if(!calculate(_numbers,len-1,sum)){
63.       printf("%d * %d = %d\n",arr[i][0],arr[i][1],arr[i][0]*arr[i][1]);
64.       return 0;
65.     }
66.     if(arr[i][0] && !(arr[i][1]%arr[i][0])){
67.       _numbers[len-2] = arr[i][1]/arr[i][0];
68.       if(!calculate(_numbers,len-1,sum)){
69.         printf("%d / %d = %d\n",arr[i][1],arr[i][0],arr[i][1]/arr[i][0]);
70.         return 0;
71.       }
72.     }
73.     if(arr[i][1] && !(arr[i][0]%arr[i][1])){
74.       _numbers[len-2] = arr[i][0]/arr[i][1];
75.       if(!calculate(_numbers,len-1,sum)){
76.         printf("%d / %d = %d\n",arr[i][0],arr[i][1],arr[i][0]/arr[i][1]);
77.         return 0;
78.       }
79.     }
80.   }
81.   return 1;
82. }
84. int main(){
85.   int numbers[] = {3,2,6,4};
86.   calculate(numbers,4,24);
87.   return 0;
88. }

复制代码

rickxbx

还有一个 scheme 的:

2. (define (get-composite numbers)
3.   (letrec ((part (lambda (x alist)
4.                    (map (lambda (y) (list x y)) alist))))
5.     (if (null? numbers)
6.         '()
7.         (append (part (car numbers) (cdr numbers))
8.                 (get-composite (cdr numbers))))))
10. (define (remove-first x alist)
11.   (cond ((null? alist) '())
12.         ((= x (car alist)) (cdr alist))
13.         (else (cons (car alist) (remove-first x (cdr alist))))))
15. (define (remove-last x alist)
16.   (reverse (remove-first x (reverse alist))))
18. (define (iter1 numbers sum result composites)
19.   (let ((remove-two (lambda (items alist)
20.                       (remove-first (cadr items) (remove-first (car items) alist))))
21.         (arg1 (if (not (null? composites))
22.                   (caar composites)))
23.         (arg2 (if (not (null? composites))
24.                   (cadar composites))))
25.     (if (null? composites)
26.         'ok
27.         (begin
28.           (iter2 (cons (+ arg1 arg2)
29.                        (remove-two (car composites) numbers))
30.                  sum
31.                  (append result (list (list arg1 '+ arg2 '= (+ arg1 arg2)))))
32.           (iter2 (cons (- arg1 arg2)
33.                        (remove-two (car composites) numbers))
34.                  sum
35.                  (append result (list (list arg1 '- arg2 '= (- arg1 arg2)))))
36.           (iter2 (cons (- arg2 arg1)
37.                        (remove-two (car composites) numbers))
38.                  sum
39.                  (append result (list (list arg2 '- arg1 '= (- arg2 arg1)))))
40.           (iter2 (cons (* arg1 arg2)
41.                        (remove-two (car composites) numbers))
42.                  sum
43.                  (append result (list (list arg1 '* arg2 '= (* arg1 arg2)))))
44.           (if (and (not (= arg2 0)) (= 0 (remainder arg1 arg2)))
45.               (iter2 (cons (/ arg1 arg2)
46.                      (remove-two (car composites) numbers))
47.                      sum
48.                      (append result (list (list arg1 '/ arg2 '= (/ arg1 arg2))))))
49.           (if (and (not (= arg1 0)) (= 0 (remainder arg2 arg1)))
50.               (iter2 (cons (/ arg2 arg1)
51.                      (remove-two (car composites) numbers))
52.                      sum
53.                      (append result (list (list arg2 '/ arg1 '= (/ arg2 arg1))))))
54.           (iter1 numbers sum result (cdr composites))))))
56. (define (iter2 numbers sum result)
57.   (if (= (length numbers) 1)
58.       (if (= (car numbers) sum)
59.           (show result))
60.       (iter1 numbers sum result (get-composite numbers))))
62. (define (show list)
63.   (display list)
64.   (newline))
66. (define (calculate numbers sum)
67.   (iter2 numbers sum '()))
69. (calculate '(13 3 7 5) 24)

复制代码