期中编程考试参考答案

===== 01:小明买雪糕 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

小明有5元钱，他想去买雪糕吃，雪糕的价格各不相同，根据雪糕的价格，计算小明最多能买多少根雪糕。

输入

输入只有一个数，一根雪糕的价格，单位是元。

输出

输出只一个整数，小明最多能买到的雪糕数。

样例输入

1.3

样例输出

3

#include <iostream>
using namespace std;

int main() {
    double a;
    cin >> a;
    cout << (int)(5 / a) << endl;
    return 0;
}

===== 02:判断闰年 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

判断某年是否是闰年。

输入

输入只有一行，包含一个整数a(0 < a < 3000)

输出

一行，如果公元a年是闰年输出Y，否则输出N

样例输入

2006

样例输出

N

提示

公历纪年法中，能被4整除的大多是闰年，但能被100整除而不能被400整除的年份不是闰年， 能被3200整除的也不是闰年，如1900年是平年，2000年是闰年，3200年不是闰年。

#include <iostream>
using namespace std;
int main(){

    int a;
    cin >> a;
    /*
    闰年的判断条件：
    能被4整除的大多数是闰年
    但能被100整除，而不能被400整除的不是闰年
    能被3200整除的也不是闰年
    */
    if (a % 4 == 0 && !(a % 100 == 0 && a % 400 != 0) &&(a % 3200 != 0))
        cout << ‘Y‘;
    else
        cout << ‘N‘;
    cout << endl;
    return 0;
}

===== 03:短信计费 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

用手机发短信，一般一条短信资费为0.1元，但限定每条短信的内容在70个字以内（包括70个字）。如果你所发送的一条短信超过了70个字，则大多数手机 会按照每70个字一条短信的限制把它分割成多条短信发送。假设已经知道你当月所发送的每条短信的字数，试统计一下你当月短信的总资费。

输入

第一行是整数n，表示当月短信总条数，其余n行每行一个整数，表示各条短信的字数。

输出

当月短信总资费，单位为元，精确到小数点后1位。

样例输入

10
39
49
42
61
44
147
42
72
35
46

样例输出

1.3

#include <iostream>
#include <iomanip>
using namespace std;
int main(){
    // n是短信条数
    int n;
    // words用于记录一条短信的数目
    int words;
    // money是短信总资费
    double cost = 0.0;

    // 输入短信总条数
    cin >> n;
    // 处理每条短信
    for (int i = 0; i < n; i++){
        cin >> words;
        if(words % 70 !=0)
            cost += words/ 70 * 0.1+0.1;
        else
            cost +=words / 70 * 0.1;
    }
    cout << fixed << setprecision(1) << cost << endl;

    return 0;
}

===== 04:不与最大数相同的数字之和 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

输出一个整数数列中不与最大数相同的数字之和

输入

输入分为两行：                 第一行为N(N为接下来数字的个数，N <= 100)；                 第二行为N个整数，以空格隔开；

输出

输出为N个数中除去最大数其余数字之和。（注意，最大数可能出现多次）

样例输入

3
1 2 3 

样例输出

3

#include <iostream>
using namespace std;

int main(){

    //n是输入的数字个数，n<=100
    int n;
    //a记录输入的数字
    int a[100];
    //max记录最大数
    int max = 0;
    //sum记录除去最大数之后的数字之和
    int sum = 0;
    int i = 0;
    cin >> n;

    // 输入并找出最大数
    for (i = 0; i < n; i++){
        cin >> a[i];
        if (a[i] > max)
            max = a[i];            

    }
    // 求最大数以外的和
    for (i = 0; i < n; i++) {
        if (a[i] != max)
            sum += a[i];       

    }
    // 输出
    cout << sum;

    return 0;
}

===== 05:能被3，5，7整除的数 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

输入一个整数，判断它能否被3，5，7整除，并输出以下信息：                 1、能同时被3，5，7整除（直接输出3 5 7，每个数中间一个空格）；                 2、能被其中两个数整除（输出两个数，小的在前，大的在后。例如：3 5或者 3 7或者5 7,中间用空格分隔）                 3、能被其中一个数整除（输出这个除数）                 4、不能被任何数整除；（输出小写字符‘n‘,不包括单引号)

