C/C++语言经典、实用、趣味程序设计编程百例精解（4）
31.歌德巴赫猜想
验证：2000以内的正偶数都能够分解为两个素数之和(即验证歌德巴赫猜想对2000以内的正偶数成立)。
*问题分析与算法设计
为了验证歌德巴赫猜想对2000以内的正偶数都是成立的，要将整数分解为两部分，然后判断出分解出的两个整数是否均为素数。若是，则满足题意；否则重新进行分解和判断。
程序中对判断是否为素数的算法进行了改进，对整数判断“用从2开始到该整数的一半”改为“2开始到该整数的平方根”。原因何在请自行分析。
*程序说明与注释
1. #include<stdio.h> 2. #include<math.h> 3. int fflag(int n); 4. int main() 5. { 6. int i,n; 7. for(i=4;i<=2000;i+=2){ 8. for(n=2;n<i;n++) /*将偶数i分解为两个整数*/ 9. if(fflag(n)) /*分别判断两个整数是否均为素数*/ 10. if(fflag(i-n)){ 11. printf("%14d=%d+%d\n",i,n,i-n); /*若均是素数则输出*/ 12. break; 13. } 14. if(n==i) printf("error %d\n",i); 15. } 16. } 17. int fflag(int i) /*判断是否为素数*/ 18. { 19. int j; 20. if(i<=1)return 0; 21. if(i==2)return 1; 22. if(!(i%2))return 0; /*if no,return 0*/ 23. for(j=3;j<=(int)(sqrt((double)i)+1);j+=2) 24. if(!(i%j)) return 0; 25. return 1; /*if yes,return 1*/ 26. }
32.可逆素数
求四位的可逆素数。可逆素数指：一个素数将其各位数字的顺序倒过来构成的反序数也是素数。
*问题分析与算法设计
本题的重点不是判断素数的方法，而是求一个整数的反序数。求反序数的方法是从整数的末尾依次截取最后一位数字，每截取一次后整数缩小10倍，将截取的数字作为新的整数的最后一位（新的整数扩大10倍后加上被截取的数字）。这样原来的整数的数字从低到高被不断地截取，依次作为新的整数从高到低的各位数字。
*程序说明与注释
1. #include<stdio.h> 2. #include<math.h> 3. int num(int number); 4. int ok(int number); 5. int main() 6. { 7. int i,count; 8. printf("There are invertable primes with 4 digits: \n"); 9. for(count=0,i=1001;i<9999;i+=2) {//穷举全部的奇数 10. if(num(i)) //若是可逆素数，则输出 11. printf(count%9 ? "%3d:%d" : "%3d:%d\n",++count,i); 12. } 13. return 0; 14. } 15. int num(int number) 16. { 17. int i,j; 18. if(!ok(number))return 0; //判断是否为素数 19. for(i=number,j=0;i>0;i/=10) {//按位将整数倒过来，产生反序数 20. j=j*10 + i%10; 21. } 22. if(number<j) {//若原数小于反序数 23. if(!ok(i)) {//判断对应的反序数是否为可逆素数 24. return 0; 25. }else{ 26. return 1; //若是可逆数素数，则返回1 27. } 28. }else{ 29. return 0; 30. } 31. getchar(); 32. return 0; 33. } 34. int ok(int number) 35. { 36. int i,j; 37. if(number%2 ==0) //判断是否为素数 38. return 0; 39. j= sqrt((double)number) +1 ; //取整数的平方根为判断的上限 40. for(i=3;i<j;i+=2){ 41. if(number %i ==0) //若为素数则返回1，否则返回0 42. return 0; 43. } 44. return 1; 45. }
*思考题
求1000以内的孪生素数。孪生素数是指：若a为素数，且a+2也是素数，则素数a和a+2称为孪生素数。
33.回文素数
求不超过1000的回文素数。
*问题分析与算法设计
所谓回文素数是指，对一个整数n从左向右和从由向左读其结果值相同且是素数，即称n为回文素数。所以本题的重点不是判断素数的方法，而是求回文整数。构造回文数的方法很多，这里仅介绍一种最简单的算法。实现思路是先求出一个整数的回文数，再判断是否为素数。
不超过1000的回文数包括二位和三位的回文数，我们采用穷举法来构造一个整数并求与其对应的反序数，若整数与其反序数相等，则该整数是回文数。
*程序说明与注释
1. #include<stdio.h> 2. int a(int n); 3. int main() 4. { 5. int i,j,t,k,s; 6. printf("Following are palindrome primes not greater than 1000:\n"); 7. for(i=0;i<=9;++i) //穷举第一位 8. for(j=0;j<=9;++j) //穷举第二位 9. for(k=0;k<=9;++k) {//穷举第三位 10. s=i*100 + j*10 + k; //计算组成的整数 11. t=k*100 + j*10 + i; //计算对应的反序数 12. if(i == 0 && j==0){ //处理整数的前两位为0的情况 13. t/=100; 14. } 15. else if(i ==0){ //处理整数的第一位为0的情况 16. t/=10; 17. } 18. if(s>10 && s==t && a(s)) {//若大于10且为回文素数，则输出 19. printf("%d\t",s); 20. } 21. } 22. return 0; 23. } 24. //判断参数n是否为素数 25. int a(int n){ 26. int i; 27. for(i=2;i<(n-1)/2;++i){ 28. if(n%i == 0)return 0; 29. } 30. return 1; 31. }
*运行结果
Following are palindrome primes not greater than 1000:
11 101 131 151 181 191 313 353
373 383 727 787 797 919 929
*思考题
优化生成回文数的算法。
34.要发就发
“1898–要发就发”。请将不超过1993的所有素数从小到大排成第一行，第二行上的每个素数都等于它右肩上的素数之差。编程求出：第二行数中是否存在这样的若干个连续的整数，它们的和恰好是1898？假好存在的话，又有几种这样的情况？
第一行：2 3 5 7 11 13 17……1979 1987 1993
第二行：1 2 2 4 2 4…… 8 6
*问题分析与算法设计
首先从数学上分析该问题：
假设第一行中的素数为n[1]、n[2]、n[3]….n[i]、…第二行中的差值为m[1]、m[2]、m[3]…m[j]…。其中m[j]为：
m[j]=n[j+1]-n[j]。
则第二行连续N个数的和为：
SUM=m[1]+m[2]+m[3]+…+m[j]
=(n[2]-n[1])+(n[3]-n[2])+(n[4]-n[3])+…+(n[j+1]-n[j])
=n[j+1]-n[1]
由此题目就变成了：在不超过1993的所有素数中是否存在这样两个素数，它们的差恰好是1898。若存在，则第二行中必有所需整数序列，其和恰为1898，。
对等价问题的求解是比较简单的。
由分析可知，在素数序列中不必包含2，因为任意素数与2的差一定为奇数，所以不必考虑。
*程序与程序注释：
1. #include<stdio.h> 2. #include<math.h> 3. #define NUM 320 4. int number[NUM]; /*存放不超过1993的全部奇数*/ 5. int fflag(int i); 6. int main() 7. { 8. int i,j,count=0; 9. printf("there are follwing primes sequences in first row:\n"); 10. for(j=0,i=3;i<=1993;i+=2) /*求出不超过1993的全部奇数*/ 11. if(fflag(i)) number[j++]=i; 12. for(j--;number[j]>1898;j--){ /*从最大的素数开始向1898搜索*/ 13. for(i=0;number[j]-number[i]>1898;i++); /*循环查找满足条件的素数*/ 14. if(number[j]-number[i]==1898) /*若两个素数的差为1898，则输出*/ 15. printf("(%d).%3d,…..,%d\n",++count,number[i],number[j]); 16. } 17. } 18. int fflag(int i) 19. { 20. int j; 21. if(i<=1) return 0; /*判断是否为素数*/ 22. if(i==2) return 1; 23. if(!(i%2)) return 0; /*if no, return 0*/ 24. for(j=3;j<=(int)(sqrt((double)i)+1);j+=2) 25. if(!(i%j)) return 0; 26. return 1; 27. }
*运行结果
There are follwing primes sequences in first row:
(1).89,……,1987
(2).53,……,1951
(3). 3,……,1901
*思考题
将1,2，3，。。。,20这20个连续的自然数排成一圈，使任意两个相邻的自然数之和均为素数。
35.素数幻方
求四阶的素数幻方。即在一个4X4 的矩阵中，每一个格填 入一个数字，使每一行、每一列和两条对角线上的4 个数字所组成的四位数，均为可逆素数。
*问题分析与算法设计
有了前面的基础，本题应当说是不困难的。
最简单的算法是：采用穷举法，设定4X4矩阵中每一个元素的值后，判断每一行、每一列和两条对角线上的4个数字组成的四位数是否都是可逆素数，若是则求出了满足题意的一个解。
这种算法在原理是对的，也一定可以求出满足题意的全部解。但是，按照这一思路编出的程序效率很低，在微机上几个小时也不会运行结束。这一算法致命的缺陷是：要穷举和判断的情况过多。
充分利用题目中的“每一个四位数都是可逆素数”这一条件，可以放弃对矩阵中每个元素进行的穷举的算法，先求出全部的四位可逆素数(204个)，以矩阵的行为单位，在四位可逆素数的范围内进行穷举，然后将穷举的四位整数分解为数字后，再进行列和对角线方向的条件判断，改进的算法与最初的算法相比，大大地减少了穷举的次数。
考虑矩阵的第一行和最后一行数字，它们分别是列方向四位数的第一个数字和最后一个数字，由于这些四位数也必须是可逆素数，所以矩阵的每一行和最后一行中的各个数字都不能为偶数或5。这样穷举矩阵的第一行和最后一行时，它们的取值范围是：所有位的数字均不是偶数或5的四位可逆数。由于符合这一条件的四位可逆素数很少，所以这一范围限制又一次减少了穷举的次数。
对算法的进一步研究会发现：当设定了第一和第二行的值后，就已经可以判断出当前的这种组合是否一定是错误的(尚不能肯定该组合一定是正确的)。若按列方向上的四个两位数与四位可逆数的前两位矛盾(不是其中的一种组合)，则第一、二行的取值一定是错误的。同理在设定了前三行数据后，可以立刻判断出当前的这种组合是否一定是错误的，若判断出矛盾情况，则可以立刻设置新的一组数据。这样就可以避免将四个数据全部设定好以后再进行判断所造成的低效。
根据以上分析，可以用伪语言描述以上改进的算法：
开始
找出全部四位的可逆素数；
确定全部出现在第一和最后一行的四位可逆素数；
在指定范围 内穷举第一行
在指定范围内穷举第二行
若第一、第二、三行已出现矛盾，则继续穷举下一个数；
在指定范围内穷举第四行
判断列和对角方向是否符合题意
若符合题意，则输出矩阵；
否则继续穷举下一个数；
结束
在实际编程中，采用了很多程序设计技巧，假如设置若干辅助数组，其目的就是要最大限度的提高程序的执行效率，缩短运行时间。下面的程序运行效率是比较高的。
*程序说明与注释
1. #include "stdio.h" 2. #include "stdlib.h" 3. int zz = 0; 4. int quzhi(int *a, int k) //将k分解成4位存在a中 5. { 6. a[0] = k / 1000; 7. a[1] = k / 100 % 10; 8. a[2] = k / 10 % 10; 9. a[3] = k % 10; 10. return 1; 11. } 12. int qiuzhi(int a, int b, int c, int d) //将a中的数还原为一个四位数 13. { 14. return (a * 1000 + b * 100 + c * 10 + d); 15. // return(d*1000+c*100+b*10+a); 16. } 17. 18. int main() { 19. int a[9000]; //建立一张素数的表 20. int i, j, k, l = 0, num = 0; // num为素数的总数 21. int p[300][5]; //用一个指针来保存每一个四位的可逆素数,p[x][1]之后用来保存每一位 22. for (i = 1000; i <= 9999; i++) { 23. int key = 1; // key等于1时表示是素数 24. for (j = 2; j <= i / 2; j++) { 25. if (i % j == 0) { 26. key = 0;break; 27. } 28. } 29. if (key) a[l++] = 1; 30. else a[l++] = 0; 31. } 32. for (i = 1000; i <= 9999; i++) { 33. if (a[i - 1000]) { 34. j = 1; 35. k = 0; 36. while (j <= 1000) { 37. k = k + (i % (j * 10) / j) * 1000 / j; // k存储的是逆序后的数 38. j = j * 10; 39. } 40. if (i >= k && a[k - 1000]) //直接在素数表中查询即可,这里防止重复输出 41. { 42. a[i - 1000] = i; 43. a[k - 1000] = k; 44. p[num++][0] = i; 45. quzhi(&p[num - 1][1], i); //建立每一位的表,提高效率 46. p[num++][0] = k; 47. quzhi(&p[num - 1][1], k); 48. // printf("%d_%d ",a[i-1000],k); 49. // if(++num%5==0) printf("\n"); 50. } 51. } 52. } 53. for (i = 1000; i <= 9999; i++) 54. if (a[i - 1000] == 1)a[i - 1000] = 0; //建立一张可逆素数的"布尔"表 55. for (int t1 = 0; t1 < num; t1++) // t1表示第一列 56. { 57. for (int k1 = 0; k1 < num; k1++) //每一行的数字 58. { 59. if (p[t1][1] != p[k1][1]) continue; 60. for (int k2 = 0; k2 < num; k2++) { 61. if (p[t1][2] != p[k2][1]) continue; 62. for (int k3 = 0; k3 < num; k3++) { 63. if (p[t1][3] != p[k3][1]) continue; 64. for (int k4 = 0; k4 < num; k4++) { 65. if (p[t1][4] != p[k4][1]) continue; 66. int key = 1, r[4]; // r用来保存每一列的数字 67. int zuoduijiao = 68. qiuzhi(p[k1][1], p[k2][2], p[k3][3], p[k4][4]) - 1000; 69. int youduijiao = 70. qiuzhi(p[k1][4], p[k2][3], p[k3][2], p[k4][1]) - 1000; 71. r[0] = qiuzhi(p[k1][1], p[k2][1], p[k3][1], p[k4][1]) - 1000; 72. r[1] = qiuzhi(p[k1][2], p[k2][2], p[k3][2], p[k4][2]) - 1000; 73. r[2] = qiuzhi(p[k1][3], p[k2][3], p[k3][3], p[k4][3]) - 1000; 74. r[3] = qiuzhi(p[k1][4], p[k2][4], p[k3][4], p[k4][4]) - 1000; 75. //经过验证,计算对角和每一列的公式完全没有问题 76. if (!a[zuoduijiao] || !a[youduijiao]) {key = 0;continue;} 77. //两个对角线 78. if ((!a[r[0]])) {key = 0;continue;} 79. //验证第一列 80. if ((!a[r[1]])) {key = 0;continue;} 81. //验证第2列 82. if ((!a[r[2]])) {key = 0;continue;} 83. //验证第3列 84. if ((!a[r[3]])) {key = 0;continue;} 85. //验证第4列 86. if (key) 87. printf("%d:\n%d\n%d\n%d\n%d\n\n", ++zz, p[k1][0], p[k2][0], 88. p[k3][0], p[k4][0]); // zz统计总的个数 89. } // end k4 90. } // end k3 91. } // end k2 92. } // end k1 93. } // end t1 94. printf("\n"); 95. system("pause"); 96. }
1. #include<stdio.h> 2. #include<math.h> 3. int number[210][5]; /*存放可逆素数及素数分解后的各位数字*/ 4. int select[110]; /*可以放在矩阵第一行和最后一行的素数的下标*/ 5. int array[4][5]; /*4X4的矩阵，每行0号元素存可逆素数对应的数组下标*/ 6. int count; /*可逆素数的数目*/ 7. int selecount; /*可以放在矩阵第一行和最后一行的可逆素数的数目*/ 8. int larray[2][200]; /*存放素数前二、三位数的临时数组所对应的数量计数器*/ 9. int lcount[2]; 10. int num(int number); 11. int ok(int number); 12. void process(int i); 13. void copy_num(int i); 14. int comp_num(int n); 15. int find1(int i); 16. int find2(void); 17. int find0(int num); 18. void p_array(void); 19. int main() 20. { 21. int i,k,flag,cc=0,i1,i4; 22. printf("there are magic squares with invertable primes as follw:\n"); 23. for(i=1001;i<9999;i+=2) /*求满足条件的可逆素数*/ 24. { 25. k=i/1000; 26. if(k%2!=0&&k!=5&&num(i)) /*若可逆素数的第一位不是偶数或5*/ 27. { 28. number[count][0]=i; /*存入数组*/ 29. process(count++); /*分解素数的各位数字*/ 30. if(number[count-1][2]%2!=0&& /*若可逆素数满足放在矩阵第一行*/ 31. number[count-1][3]%2!=0&& /*和最后一行的条件，记录可逆素数的*/ 32. number[count-1][2]!=5&& /*下标，计数器加1*/ 33. number[count-1][3]!=5) 34. select[selecount++]=count-1; 35. } 36. } 37. larray[0][lcount[0]++]=number[0][0]/100; /*临时数组的第一行存前二位*/ 38. larray[1][lcount[1]++]=number[0][0]/10; /*临时数组的第二行存前三位*/ 39. for(i=1;i<count;i++) /*将素数不重复的前二、三位存入临时数组中*/ 40. { 41. if(larray[0][lcount[0]-1]!=number[i][0]/100) 42. larray[0][lcount[0]++]=number[i][0]/100; 43. if(larray[1][lcount[1]-1]!=number[i][0]/10) 44. larray[1][lcount[1]++]=number[i][0]/10; 45. } 46. for(i1=0;i1<selecount;i1++) /*在第一行允许的汇聚围内穷举*/ 47. { 48. array[0][0]=select[i1]; /*取对应的素数下标*/ 49. copy_num(0); /*复制分解的素数*/ 50. for(array[1][0]=0;array[1][0]<count;array[1][0]++) /*穷举第二行*/ 51. { 52. copy_num(1); /*复制分解的数字*/ 53. if(!comp_num(2)) 54. continue; /*若每列的前两位的组成与素数相矛盾，则试探下一个数*/ 55. for(array[2][0]=0;array[2][0]<count;array[2][0]++) /*穷举第三行*/ 56. { 57. copy_num(2); /*复制分解的数字*/ 58. if(!comp_num(3))continue; /*若每列的前三位的组成与素数相矛盾，则试探下一个数*/ 59. for(i4=0;i4<selecount;i4++) /*在最后一行允许的范围内穷举*/ 60. { 61. array[3][0]=select[i4]; 62. copy_num(3); /*复制分解的数字*/ 63. for(flag=1,i=1;flag&&i<=4;i++) /*判断每列是否可逆素数*/ 64. if(!find1(i))flag=0; 65. if(flag&&find2()) /*判断对角线是否为可逆素数*/ 66. { printf("No.%d\n",++cc); p_array(); } /*输出幻方矩阵*/ 67. } 68. } 69. } 70. } 71. } 72. int num(int number) /*判断是否可逆素数*/ 73. { 74. int j; 75. if(!ok(number)) return 0; 76. for(j=0;number>0;number/=10) /*将素数变为反序数*/ 77. j=j*10+number%10; 78. if(!ok(j)) return 0; /*判断反序数是否为素数*/ 79. return 1; 80. } 81. int ok(int number) /*判断是否为素数*/ 82. { 83. int i,j; 84. if(number%2==0) return 0; 85. j=sqrt((double)number)+1; 86. for(i=3;i<=j;i+=2) 87. if(number%i==0) return 0; 88. return 1; 89. } 90. void process(int i) /*将第i个整数分解为数字并存入数组*/ 91. { 92. int j,num; 93. num=number[i][0]; 94. for(j=4;j>=1;j--,num/=10) 95. number[i][j]=num%10; 96. } 97. void copy_num(int i) /*将array[i][0]指向的素数的各位数字复制到array[i]中*/ 98. { 99. int j; 100. for(j=1;j<=4;j++) 101. array[i][j]=number[array[i][0] < [j] ]; 102. } 103. int comp_num(int n) /*判断array中每列的前n位是否与可逆素数允许的前n位矛盾*/ 104. { 105. static int ii; /*用内部静态变量保存前一次查找到的元素下标*/ 106. static int jj; /*ii:前一次查找前二位的下标，jj:前一次查找前三位的下标*/ 107. int i,num,k,*p; /*p:指向对应的要使用的前一次下标ii或jj*/ 108. int *pcount; /*pcount:指向要使用的临时数组数量的计数器*/ 109. switch(n){ /*根据n的值选择对应的一组控制变量*/ 110. case 2:pcount=&lcount[0];p=ⅈbreak; 111. case 3:pcount=&lcount[1];p=&jj;break; 112. default:return 0; 113. } 114. for(i=1;i<=4;i++) /*对四列分别进行处理*/ 115. { 116. for(num=0,k=0;k<n;k++) /*计算前n位数字代表的数值*/ 117. num=num*10+array[k][i]; 118. if(num<=larray[n-2][*p]) /*与前一次最后查找到的元素进行比较*/ 119. for(;*p>=0&&num<larray[n-2][*p];(*p)--);/*若前次查找到的元素大，则向前找*/ 120. else 121. for(;p<pcount&&num>larray[n-2][*p];(*p)++); /*否则向后找*/ 122. if(*p<0||*p>=*pcount){ 123. *p=0; return 0; 124. } 125. if(num!=larray[n-2][*p]) 126. return 0; /*前n位不是可逆素数允许的值则返回0*/ 127. } 128. return 1; 129. } 130. int find1(int i) /*判断列方向是否是可逆素数*/ 131. { 132. int num,j; 133. for(num=0,j=0;j<4;j++) 134. num=num*10+array[j][i]; 135. return find0(num); 136. } 137. int find2(void) /*判断对角线方向是否是可逆素数*/ 138. { 139. int num1,num2,i,j; 140. for(num1=0,j=0;j<4;j++) 141. num1=num1*10+array[j][j+1]; 142. for(num2=0,j=0,i=4;j<4;j++,i--) 143. num2=num2*10+array[j][i]; 144. if(find0(num1)) return(find0(num2)); 145. else return 0; 146. } 147. int find0(int num) /*查找是否为满足要求的可逆素数*/ 148. { 149. static int j; 150. if(num<=number[j][0]) 151. for(;j>=0&&num<number[j][0];j--); 152. else 153. for(;j<count&&num>number[j][0];j++); 154. if(j<0||j>=count){ j=0;return 0; } 155. if(num==number[j][0]) return 1; 156. else return 0; 157. } 158. void p_array(void) {/*输出矩阵*/ 159. int i,j; 160. for(i=0;i<4;i++){ 161. for(j=1;j<=4;j++) printf("%d ",array[i][j]); 162. printf("\n"); 163. } 164. }
*问题的进一步讨论
程序中大量技巧是用于尽早发现矛盾，减少循环次数，缩短运行时间。从实际效果看是相当不错的。但目前的程序仍然可以进一步优化。
当第四行设定了前三行后，尚未设定的行就没必要再使用穷举的方法，因为列方向设定好的三位数字已经限制了最后一个数字可能的取值，在可逆数中找出前三位数字与设定好的三位数字相同的素数。这些素数就是在这一列前面已设定好的三位数字的限制条件下可能的取值。此时每一列上只有不超过四个可能的取值。找出全部各列可能的取值(可能的四位可逆素数)，求出它们的交集。若交集为空，即没有共同的可能取值，则列间数据相互矛盾否满足则将交集中的数据填 入矩阵中就是题目的一个解。
算法可再进一步优化。先穷举一、二和四列的数据，然后用上面的算法来确定第三行的值，这样可进一步缩小穷举的范围，提高运行效率。
分析输出的结果。可以看出本题的基本解只有17种，每个解可通过旋转与反射获得同构的其它7个解，可以进一步改进程序，只输出17个基本解。
*思考题
用1到16构成一个四阶幻方，要求任意相邻两个方格中的数字之和均为素数。
36.百钱百鸡问题
中国古代数学家张丘建在他的《算经》中提出了著名的“百钱买百鸡问题”：鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁、母、雏各几何？
*问题分析与算法设计
设鸡翁、鸡母、鸡雏的个数分别为x,y,z，题意给定共100钱要买百鸡，若全买公鸡最多买20只，显然x的值在0~20之间；同理，y的取值范围在0~33之间，可得到下面的不定方程：
5x+3y+z/3=100
x+y+z=100
所以此问题可归结为求这个不定方程的整数解。
由程序设计实现不定方程的求解与手工计算不同。在分析确定方程中未知数变化范围的前提下，可通过对未知数可变范围的穷举，验证方程在什么情况下成立，从而得到相应的解。
*程序说明与注释
1. #include<stdio.h> 2. int main() 3. { 4. int x,y,z,j=0; 5. printf("Folleing are possible plans to buy 100 fowls with 100 Yuan.\n"); 6. for(x=0;x<=20;x++) /*外层循环控制鸡翁数*/ 7. for(y=0;y<=33;y++) {/*内层循环控制鸡母数y在0~33变化*/ 8. z=100-x-y; /*内外层循环控制下，鸡雏数z的值受x,y的值的制约*/ 9. if(z%3==0&&5*x+3*y+z/3==100) 10. /*验证取z值的合理性及得到一组解的合理性*/ 11. printf("%2d:cock=%2d hen=%2d chicken=%2d\n",++j,x,y,z); 12. } 13. }
*运行结果
Follwing are possible plans to buy 100 fowls with 100 Yuan.
1:cock=0 hen=25 chicken=75
2:cock=4 hen=18 chicken=78
3:cock=8 hen=11 chicken=81
4:cock=12 hen=4 chicken=84
*问题的进一步讨论
这类求解不定方程总理的实现，各层循环的控制变量直接与方程未知数有关，且采用对未知数的取值范上穷举和组合的方法来复盖可能得到的全部各组解。能否根据题意更合理的设置循环控制条件来减少这种穷举和组合的次数，提高程序的执行效率，请读者考虑
37.爱因斯坦的数学题
爱因斯坦出了一道这样的数学题：有一条长阶梯，若每步跨2阶，则最最后剩一阶，若每步跨3 阶，则最后剩2阶，若每步跨5阶，则最后剩4阶，若每步跨6阶则最后剩5阶。只有每次跨7阶，最后才正好一阶不剩。请问这条阶梯共有多少阶？
*问题分析与算法设计
根据题意，阶梯数满足下面一组同余式：
x≡1 (mod2)
x≡2 (mod3)
x≡4 (mod5)
x≡5 (mod6)
x≡0 (mod7)
*程序说明与注释
1. #include<stdio.h> 2. int main() 3. { 4. int i=1; /*i为所设的阶梯数*/ 5. while(!((i%2==1)&&(i%3==2)&&(i%5==4)&&(i%6==5)&&(i%7==0))) 6. ++i; /*满足一组同余式的判别*/ 7. printf("Staris_number=%d\n",i); 8. }
*运行结果
Staris_number=119
*问题的进一步讨论
此题算法还可考虑求1、2、4、5的最小公倍数n，然后判t(t为n-1)≡0(mod7)是否成立，若不成立则t=t+n,再进行判别，直至选出满足条件的t值。请自行编写程序实现
38.换分币
用一元人民币兑换成1分、2分和5分硬币，共有多少种不同的兑换方法。
*问题分析与算法设计
根据题意设i,j,k分别为兑换的1分、2分、5分硬币所具有的钱数(分)，则i,j,k的值应满足：
i+j+k=100
*程序说明与注释
1. #include<stdio.h> 2. int main() 3. { 4. int i,j,k,count=1; 5. printf("There are follwing small exchange plans for 1 Yuan note:\n"); 6. for(i=0;i<=100;i++) /*i为1分硬币钱数，可取值0,1，2…,100*/ 7. for(j=0;j<=100-i;j+=2) /*j为2分硬币钱数，可取0值，2，4，…，100*/ 8. for(k=0;k<=100-i-2*j;k+=5) /*k为5分硬币钱数*/ 9. if(i+j+k==100) 10. printf(count%4?"%d:1*%d+2*%d+5*%d\t":"%d:1*%d+2*%d+5*%d\n",count++,i,j/2,k/5); 11. }
39.年龄几何
张三、李四、王五、刘六的年龄成一等差数列，他们四人的年龄相加是26，相乘是880，求以他们的年龄为前4项的等差数列的前20项。
*问题分析与算法设计
设数列的首项为a，则前4项之和为"4*n+6*a",前4 项之积为"n*(n+a)*(n+a+a)*(n+a+a+a)"。同时"1<=a<=4","1<=n<=6"。可采用穷举法求出此数列。
*程序说明与注释
1. #include<stdio.h> 2. int main() 3. { 4. int n,a,i; 5. printf("The series with equal difference are:\n"); 6. for(n=1;n<=6;n++) /*公差n取值为1~6*/ 7. for(a=1;a<=4;a++) /*首项a取值为1~4*/ 8. if(4*n+6*a==26&&n*(n+a)*(n+a+a)*(n+a+a+a)==880) /*判断结果*/ 9. for(i=0;i<20;i++) 10. printf("%d ",n+i*a); /*输出前20项*/ 11. }
*运行结果
The series with equal difference are:
2 5 8 11 14 17 20 23 26 29 32 35 38 41 44 47 50 53 56 59
40.三色球问题
若一个口袋中放有12个球，其中有3个红的。3个白的和6个黒的，问从中任取8个共有多少种不同的颜色搭配？
*问题分析与算法设计
设任取的红球个数为i，白球个数为j，则黒球个数为8-i-j，根据题意红球和白球个数的取值范围是0~3，在红球和白球个数确定的条件下，黒球个数取值应为8-i-j<=6。
*程序说明与注释
1. #include<stdio.h> 2. int main() 3. { 4. int i,j,count=0; 5. printf(" RED BALL WHITE BALL BLACKBALL\n"); 6. printf("…………………………………………..\n"); 7. for(i=0;i<=3;i++) /*循环控制变量i控制任取红球个数0￣3*/ 8. for(j=0;j<=3;j++) /*循环控制变量j控制任取白球个数0￣3*/ 9. if((8-i-j)<=6) 10. printf(" %2d: %d %d %d\n",++count,i,j,8-i-j); 11. }
