2014年武汉大学复试上机题目

向右看齐 2022-03-25 08:16 185阅读 0赞

### ***Q1.* 编写程序可计算如下分段函数：** ###

![20190119171400746.PNG][]

#include <iostream>
    #include <math.h>
    using namespace std;
    
    double calc(double x)
    {
        double m;
        if(x>0)
            m=(sqrt(x)+exp(x))/(5.0*x+5);
        else
            m=(2.0/3+sin(60/180.0*M_PI))*(-x);//sin函数中变量为弧度，而不是度数，即sin（π/3）=sin（60）,fabs(x):求x的绝对值
        return m;
    }
    int main()
    {
        double a;
        cin>>a;
        cout<<calc(a)<<endl;
        return 0;
    }

运行结果：

![20190119173045306.PNG][]

### ***Q2.*** 从键盘输入一个字符串，将此字符串按字符的ASCII码值从小到大排序，并显示排序后的字符串。 ###

#include <iostream>
    #include <stdio.h>
    #include <string.h>
    using namespace std;
    int main()
    {
        char a[100],tmp;
        int n;
        scanf("%s",a);   //接受字符串放入字符数组中
        n = strlen(a);   //计算字符串的长度
        for(int i=0; i<n-1; i++) //进行冒泡排序
        {
            for(int j=n-1; j>i; j--)
            {
                if(a[j]<a[j-1])
                {
                    tmp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = tmp;
                }
            }
        }
        for(int k=0; k<n; k++)  //输出排序好的字符串数组
            cout<<a[k];
        cout<<endl;
    
        return 0;
    }

运行结果：

![20190119180053875.PNG][]

#include <stdio.h>
    #include <algorithm>
    #include <string.h>
    using namespace std;
    int main()
    {
        char str[100];
        int n;
        while(gets(str))
        {
            n=strlen(str);
            sort(str,str+n);
            puts(str);
        }
        return 0;
    }

运行结果：

![20190120085953525.PNG][]

### ***Q3.*** 编写程序显示2-1000之间的所有完数，所谓完数是指，该数的各因子之和正好等于该数本身。 ###

#include <iostream>
    using namespace std;
    
    int main()
    {
        for(int j=2; j<=1000; j++)   //求2-1000之间的完数
        {
            int sum=0;     //求该数各因子之和
            for(int k=1; k<j; k++)  
            {
                if(j%k==0)
                    sum+=k;
            }
            if(j==sum)    //若该数与该数因子之和相等，则输出
                cout<<j<<endl;
        }
        return 0;
    }

运行结果：

![20190119183230302.PNG][]

### ***Q4.*** 编写程序，判断键盘输入的用户名字符串的合法性。 ###

### 用户名要求总长度不少于10个字符，首字符必须是字母，其他位置必须含有2-6个不重复的数字，不能含有等号（=）和星号（\*）号。 ###

### 例如：m123abc456是合法用户名 ###

#include <stdio.h>
    #include <iostream>
    #include <string.h>
    using namespace std;
    int main()
    {
        char str[100];
        int n,i,j;
        while(gets(str))
        {
            n=strlen(str);
            int flag=1,count=0,c[10]= {0};//c[10]表示0-9数字的个数
            if(n<10)     //总长度不小于10个字符
                flag=0;
            if(str[0]<'A'||(str[0]>'Z'&&str[0]<'a')||str[0]>'z')   //首字母必须是字母
                flag=0;
            for(i=0; i<n; i++)
            {
                if(str[i]>='0'&&str[i]<='9')    //统计各个数字的个数
                {
                    j=str[i]-'0';
                    count+=1;
                    c[j]+=1;
                }
                if(str[i]=='='||str[i]=='*')   //不能含有等号（=）和星号（*）
                    flag=0;
            }
            if(count<2||count>6)   //必须含有2-6个数字
                flag=0;
            for(j=0; j<10; j++)  //判断各个数字是否重复
            {
                if(c[j]>1)
                    flag=0;
            }
            if(flag==1)
                cout<<"合法"<<endl;
            else
                cout<<"不合法"<<endl;
        }
        return 0;
    }

运行结果：  
![20190122181106475.PNG][]

### ***Q5.*** 显示5阶的魔方阵 ###

### N阶魔方阵是：元素为自然数1，2，…，N2的N×N方阵，每个元素值均不相等，每行、每列以及主、副对角线上各N个元素之和相等。 ###

### 例如3阶魔方阵为： ###

### 8 1 6 ###

### 3 5 7 ###

### 4 9 2 ###

### 提示：从1开始，依次放置各自然数，Dole Rob算法可以确定插入的每一个元素的下标： ###

1.  ### 第一个位置在第一行的正中。 ###
2.  ### 若最近一个插入元素为N的整数倍，则选下一行同列上的位置为新位置。 ###
3.  ### 新位置处于最近一个插入位置的右上方。 ###
4.  ### 若超出方阵上边界，则选该列的在最后一行的位置，若超过右边界，则选择该行的在最左一列的位置。 ###

### 参考示例的3阶魔方阵，理解算法提示，并编程实现。 ###

#include <iostream>
    using namespace std;
    
    int main()
    {
        int count=0,i=0,j,n,integer=0,a[10][10]= {0};  //count:已确认的数字个数,integer:放进去的数字，数组a为矩阵
        cin>>n;   //n阶魔方阵
        j=n/2;    //i,j代表矩阵中的位置
        while(count<n*n)
        {
            count++;
            integer++;
            a[i][j]=integer;  //第一个数字放入第一行的正中
            if(a[i][j]%n==0)   //最近一个插入元素为N的整数倍，则选下一行同列上的位置为新位置
            {
                i++;
            }
            else       //新位置处于最近一个插入位置的右上方
            {
                if(i-1>=0&&j+1<n)  //右上方位置在矩阵内，正常放入
                {
                    i--;
                    j++;
                }
                else if(i-1<0&&j+1<n)  //若超出方阵上边界，则选该列的在最后一行的位置
                {
                    i=n-1;
                    j++;
                }
                else        //若超过右边界，则选择该行的在最左一列的位置
                {
                    i--;
                    j=0;
                }
            }
        }
    
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
            {
                cout<<a[i][j]<<" ";
                if(j==n-1)
                    cout<<endl;
            }
        return 0;
    }

运行结果：

![20190123173457416.PNG][]

![201901231734028.PNG][]

[20190119171400746.PNG]: /images/20220325/87db365d990946c3a4c548bc31de63ac.png
[20190119173045306.PNG]: /images/20220325/189b27304af240ccbcb06a577179298f.png
[20190119180053875.PNG]: /images/20220325/b15464e6d28a47e0ae3ea98741094401.png
[20190120085953525.PNG]: /images/20220325/b5751e0bce9943e9ac41c8b0f81d4a51.png
[20190119183230302.PNG]: /images/20220325/1f8988b607784b988a82131bee3c1085.png
[20190122181106475.PNG]: /images/20220325/dc82ca060f58441793a1984149cdafa5.png
[20190123173457416.PNG]: /images/20220325/4cea2465eca9402fac5f985a3b8438b6.png
[201901231734028.PNG]: /images/20220325/e3fe92ce825d4bd0bf196c5e140e14cc.png