输入

一个数字

输出

一行数字,从小到大排列,包含3,5,7中为该输入的除数的数字,数字中间用空格隔开

样例输入

0
5
15
105

样例输出

3 5 7
5
3 5
3 5 7

提示

因为有多组测试数据,程序通过下面方式读入n                
int n;                 while(cin>>n)                 {                 //你的代码                 }                
good luck:)

#include <iostream>
using namespace std;

int main() {
    int n;
    while(cin >> n) {
        if(n % 3 == 0) {
            cout << 3 << " ";
        }
        if(n % 5 == 0) {
            cout << 5 << " ";
        }
        if(n % 7 == 0) {
            cout << 7 << " ";
        }
        if(n%3!=0 && n%5!=0 && n%7!=0) {
            cout << "n";
        }
        cout << endl;
    }

    return 0;
}

===== 06:鸡尾酒疗法 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

鸡尾酒疗法，原指“高效抗逆转录病毒治疗”（HAART），由美籍华裔科学家何大一于1996年提出，是通过三种或三种以上的抗病毒药物联合使用来治疗艾 滋病。该疗法的应用可以减少单一用药产生的抗药性，最大限度地抑制病毒的复制，使被破坏的机体免疫功能部分甚至全部恢复，从而延缓病程进展，延长患者生 命，提高生活质量。人们在鸡尾酒疗法的基础上又提出了很多种改进的疗法。为了验证这些治疗方法是否在疗效上比鸡尾酒疗法更好，可用通过临床对照实验的方式 进行。假设鸡尾酒疗法的有效率为x，新疗法的有效率为y，如果y-x大于5%，则效果更好，如果x-y大于5%，则效果更差，否则称为效果差不多。下面给                    出n组临床对照实验，其中第一组采用鸡尾酒疗法，其他n-1组为各种不同的改进疗法。请写程序判定各种改进疗法效果如何。

输入

第一行为整数n；                 其余n行每行两个整数，第一个整数是临床实验的总病例数，第二个疗效有效的病例数。                 这n行数据中，第一行为鸡尾酒疗法的数据，其余各行为各种改进疗法的数据。

输出

有n-1行输出，分别表示对应改进疗法的效果：                 如果效果更好，输出better；如果效果更差，输出worse；否则输出same

样例输入

5
125 99
112 89
145 99
99 97
123 98

样例输出

same
worse
better
same

#include <iostream>
using namespace std;
int main(){

    // 组数
    int num;
    cin >> num;

    // 记录鸡尾酒疗法的总人数、有效人数
    double totalCock, positiveCock;
    double ratioCock;
    cin >> totalCock >> positiveCock;
    if(totalCock > 0 && positiveCock > 0 && totalCock > positiveCock){

        ratioCock = (positiveCock / totalCock) * 100;

           // cout << ratioCock;
         // 处理n-1个数据

        num = num -1;

         for(int i = 0; i < num; i++){
            double tmpTotal = 0, tmpPositive = 0;
            cin >> tmpTotal >> tmpPositive;
            if((tmpTotal > tmpPositive )&& (tmpTotal > 0) && (tmpPositive > 0)){

                double tmpRatio = (tmpPositive / tmpTotal) * 100;

                if (tmpRatio-ratioCock  > 5){
                    cout << "better" << endl;
                }
                 else if (ratioCock - 5 > tmpRatio ){
                      cout << "worse" << endl;
                 }
                 else{
                  cout << "same" << endl;
                 }
            }
            else{
                cout << endl;
                continue;
            }
        }
    }
    return 0;
}

===== 07:最远距离 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

给定一组点(x,y)，求距离最远的两个点之间的距离。

输入

第一行是点数n（n大于等于2）                 接着每一行代表一个点，由两个浮点数x y组成。

输出

输出一行是最远两点之间的距离。                 使用printf("%.4f\n", dis)输出距离值并精确到小数点后4位。

样例输入

