哈工大C语言程序设计精髓第九周

素颜马尾好姑娘i 2023-07-13 13:48 34阅读 0赞

由于这些代码也是我初学时写的代码，故其中的规范程度及简洁程度并不很好（此处我后来写的有可以参考一下->[C语言代码规范][C]），但是能很好的接近出初学者的水平，也更有参考价值！排版不易，喜欢就点个赞吧！如有问题，请勿吐槽，欢迎留言互相学习。

**第9周编程题在线测试**

### 1. 重复数字检查 ###

**题目内容**：  
从键盘输入一个数，检查这个数中是否有重复出现的数字。如果这个数中有重复出现的数字，则显示“Repeated digit!”；否则显示“No repeated digit!”。  
已知 **函数原型**：  
int CountRepeatNum(int count\[\], int n);  
若有重复数字，则该函数返回重复出现的数字；否则返回-1.  
程序运行结果示例1：  
Input n:  
28212↙  
Repeated digit!  
程序运行结果示例2：  
Input n:  
12345↙  
No repeated digit!  
**输入提示**：“Input n:\\n”  
**输入格式**: “%ld”  
**输出格式**：  
有重复数字，输出信息: “Repeated digit!\\n”  
没有重复数字，输出信息: “No repeated digit!\\n”

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    int CountRepeatNum( int n);
    int main()
    { 
        long int a;
        int b[1000];
        printf("Input n:\n");
        scanf("%ld",&a);
        if(CountRepeatNum(a)==-1)
        { 
            printf("No repeated digit!\n");
        }
        else
        { 
            printf("Repeated digit!\n");
        }
        return 0;
    }
    int CountRepeatNum( int n)
    { 
        int i,c,d,count[1000];
        for(i=0;n>0;i++)
        { 
            count[i]=n%10;
            n/=10;
            c=i;
        }
        for(;c>0;c--)
        { 
            for(d=c-1;d>=0;d--)
            { 
                if(count[c]==count[d])
                { 
                    return count[c];
                }
            }
        }
        return -1;
    }

### 2. 教授的课 ###

**题目内容**：  
教授正在为一个有N个学生的班级讲授离散数学课。他对某些学生缺乏纪律性很不满意，于是决定：如果课程开始后上课的人数小于K，就取消这门课程。从键盘输入每个学生的到达时间，请编程确定该课程是否被取消。如果该门课程被取消，则输出“Yes”，否则输出“No”。假设教授在时刻0开始上课。如果一个学生的到达时间是非正整数，则表示该学生在上课前进入教室。如果一个学生的到达时间是正整数，则表示该学生在上课后进入教室。如果一个学生在时刻0进入教室，也被认为是在上课前进入教室。假设到达时间的绝对值不超过100，学生数N不超过1000。要求在输入学生的到达时间之前，先输入N和K。  
已知 **函数原型**：  
//函数功能：根据数组a中记录的学生到达时间确定课程是否被取消，取消则返回1，否则返回0  
int IsCancel(int a\[\], int n, int k);  
程序运行结果示例1：  
Input n,k:  
4,3↙  
\-1 -3 4 2↙  
YES  
程序运行结果示例2：  
Input n,k:  
5,3↙  
\-1 -2 -3 0 4↙  
NO  
**输入提示**：“Input n,k:\\n”  
**输入格式**:  
“%d,%d”  
“%d”  
输入包括两行数据：  
第1行是n,k的值。  
第2行是学生的到达时间。  
**输出格式**：  
课程被取消，输出"YES"  
课程不取消，输出"NO"

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    int IsCancel(int a[], int n, int k);
    int main()
    { 
        int n,k,a[1000],i;
        printf("Input n,k:\n");
        scanf("%d,%d",&n,&k);
        for(i=1;i<=n;i++)
        { 
            scanf("%d",&a[i]);
        }
        if(IsCancel(a,n,k))
        { 
            printf("YES");
        }
        else
        { 
            printf("NO");
        }
        return 0;
    }
    int IsCancel(int a[], int n, int k)
    { 
        int i,s=0;
        for(i=1;i<=n;i++)
        { 
            if(a[i]>0)
            { 
                s++;
            }
        }
        if(n-s<k)
        { 
            return 1;
        }
        else
        { 
            return 0;
        }
    }