6
34.0 23.0
28.1 21.6
14.7 17.1
17.0 27.2
34.7 67.1
29.3 65.1

样例输出

53.8516

提示

注意在内部计算时最好使用double类型，但在用scanf读取数据时只能用float类型的变量。

#include <iostream>
#include<iomanip>
#include<cmath>
using namespace std;
int main(){
    // 所有点的X,Y坐标。假设最多有100个点
    double X[100], Y[100];
    // 记录最大的距离平方
    double maxDisSquare = 0;
    // 点的数量
    int num;
    cin >> num;
    for (int i = 0; i < num; i++){
        cin >> X[i] >> Y[i];
        // 比较与已有的点的距离
        for (int j = 0; j < i; j++){
            double DisSquare = pow(X[j]-X[i],2)+pow(Y[j]-Y[i],2);
            if (maxDisSquare < DisSquare) maxDisSquare = DisSquare;
        }
    }
    cout << fixed << setprecision(4) << sqrt(maxDisSquare) << endl;
    return 0;
}

===== 08:完美立方 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

a的立方 = b的立方 + c的立方 + d的立方为完美立方等式。例如12的立方 = 6的立方 + 8的立方 + 10的立方 。编写一个程序，对任给的正整数N (N≤100)，寻找所有的四元组(a, b, c, d)，使得a的立方 = b的立方 + c的立方 + d的立方，其中a,b,c,d 大于 1, 小于等于N。

输入

正整数N (N≤100)

输出

每行输出一个完美立方，按照a的值，从小到大依次输出。当两个完美立方等式中a的值相同，则依次按照b、c、d进行非降升序排列输出，即b值小的先输出、然后c值小的先输出、然后d值小的先输出。

样例输入

24

样例输出

Cube = 6, Triple = (3,4,5)
Cube = 12, Triple = (6,8,10)
Cube = 18, Triple = (2,12,16)
Cube = 18, Triple = (9,12,15)
Cube = 19, Triple = (3,10,18)
Cube = 20, Triple = (7,14,17)
Cube = 24, Triple = (12,16,20) 

#include<iostream>
using namespace std;
int main(){
    // 上限
    int limit;
    cin >> limit;

    for(int a = 2; a <= limit; a++){
        for(int b = 2; b < a; b++)
            for(int c = b; c < a; c++)
                for(int d = c; d < a; d++){
                    if(a * a * a == b * b * b + c * c * c + d * d * d)
                        cout << "Cube = " << a << ", Triple = ("
                             << b << "," << c << "," << d << ")" << endl;
                }
    }
    return 0;
}

===== 09:素数 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

输入一个正整数，请判断它是不是素数。如果是输出yes，不是则输出no

输入

输入仅一行，一个正整数，范围是1到3000之间

输出

输出也仅一行，yes或者no

样例输入

10

样例输出

no

#include <iostream>
using namespace std;

int main(){

    bool is = true;
    int num;
    cin >> num;

    if (num == 1) {
        cout << "no" << endl;
        return 0;
    }
    for (int i = 2; i < num; i++) {
        if (num % i == 0){
            is = false;
            break;
        }
    }
    cout << ((is)?"yes":"no") << endl;

    return 0;
}

===== 10:统计字符数 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

判断一个由a-z这26个字符组成的字符串中哪个字符出现的次数最多

输入

第1行是测试数据的组数n，每组测试数据占1行，是一个由a-z这26个字符组成的字符串                 每组测试数据之间有一个空行，每行数据不超过1000个字符且非空

输出

n行，每行输出对应一个输入。一行输出包括出现次数最多的字符和该字符出现的次数，中间是一个空格。                 如果有多个字符出现的次数相同且最多，那么输出ascii码最小的那一个字符

样例输入

2
abbccc

adfadffasdf

样例输出

c 3
f 4