### 3. 寻找鞍点 ###

**题目内容**：  
请编程找出一个M\*N矩阵中的鞍点，即该位置上的元素是该行上的最大值，是该列上的最小值。如果矩阵中没有鞍点，则输出“No saddle point！”  
已知 **函数原型**：  
void FindSaddlePoint(int a\[\]\[N\], int m, int n);  
在该函数中输出有无鞍点的信息。  
程序运行结果示例1：  
Input m,n:  
3,3↙  
Input matrix:  
1 2 3↙  
4 5 6↙  
7 8 9↙  
a\[0\]\[2\] is 3  
程序运行结果示例2：  
Input m,n:  
3,4↙  
Input matrix:  
3 4 7 5↙  
0 1 8 2↙  
9 3 2 6↙  
No saddle point!  
**输入提示**： “Input m,n:\\n”  
“Input matrix:\\n"  
**输入格式**:  
输入矩阵大小： “%d,%d”  
输入矩阵元素： “%d”  
**输出格式**：  
找到鞍点的输出格式：“a\[%d\]\[%d\] is %d\\n”  
没找到鞍点的输出格式：“No saddle point!\\n”

**代码实现：**

//寻找鞍点
    #include<stdio.h>
    #define N 100
    void FindSaddlePoint(int a[][N], int m, int n);
    int main()
    { 
        int m,n,i,j,y,x,x1,y1,max,min,d=0,r,t=1;
        int a[N][N];
        printf("Input m,n:\n");
        scanf("%d,%d",&m,&n);
        printf("Input matrix:\n");
        for(i=0;i<m;i++)
        { 
            for(j=0;j<n;j++)
            { 
                scanf("%d",&a[i][j]);
            }
        }
        for(i=0;i<m;i++)
        { 
            t=1;
            max=a[i][0];
            for(j=1;j<n;j++)
            { 
                if(a[i][j]>max)
                { 
                    max=a[i][j];
                    x=i;
                    y=j;
                }
            }
            min=a[i][y];
            for(r=0;r<m;r++)
            { 
                if(a[r][y]<min)
                { 
                    t=0;
                }
            }
            if(t==1)
            { 
                printf("a[%d][%d] is %d\n",x,y,max);
                return 0;
            }
        }
        printf("No saddle point!\n");
        return 0;
    }

### 4. 计算三位阶乘和数 ###

**题目内容**：  
试求出所有三位阶乘和数：m=a!+b!+c!(其中a为百位数字，b为十位数字，c为个位数字。约定0!=1，并输出所有的m)  
**输入格式**: 无  
**输出格式**："%ld\\n"  
注意：为避免出现格式错误，请直接拷贝粘贴上面给出的输入、输出提示信息和格式控制字符串！

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    int AAA(int a);
    int main()
    { 
        long int a,b,c,m;
        for(m=100;m<=999;m++)
        { 
            a=m/100,b=(m%100)/10,c=m%10;
            if(AAA(a)+AAA(b)+AAA(c)==m)
            { 
                printf("%ld\n",m);
            }
        }
        return 0;
    }
    int AAA(int a)
    { 
        int i;
        if(a==0 || a==1)
        { 
            return 1;
        }
        else
        { 
            return a*AAA(a-1);
        }
    }

**练兵区——编程题**

### 1. 二分法求根 ###