#include<iostream>
#include<cstring>
using namespace std;
int main(){
    // 组数
    int group;
    cin >> group;
    // 字符串
    char str[1001];

    // 不断地输入并处理每组数据
    for(int iG = 0; iG < group; iG++){
        cin >> str;
        int cnt[27] = {0};
        for(int i = 0; i < strlen(str); i++){
            // 计数并累计至cnt数组中
                cnt[str[i]-‘a‘]++;
        }

        // 找出出现最多的字母及其数量
        int mostAlphabetIdx = 0;
        int maxCnt = 0;
        for (int i=0; i<26; i++) {
            if (cnt[mostAlphabetIdx] < cnt[i]) {

                mostAlphabetIdx = i;
            }
        }
        maxCnt = cnt[mostAlphabetIdx];

        cout << (char) (‘a‘ + mostAlphabetIdx)
        << " " << maxCnt << endl;
    }
    return 0;
}

===== 11:计算书费 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

下面是一个图书的单价表：                 计算概论 28.9 元/本                 数据结构与算法 32.7 元/本                 数字逻辑 45.6元/本                 C++程序设计教程 78 元/本                 人工智能 35 元/本                 计算机体系结构 86.2 元/本                 编译原理 27.8元/本                 操作系统 43 元/本                 计算机网络 56 元/本                 JAVA程序设计 65 元/本                 给定每种图书购买的数量，编程计算应付的总费用。                

输入

输入第一行包含一个正整数k（0                

输出

对于每组测试数据，输出一行。该行包含一个浮点数f，表示应付的总费用。精确到小数点后两位。                
可用printf("%.2f\n", sum)来输出sum的值，并精确到小数点后两位。

样例输入

2
1 5 8 10 5 1 1 2 3 4
3 5 6 3 100 1 1 0 1 0

样例输出

2140.20
4427.80

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
    // 多组数据
    int numGroup = 0;
    cin >> numGroup;

    // 书的数量
    int numBook = 10;

    // price为每本书的价格
    double price[] = {28.9, 32.7, 45.6, 78, 35, 86.2, 27.8, 43, 56, 65};

    // 处理多组输入
    for (int iGroup = 0; iGroup < numGroup; iGroup++){

        // sum为总价
        double sum = 0;
        // 处理每一本书
        for (int iBook = 0; iBook < numBook; iBook++){
            int num;
            cin >> num;
            sum += num * price[iBook];
        }
        // 按要求输出
        cout << fixed << setprecision(2) << sum << endl;
    }

    return 0;
}

===== 12:学分绩点 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

北京大学对本科生的成绩施行平均学分绩点制（GPA）。既将学生的实际考分根据不同的学科的不同学分按一定的公式进行计算。                     公式如下：                     实际成绩 绩点                     90——100 4.0                     85——89 3.7                     82——84 3.3                     78——81 3.0                     75——77 2.7                     72——74 2.3                     68——71 2.0                     64——67 1.5                     60——63 1.0                     60以下 0                     1．一门课程的学分绩点=该课绩点*该课学分                     2．总评绩点=所有学科绩点之和/所有课程学分之和                     现要求你编写程序求出某人A的总评绩点（GPA）。

输入

第一行 总的课程数n（n<10）；                     第二行 相应课程的学分（两个学分间用空格隔开）；                     第三行 对应课程的实际得分；                     此处输入的所有数字均为整数。                    

输出

输出有一行，总评绩点，精确到小数点后2位小数。

样例输入

5
4 3 4 2 3
91 88 72 69 56

样例输出

2.52

#include<iostream>
#include<iomanip>
using namespace std;
int main(){
    // 成绩与绩点对应关系共10档
    // SCORE记录每一档成绩的下限、对应的GP记录这一档成绩的绩点
    int nCLASS = 10;
    int SCORE[] = {90, 85, 82, 78, 75, 72, 68, 64, 60, 0};
    double GP[] = {4, 3.7, 3.3, 3.0, 2.7, 2.3, 2.0, 1.5, 1.0, 0};
    // credits记录每门课
    int credits[10] = {0};
    // 课程数
    int nCourse = 0;
    cin >> nCourse;
    // 输入所有课的学分
    for (int iCourse = 0; iCourse < nCourse; iCourse++)
        cin >> credits[iCourse];
    // 初始化总学分和总绩点（乘以权重）
    // 即 totalGP = sum over all courses {credit * gp}
    int totalCredit = 0;
    double totalGP = 0;
    // 输入每门课的成绩并判断绩点，并累加至totalGP中
    for (int iCourse = 0; iCourse < nCourse; iCourse++){
        int tmpScore = 0;
        cin >> tmpScore;
        totalCredit += credits[iCourse];
        // 判断这个成绩落入哪个绩点类别
        for (int iClass = 0; iClass < nCLASS; iClass++){
            if (tmpScore >= SCORE[iClass]){
                totalGP += credits[iCourse] * GP[iClass];
                break;
            }
        }
    }
    cout << fixed << setprecision(2) << (totalGP / totalCredit) << endl;
}