**题目内容**：  
用二分法求下面的一元三次方程在区间\[-10, 10\]上误差不大于的根。  
用二分法求方程的根的基本原理是：若函数有实根，则函数曲线应当在根x\*这一点上与x轴有一个交点，并且由于函数是单调的，在根附近的左右区间内，函数值的符号应当相反。利用这一特点，可以通过不断将求根区间二分的方法，每次将求根区间缩小为原来的一半，在新的折半后的区间内继续搜索方程的根，对根所在区间继续二分，直到求出方程的根为止。  
该方法的 **关键**在于要解决如下两个问题：  
1）如何对区间进行二分，并在二分后的左右两个区间中确定下一次求根搜索的区间？  
假设区间端点为x1和x2，则通过计算区间的中点x0，即可将区间\[x1, x2\]二分为\[x1, x0\]和\[x0, x2\]。这时，为了确定下一次求根搜索的区间，必须判断方程的根在哪一个区间内，由上图可知方程的根所在区间的两个端点处的函数值的符号一定是相反的。也就是说，如果f(x0)与f(x1)是异号的，则根一定在左区间\[x1, x0\]内，否则根一定在右区间\[x0, x2\]内。  
2）如何终止这个搜索过程？即如何确定找到了方程的根？  
对根所在区间继续二分，直到,即|f(x0)|≈0时，则认为x0是逼近函数f(x)的根。  
程序中所有变量的数据类型均为float。  
**输入格式**: “%f,%f”  
**输出格式**： “x=%6.2f\\n”  
输入样例：  
0,4  
输出样例：  
x=\_\_1.32  
(输出样例中下划线“\_”代表空格，本例中数字1的前面有两个空格)

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    float F(float a);
    int main()
    { 
        float a,b,x=0;
        scanf("%f,%f",&a,&b);
        for(;fabs(F(x))>1e-6;)
        { 
            x=(a+b)/2;
            if(F(x)>0)
            { 
                b=x;
            }
            else
            { 
                a=x;
            }
        }
        printf("x=%6.2f\n",x);
        return 0;
    }
    float F(float a)
    { 
        return a*a*a-a-1;
    }

### 2. 矩阵转置 ###

**题目内容**：  
某二维数组存放的数据构成一个n *n的方阵，其中n<=5。写程序，从键盘输入n的值（n<=5），该n*n矩阵中各元素的值按下面的公式计算：  
a\[i\]\[j\] = i \* n + j + 1  
其中，a\[i\]\[j\]表示第i行第j列的元素。要求分别输出该矩阵和它的转置矩阵。  
**注意**：定义数字大小N时，请用  
\#define N 10  
**输入格式**: “%d”  
**输出提示**：“The original matrix is:\\n”  
**输出提示**：“The changed matrix is:\\n”  
**输出格式**： 矩阵的列与列之间为%3d,行与行之间为\\n  
输入样例1：  
5↙  
输出样例1：  
The\_original\_matrix\_is:  
\_\_1\_\_2\_\_3\_\_4\_\_5  
\_\_6\_\_7\_\_8\_\_9\_10  
\_11\_12\_13\_14\_15  
\_16\_17\_18\_19\_20  
*21\_22\_23\_24\_25  
The\_changed\_matrix\_is:  
\_\_1\_\_6\_11\_16\_21  
\_\_2\_\_7\_12\_17\_22  
\_\_3\_\_8\_13\_18\_23  
\_\_4\_\_9\_14\_18\_24  
\_\_5\_10\_15\_20\_25  
(输出样例中下划线“*”代表空格)  
输入样例2：  
4↙  
输出样例2：  
The original matrix is:  
\_\_1\_\_2\_\_3\_\_4  
\_\_5\_\_6\_\_7\_\_8  
\_\_9\_10\_11\_12  
*13\_14\_15\_16  
The changed matrix is:  
\_\_1\_\_5\_\_9\_13  
\_\_2\_\_6\_10\_14  
\_\_3\_\_7\_11\_15  
\_\_4\_\_8\_12\_16  
(输出样例中下划线“*”代表空格)

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    int main()
    { 
        int a,i,u;
        scanf("%d",&a);
        printf("The original matrix is:\n");
        for(i=0;i<a;i++)
        { 
            for(u=0;u<a;u++)
            { 
                printf("%3d",i*a+u+1);
            }
            printf("\n");
        }
        printf("The changed matrix is:\n");
        for(u=0;u<a;u++)
        { 
            for(i=0;i<a;i++)
            { 
                printf("%3d",i*a+u+1);
            }
            printf("\n");
        }
        return 0;
    }

### 3. 程序改错 ###