===== 13:停车场收费 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

一个停车场的标准收费是3小时之内收5元，超过3小时，每增加1小时加收2元；如果时间不是整数，按比例收取，例如：如果输入为3.6小时，则费用为5 + (3.6-3)*2 = 6.2 元。最高收费为40元。假设任何车辆的停车时间都不超过24小时。编写程序，计算每辆车的停车费。(注意输出结果小数点后保留两位)

输入

输入停车的时间

输出

输出应该收取的停车费用

样例输入

2
3
3.46

样例输出

5.00
5.00
5.92

#include<iostream>
#include <iomanip>
using namespace std;
int main(){
    double time;
    while(cin >> time){
        double cost = 0;
        if(time <= 3)
            cost = 5.00;
        else if(time <= 24){
            cost = 5.00 + (time - 3)*2;
            if(cost > 40)
                cost = 40;
        }
        cout << fixed << setprecision(2) << cost << endl;
    }
    return 0;
}

===== 14:整数的立方和 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

给定一个正整数k（1                        

输入

输入只有一行，该行包含一个正整数k。

输出

输出只有一行，该行包含1到k的立方和。

样例输入

5 

样例输出

225

#include <iostream>
#include<iomanip>
using namespace std;
int main(){
    int k;
    cin >> k;
    int sum = 1;
    for(int i = 2; i <= k; i++){
        sum += i*i*i;
    }
    cout << sum << endl;
    return 0;
}

===== 15:自整除数 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

对一个整数n,如果其各个位数的数字相加得到的数m能整除n,则称n为自整除数.例如21,21%(2+1)==0,所以21是自整除数.现求出从10到n(n < 100)之间的所有自整除数.

输入

有一行,整数n,(10 <= n < 100)

输出

有多行.按从小到大的顺序输出所有大于等于10,小于等于n的自整除数,每行一个自整除数.

样例输入

47

样例输出

10
12
18
20
21
24
27
30
36
40
42
45

#include <iostream>
using namespace std;
int main(){
    int n;
    cin >> n;
    for(int i = 10; i <= n; i++)
        if(i % (i / 10 + i % 10) == 0)
            cout << i << endl;
    return 0;
}

===== 17:满足条件的整数 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

假设a、b、c均为整数，且满足a，b，c 大于1，并且小于等于100，找出所有符合条件：“a的平方 + b的平方 = c的平方”的整数组。

输入

无

输出

按a从小到大的顺序输出所有满足条件的整数组（若a相同，则按b从小到大的顺序输出），每行一组，每一组数据的输出样式为：                            
3*3 + 4*4 = 5*5                            
注意：                            
1）3*3 + 4*4 = 5*5 和 4*4 + 3*3 = 5*5是同一组数据，后者不要输出；                             2）加号和等号左右各有一个空格                             3）9*9 + 12*12 = 15*15 （在前）                             9*9 + 40*40 = 41*41 （在后）                            

样例输入

样例输出

#include <iostream>
using namespace std;
int main(){
    for(int i = 2; i <= 100; i++){
        for(int j = i; j <= 100; j++){
            int k = i*i + j*j;
            for(int p = 2; p <= 100; p++){
                if(p*p == k)
                    cout << i << ‘*‘ << i << " + " << j << ‘*‘ << j << " = " << p << ‘*‘ << p << endl;
            }
        }
    }
    return 0;
}

===== 18:最大商 =====

总时间限制:

5000ms