**题目内容**：  
下面程序的功能是从键盘任意输入n个数，然后找出其中的最大数与最小数，并将其位置对换。目前程序中存在错误，请修改正确。并按照给出的程序运行结果示例检查修改后的程序。  
程序运行结果示例1：  
Input n(n<=10):  
5↙  
Input 5 Numbers:  
12 4 6 7 0↙  
After MaxMinExchange:  
0 4 6 7 12  
程序运行结果示例2：  
Input n(n<=10):  
6↙  
Input 6 Numbers:  
7 -3 2 0 56 18↙  
After MaxMinExchange:  
7 56 2 0 -3 18

#include <stdio.h>
      #define ARR_SIZE 10
      int main()
      { 
         int a[ARR_SIZE], i, n;
         printf("Input n(n<=10):\n");
         scanf("%d", &n);
         printf("Input %d Numbers:\n", n);
         for (i=0; i<n; i++)
         { 
            scanf("%d", &a[i]);
         }
         MaxMinExchang(a, n);
        printf("After MaxMinExchange:\n");
         for (i=0; i<n; i++)
         { 
            printf("%d ", a[i]);
         }
        printf("\n");
        return 0;
      }
      void  MaxMinExchang(int *a, int n)
     { 
         int  maxValue = a[0], minValue = a[0], maxPos, minPos;
         int  i, temp;
         for (i=0; i<n; i++)
        { 
           if (a[i] > maxValue)
            { 
               maxValue = a[i];
               maxPos = i;
            }
            if (a[i] < minValue)
           { 
                minValue = a[i];
                minPos = i;
            }
         } 
         temp = a[maxPos];
         a[maxPos] = a[minPos];
         a[minPos] = temp;
      }

1.  **输入提示信息**： “Input n(n<=10):\\n”  
    “Input %d Numbers:\\n”  
    **输入格式**: “%d”  
    **输出格式**："%d " (注意：%d后面有一个空格)  
    **输出提示信息**：“After MaxMinExchange:\\n”

**代码实现：**

#include <stdio.h>
    void  MaxMinExchang(int *a, int n);
    #define ARR_SIZE 10
    int main()
    { 
        int a[ARR_SIZE], i, n;
        printf("Input n(n<=10):\n");
        scanf("%d", &n);
        printf("Input %d Numbers:\n", n);
        for (i=0; i<n; i++)
        { 
            scanf("%d", &a[i]);
        }
        MaxMinExchang(a, n);
        printf("After MaxMinExchange:\n");
        for (i=0; i<n; i++)
        { 
            printf("%d ", a[i]);
        }
        printf("\n");
        return 0;
    }
    void  MaxMinExchang(int *a, int n)
    { 
        int  maxValue = a[0], minValue = a[0], maxPos=0, minPos=0;
        int  i, temp;
        for (i=0; i<n; i++)
        { 
            if (a[i] > maxValue)
            { 
               maxValue = a[i];
               maxPos = i;
            }
            if (a[i] < minValue)
            { 
                minValue = a[i];
                minPos = i;
            }
        }
        temp = a[maxPos];
        a[maxPos] = a[minPos];
        a[minPos] = temp;
    }

### 4. 蛇形矩阵 ###

**题目内容**：  
从键盘任意输入一个自然数n（n表示矩阵的大小，假设不超过100），请编程输出一个n *n的蛇形矩阵。如果输入的n不是自然数或者输入了不合法的数字，则输出"Input error!"。  
**函数原型**： void ZigzagMatrix(int a\[\]\[N\], int n);  
**函数功能**：计算n*n的蛇形矩阵  
提示：用两个双重循环分别计算n\*n矩阵的左上三角和右下三角，设置一个计数器从1开始记录当前要写入矩阵的元素值，每次写完一个计数器加1，在计算左上角和右下角矩阵元素时，分奇数和偶数两种情况考虑待写入的元素在矩阵中的行列下标位置。  
程序运行结果示例1：  
Input n:  
5↙  
1 2 6 7 15  
3 5 8 14 16  
4 9 13 17 22  
10 12 18 21 23  
11 19 20 24 25  
程序运行结果示例2：  
Input n:  
4↙  
1 2 6 7  
3 5 8 13  
4 9 12 14  
10 11 15 16  
程序运行结果示例3：  
Input n:  
\-5↙  
Input error!  
程序运行结果示例4：  
Input n:  
105↙  
Input error!  
程序运行结果示例5：  
Input n:  
w↙  
Input error!  
**输入提示信息**：“Input n:\\n”  
**输入错误提示信息**：“Input error!\\n”  
**输入格式**： “%d”  
**输出格式**："%4d"  
数据换行： “\\n”

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    void ZigzagMatrix(int a[][1000], int n);
    int main()
    { 
        int a,b[100][100],c;
        printf("Input n:\n");
        c=scanf("%d",&a);
        if(c==0 || a<0 || a>100)
        { 
            printf("Input error!\n");
        }
        else
        { 
            ZigzagMatrix(b,a);
        }
        return 0;
    }
    void ZigzagMatrix(int a[][1000], int n)
    { 
        int b[100][100],i,u,s=1;
        for(i=1;i<=n;i++)
        { 
            for(u=1;u<=i;u++)
            { 
                if(i%2==0)
                { 
                    b[u][i+1-u]=s;
                }
                else
                { 
                    b[i+1-u][u]=s;
                }
                s++;
            }
        }
        for(i=n+1;i<2*n;i++)
        { 
            for(u=1;u<=2*n-i;u++)
            { 
                if(i%2==0)
                { 
                    b[i-n+u][n+1-u]=s;
                }
                else
                { 
                    b[n+1-u][i-n+u]=s;
                }
                s++;
            }
        }
        for(i=1;i<=n;i++)
        { 
            for(u=1;u<=n;u++)
            { 
                printf("%4d",b[i][u]);
            }
            printf("\n");
        }
    }

### 5. 亲密数\_1 ###

**题目内容**：  
2500年前数学大师毕达哥拉斯就发现，220与284两数之间存在着奇妙的联系：  
220的真因数之和为：1+2+4+5+10+11+20+22+44+55+110=284  
284的真因数之和为：1+2+4+71+142=220  
毕达哥拉斯把这样的数对称为相亲数。相亲数，也称为亲密数，如果整数A的全部因子（包括1，不包括A本身）之和等于B，且整数B的全部因子（包括1，不包括B本身）之和等于A，则将整数A和B称为亲密数。  
从键盘任意输入两个整数m和n，编程判断m和n是否是亲密数。若是亲密数，则输出“Yes!”，否则输出“No!”  
程序运行示例1  
Input m, n:  
220,284↙  
Yes!  
程序运行示例2  
Input m, n:  
224,280↙  
No!  
**输入提示信息**：“Input m, n:\\n”  
**输入格式**: “%d,%d”  
**输出格式**：  
输出提示信息：“Yes!\\n”  
“No!\\n”

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    int main()
    { 
        int m,n,a,b,d[1000],e[1000],i=0,u,y,sum1=0,sum2=0;
        float c;
        printf("Input m, n:\n");
        scanf("%d,%d",&m,&n);
        for(a=2;a<m;a++)
        { 
            b=m/a;
            c=(float)m/a;
            if(b==c)
            { 
                d[i]=a;
                i++;
                u=i;
            }
        }
        for(a=2,i=0;a<n;a++)
        { 
            b=n/a;
            c=(float)n/a;
            if(b==c)
            { 
                e[i]=a;
                i++;
                y=i;
            }
        }
        for(i=0;i<u;i++)
        { 
           sum1+=d[i];
        }
        for(i=0;i<y;i++)
        { 
            sum2+=e[i];
        }
        if(sum1+1==n && sum2+1==m)
        { 
            printf("Yes!\n");
        }
        else
        { 
            printf( "No!\n");
        }
        return 0;
    }

### 6. 亲密数\_2 ###