内存限制:

65536kB

描述

给一组数，前后相邻的两个数相除，输出商最大的两个数及商的值。

输入

第一行为数组中浮点数的个数n，n大于2，其余n行为每一行一个浮点数。

输出

以下面的形式输出结果，前两个数是相除的两个数，最后一个数为最大的商值。                             printf("%f / %f = %f\n", a[maxi-1], a[maxi], maxq);

样例输入

10
41.0
18467.0
6334.0
26500.0
19169.0
15724.0
11478.0
29358.0
26962.0
24464.0

样例输出

18467.000000 / 6334.000000 = 2.915535

提示

应使用动态数组保存输入的浮点数。                             运算过程中应只使用float类型的浮点数。

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
    int n; // 数字的个数
    cin >> n;

    float maxq = 0; // maxq记录截止当前的最大商，初始为0。注意：这道题请用float
    float maxd = 0; // maxd记录最大商的分子
    float maxn = 0; // maxn记录最大商的分母

    float last2; // last2记录当前数的前两个数
    float last; // last记录当前数
    cin >> last; // 输入第一个数，且无需比较

    for (int i = 1; i < n; i++) {
        // 更新本次读入的数
        last2 = last;
        cin >> last;
        if (last2 / last > maxq) {
            maxq = last2 / last;
            maxd = last2;
            maxn = last;
        }
    }
    cout << fixed << setprecision(6) << maxd << " / " << maxn << " = " << maxq << endl;

    return 0;
}

===== 19:简单计算器 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

一个最简单的计算器，支持+, -, *, / 四种运算。仅需考虑输入输出为整数的情况，数据和运算结果不会超过int表示的范围。

输入

输入只有一行，共有三个参数，其中第1、2个参数为整数，第3个参数为操作符（+,-,*,/）。

输出

输出只有一行，一个整数，为运算结果。然而：                             1. 如果出现除数为0的情况，则输出：Divided by zero!                             2. 如果出现无效的操作符(即不为 +, -, *, / 之一），则输出：Invalid operator!

样例输入

1 2 +

样例输出

3

提示

可以考虑使用if和switch结构。

#include<iostream>
using namespace std;
int main(){
    int a, b;
    char op;
    cin >> a >> b >> op;
    if (op == ‘+‘)
        cout << a + b << endl;
    else if (op == ‘-‘)
        cout << a - b << endl;
    else if (op == ‘*‘)
        cout << a * b << endl;
    else if (op == ‘/‘) {
        if (b == 0)
            cout << "Divided by zero!"<< endl;
        else if (b != 0)
            cout << a / b << endl;
    } else
        cout << "Invalid operator!" << endl;
}

===== 20:字符串插入 =====

总时间限制:

1000ms

内存限制:

65536kB

描述

有两个字符串str和substr，str的字符个数不超过10，substr的字符个数为3。（字符个数不包括字符串结尾处的‘\0‘。）将substr插入到str中ASCII码最大的那个字符后面，若有多个最大则只考虑第一个。

输入

输入包括若干行，每一行为一组测试数据，格式为                                 str substr

输出

对于每一组测试数据，输出插入之后的字符串。

样例输入

abcab eee
12343 555

样例输出

abceeeab
12345553

#include <iostream>
using namespace std;

int main() {
    char string[20], substr[10];

    // 处理多组数据
    while (cin >> string){

        cin >> substr;
        // get max ASCII char & location index
        int maxChar = 0;
        int maxIndex = 0;

        // 遍历数组，并获得相关信息
        for (int i = 0; i < 11; i++) {
            if (string[i] == ‘\0‘) break;
            if (string[i] > maxChar){
                maxIndex = i;
                maxChar = string[i];
            }
        }

        // 输出，先输出str的前半部分、再输出substr、最后输出str的后半部分
        for (int i = 0; i <= maxIndex; i++) {
            cout << string[i];
        }
        cout << substr;
        for (int i = maxIndex + 1; i < 11; i++) {
            if (string[i] == ‘\0‘) break;
            cout << string[i];
        }
        cout << endl;
    }

    return 0;
}