**题目内容**：  
2500年前数学大师毕达哥拉斯就发现，220与284两数之间存在着奇妙的联系：  
220的真因数之和为：1+2+4+5+10+11+20+22+44+55+110=284  
284的真因数之和为：1+2+4+71+142=220  
毕达哥拉斯把这样的数对称为相亲数。相亲数，也称为亲密数，如果整数A的全部因子（包括1，不包括A本身）之和等于B，且整数B的全部因子（包括1，不包括B本身）之和等于A，则将整数A和B称为亲密数。  
从键盘任意输入一个整数n，编程计算并输出n以内的全部亲密数。  
程序运行示例1  
Input n:  
3000↙  
(220,284)  
(1184,1210)  
(2620,2924)  
程序运行示例2  
Input n:  
1000↙  
(220,284)  
**输入提示信息**：“Input n:\\n”  
**输入格式**: “%d”  
**输出格式**： “(%d,%d)\\n”

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    
    int main()
    { 
        int m,n,a,t,sum1,sum2;
        printf("Input n:\n");
        scanf("%d",&t);
        for(m=1;m<t;m++)
        { 
            for(sum1=0,a=1;a<m/2+1;a++)
            { 
                if(m%a==0)
                { 
                    sum1+=a;
                }
            }
            for(sum2=0,n=1;n<sum1/2+1;n++)
            { 
                if(sum1%n==0)
                { 
                    sum2+=n;
                }
            }
            if(sum2==m && m<=sum1 && m!=sum1)
            { 
                printf("(%d,%d)\n",m,sum1);
            }
        }
        return 0;
    }

### 7. 完全数 ###

**题目内容**：  
完全数（Perfect Number），又称完美数或完数，它是指这样的一些特殊的自然数。它所有的真因子（即除了自身以外的约数）的和，恰好等于它本身，即m的所有小于m的不同因子（包括1）加起来恰好等于m本身。注意：1没有真因子，所以1不是完全数。计算机已经证实在10300以下，没有奇数的完全数。例如，因为6 = 1 + 2 + 3，所以6是一个完全数。  
从键盘任意输入一个整数m，编程判断m是否是完全数。若m是完全数，则输出“Yes!”，并同时打印出每一个完美数的全部因子，以验证这个数确实是一个完美数。若m不是完全数，则输出“No!”  
程序运行示例1  
Input m:  
28↙  
Yes!  
1,2,4,7,14  
程序运行示例2  
Input m:  
6↙  
Yes!  
1,2,3  
程序运行示例3  
Input m:  
1↙  
No!  
**输入信息提示**：“Input m:\\n”  
**输入格式**: “%d”  
**输出格式**：  
**输出格式**： “%d”  
**输出信息提示**：“Yes!\\n”  
“No!\\n”

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    int main()
    { 
        int m,a,s[1000],i,u=0,d;
        printf("Input m:\n");
        scanf("%d",&m);
        for(a=2,d=1;a<m;a++)
        { 
            if(m%a==0)
            { 
                s[u]=a;
                d+=s[u];
                u++;
            }
        }
        if(d!=m)
        { 
            printf("No!\n");
        }
        else
        { 
            printf("Yes!\n");
            printf("1");
            for(i=0;i<u;i++)
            { 
                printf(",%d",s[i]);
            }
        }
        return 0;
    }

### 8. 回文素数 ###

**题目内容**：  
所谓回文素数是指对一个素数n，从左到右和从右到左读是相同的，这样的数就称为回文素数，例如11，101，313等。编程计算并输出不超过n（100<=n<1000）的回文素数，并统计这些回文素数的个数，其中n的值从键盘输入。  
程序运行示例1  
Input n:  
100↙  
11  
count=1  
程序运行示例2  
Input n:  
1000↙  
11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929  
count=16  
**输入提示信息**：“Input n:\\n”  
**输入格式**:"%d"  
**输出格式**：  
回文素数的输出格式："%4d"  
统计回文素数个数的输出格式： “\\ncount=%d\\n”

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    int main()
    { 
        int n,a,q,w,e,r,i=0;
        printf("Input n:\n");
        scanf("%d",&n);
        for(a=2;a<=n;a++)
        { 
            if(FF(a))
            { 
                q=a/1000,w=(a%1000)/100,e=(a%100)/10,r=a%10;
                if((q==0 && w==r) || (q==0 && w==0 &&e==r) || (q==r && w==e))
                { 
                    printf("%4d",a);
                    i++;
                }
            }
        }
        printf( "\ncount=%d\n",i);
        return 0;
    }
    int FF(int b)
    { 
        int a;
        for(a=2;a<=sqrt(b);a++)
        { 
            if(b%a==0)
            { 
                return 0;
            }
        }
        return 1;
    }

### 9. 梅森尼数 ###

**题目内容**：  
形如2 i-1的素数，称为梅森尼数。编程计算并输出指数i在\[2,n\]中的所有梅森尼数，并统计这些梅森尼数的个数，其中n的值由键盘输入，并且n的值不能大于50。其中，2i表示2的i次方，请不要使用pow(2,i)编程计算，应采用循环累乘求积的方式计算2^i。  
提示：当i 超过30以后，2^i-1的值会很大，不能用long型变量来存储，必须使用double类型来存储。对于double类型变量x（不是整型）不能执行求余运算，即不能用 x % i == 0来判断x是否能被i整除，可以使用 x / i == (int)(x/i)来判断x是否能被i整除。  
程序运行示例：  
Input n:  
50↙  
2^2-1=3  
2^3-1=7  
2^5-1=31  
2^7-1=127  
2^13-1=8191  
2^17-1=131071  
2^19-1=524287  
2^31-1=2147483647  
2^49-1=562949953421311  
count=9  
**输入提示信息**：“Input n:\\n”  
**输入格式**: “%d”  
**输出格式**：  
梅森尼数的输出格式： “2^%d-1=%.0lf\\n”  
统计梅森尼数个数的输出格式： “count=%d\\n”

**代码实现：**

#include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    int FF(int a);
    int main()
    { 
        int n,i,s=0;
        printf("Input n:\n");
        scanf("%d",&n);
        for(i=2;i<=n;i++)
        { 
            if(FF(i)==1)
            { 
                printf( "2^%d-1=%.0lf\n",i,pow(2,i)-1);
                s++;
            }
        }
        printf( "count=%d\n",s);
        return 0;
    }
    int FF(int a)
    { 
        int i;
        double d=1;
        d=pow(2,a)-1;
        for(i=2;i<=sqrt(d);i++)
        { 
            if((d/i)==(int)(d/i))
            { 
                return 0;
            }
        }
        return 1;
    }

### 10. 工资统计 ###

**题目内容**：  
某公司有职员（最多50人），试编写程序打印最高工资、最低工资和平均工资。公司人数在主函数给出，职工工资输入请调用Input函数，计算最高工资、最低工资和平均工资调用Compute函数，打印最高工资、最低工资和平均工资在主函数。请在给定的框架下写出完整程序。

程序运行结果示例：  
Please input n:  
10↙  
1200.34↙  
2378.48↙  
8600.56↙  
5372.42↙  
6317.25↙  
7265.88↙  
=2156.39↙  
1876.31↙  
1792.14↙  
4326.22↙  
maxwage=8600.56, minwage=1200.34, avewage=4128.60  
**输入人数提示信息**：“Please input n:\\n”  
**人数输入格式**："%d"  
**工资输入格式**："%f"  
**输出格式**：“maxwage=%.2f, minwage=%.2f, avewage=%.2f\\n”

**代码实现：**

#include<stdio.h>
    void Input(float wage[], int n);
    float Compute(float wage[], int n, float *pmaxwage, float *pminwage);
    int main()
    { 
        float wage[50],maxwage,minwage,avewage;
        int n;
        printf("Please input n:\n");
        scanf("%d",&n);
        Input(wage,n);
        avewage=Compute(wage,n,&maxwage,&minwage);
        printf("maxwage=%.2f, minwage=%.2f, avewage=%.2f\n",maxwage,minwage,avewage);
        return 0;
    }
    void Input(float wage[], int n)
    { 
         int i;
         for(i=0;i<n;i++)
         { 
             scanf("%f",&wage[i]);
         }
    }
    float Compute(float wage[], int n, float *pmaxwage, float *pminwage)
    { 
        int i;
        float sumh=0;
        for(i=0,*pmaxwage=*pminwage=wage[0];i<n;i++)
        { 
            if(wage[i]>=*pmaxwage)
            { 
                *pmaxwage=wage[i];
            }
            if(wage[i]<=*pminwage)
            { 
                *pminwage=wage[i];
            }
            sumh+=wage[i];
        }
        return sumh/n;
    }

[C]: https://blog.csdn.net/weixin_45652695/article/details/104180651