[大学计算] 期末自测 答案
BMI指数
体质量指数BMI（Body Mass Index），简称体质指数，是国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。
设体重为w（单位：公斤），身高为h（单位：米），BMI指数计算方法是：bmi=w/(h2)，其中2表示平方。BMI判断体型胖瘦的标准是：bmi < 18.5，属于偏瘦；18.5 <= bmi < 24，属于正常； 24 <= bmi <28，属于偏胖；bmi >= 28，属于肥胖。请上述公式，完成如下的体质指数判断函数功能：int bmiIndex(double weight, double height);其中，weight和height分别表示某人的体重和身高，该函数返回体型胖瘦的判断结果（为整数值，1、2、3、4分别表示偏瘦、正常、偏胖、肥胖）。
#include <iostream>
#include <iomanip>
using namespace std;
int bmiIndex(double weight, double height)
{
/**********Program**********/
double bmi = weight / (height * height);
if (bmi < 18.5)
{
return 1;
}
if (bmi < 24)
{
return 2;
}
if (bmi < 28)
{
return 3;
}
return 4;
/********** End **********/
}
int main()
{
double w,h;
cin >> w >> h;
cout << bmiIndex(w,h) << endl;
return 0;
}
中奖
某彩票号码共有八位，中奖规则如下：
一等奖：投注号码与当期开奖号码八位数字全部相同(顺序也相同，下同)，即中奖；
二等奖：投注号码与当期开奖号码中的前五位数字完全相同，且第八位也相同，即中奖；
三等奖：投注号码与当期开奖号码中的前五位号码完全相同，即中奖；
注意中奖等级以高奖优先，不叠加中奖。
请根据中奖规则，完成函数int lottery(int theNum, int luckyNum)功能，
判断投注号码的得奖等级，中奖则返回对应的得奖等级，未中奖则返回-1。
其中，参数theNum是投注号码，参数luckyNum是当期开奖号码。
例如：投注号码为12345678，当期开奖号码为12345768，由于两者
前五位号码均为12345，第八位均为8，其他号码不完全一致，中二等奖，结果返回2。
#include <iostream>
using namespace std;
int lottery(int theNum, int luckyNum)
{
/**********Program**********/
int num[10] = {0};
for (int i = 8; i >= 1; i --)
{
num[i] = theNum % 10;
theNum /= 10;
}
int lnum[10] = {0};
for (int i = 8; i >= 1; i --)
{
lnum[i] = luckyNum % 10;
luckyNum /= 10;
}
bool judge = 1;
for (int i = 1; i <= 8; i ++)
{
if (num[i] != lnum[i])
{
judge = 0;
}
}
if (judge == 1)
{
return 1;
}
judge = 1;
for (int i = 1; i <= 5; i ++)
{
if (num[i] != lnum[i])
{
judge = 0;
}
}
if (num[8] != lnum[8])
{
judge = 0;
}
if (judge == 1)
{
return 2;
}
judge = 1;
for (int i = 1; i <= 5; i ++)
{
if (num[i] != lnum[i])
{
judge = 0;
}
}
if (judge == 1)
{
return 3;
}
return -1;
/********** End **********/
}
int main()
{
int num, lucky;
cin >> num;
cin >> lucky;
cout << lottery(num, lucky) << endl;
return 0;
}
亏数
亏数（又称缺数)是一种特殊的自然数，指的是该数的所有
真因数（除去其自身）之和比这个数要小。然后，亏数的亏度
又定义为该数减去其真因数之和的结果。例如，15的真因数
包括1、3、5，1+3+5=9<15，所以15是亏数，其亏度为15-9=6。
请根据上述定义，完成如下函数功能：
int deficientNumber(int num);
该函数首先判断参数num是否为亏数，如果是则返回其亏度，
如果不是，则返回0。
#include <iostream>
using namespace std;
int deficientNumber(int num)
{
/**********Program**********/
int cnt = 0;
for (int i = 1; i <= num / 2; i ++)
{
if (num % i == 0)
{
cnt += i;
}
}
if (cnt < num)
{
return num - cnt;
}
return 0;
/********** End **********/
}
int main()
{
int n;
cin >> n;
cout << deficientNumber(n) << endl;
return 0;
}
去除0
函数digitTrim(int n)作用是删除参数n中的数字0，并返回删除
后的结果，例如digitTrim(1018)的结果是118，注意n是一个正整数。
请尝试用递归调用完成该函数的功能。
#include <iostream>
using namespace std;
int digitTrim(int n)
{
/**********Program**********/
if (n / 10 == 0)
{
return n;
}
if (n % 10 != 0)
{
return digitTrim(n / 10) * 10 + n % 10;
}
else
{
return digitTrim(n / 10);
}
/********** End **********/
}
int main()
{
int n;
cin >> n;
cout << digitTrim(n) << endl;
return 0;
}
单位向量
单位向量是指模为1的向量，任一非零向量除以它的模可以
求得对应的单位向量，向量模等于各个元素平方和的平方根。
例如，向量(1, -1, 2, 1, -3)的模为1+1+4+1+9=16的平方根，
即等于4，所以该向量的单位向量是(0.25, -0.25, 0.5, 0.25, -0.75)。
编写函数void unitVector(double a[], double b[])，
其中a中存储了包含5个元素的非零向量，计算得到对应的单位向量，
存放到数组b中。
提示：求平方根的函数是sqrt。
#include <iostream>
#include <cmath>
using namespace std;
void unitVector(double a[], double b[])
{
/**********Program**********/
double tot = 0;
for (int i = 0; i < 5; i ++)
{
tot += a[i] * a[i];
}
tot = sqrt(tot);
for (int i = 0; i < 5; i ++)
{
b[i] = a[i] / tot;
}
/********** End **********/
}
int main()
{
double a[5];
double b[5];
for(int i = 0; i < 5; i++)
{
cin >> a[i];
}
unitVector(a, b);
for (int i = 0; i < 5; i++)
cout << b[i] << "\t";
cout << endl;
return 0;
}
提取字符
函数extract(char str[], int s, int e, int n, char res[])
从字符串str中抽取字符形成字符串存入res中。抽取规则为：
在str中从序号s到e(不包括e)的子串中每n个字符取1个字符。
例如，str为”abcdefghijklmnopqrstuvwxyz”
则extract(str,2,18,2,res)被抽取的子串为”cdefghijklmnopqr”，
每2个字符取1个字符，抽取到的字符串为”cegikmoq”，
请按上述规则，完成函数extract的编写。
#include <iostream>
using namespace std;
void extract(char str[], int s, int e, int n, char res[])
{
/**********Program**********/
int cnt = 0;
for (int i = s; i < e; i += n)
{
res[cnt++] = str[i];
}
res[cnt] = '\0';
/********** End **********/
}
int main()
{
int n;
char s[100];
char e[100];
for (int j = 0; j < 50; j++)
{
cin >> n;
s[j] = n % 26 + 'a';
}
s[50] = 0;
extract(s, 2, 40, 3, e);
cout << e << endl;
return 0;
}
行程编码
数据压缩对高效传输和存储大量数据具有重要意义。
行程编码是一种简单有效的压缩算法，它可将连续的重复字符
压缩成“重复次数+字符”的形式，从而减少存储开销。
行程编码解压缩则对应的逆向过程。
例如，“4A2B1C1D2E”压缩后为“AAAABBCDEE”，
“3a1B2C1e2F”压缩后为“aaaBCCeFF”。
函数run_length_decoding的功能是按行程编码算法进行解压缩，
参数src是压缩的字符串，解压后的结果保存在参数dst中
（仅包含字母，长度不超过1000）。请完成函数run_length_decoding。
说明：简化起见，测试用例保证每种字符连续重复次数在1到9之间。
提示：可能用到的字符串函数说明如下，
strlen(char *str)：返回字符串str的长度；
strcpy(char *dest, char *src)：把字符串src复制到dest；
strcat(char *dest, char *src)：把字符串src连接到dest后面；
int atoi(const char *str)：将字符串str转换成对应的整数。
sprintf(char *str, const char *format, …)：发送格式化输出到str所指向的字符串。
#include <iostream>
#include <cstring>
using namespace std;
void run_length_decoding(char* src, char* dst)
{
/**********Program**********/
int index = 0;
for (int i = 0; src[i] != '\0'; i += 2)
{
for (int j = 0; j < src[i] - '0'; j ++)
{
dst[index++] = src[i + 1];
}
}
dst[index] = '\0';
/********** End **********/
}
int main()
{
char s[1000], t[1000];
cin >> s;
run_length_decoding(s, t);
cout << t << endl;
return 0;
}
统计平均分
某班共有若干名学生，学生信息用如下的stuinfo结构表示，
其中，男学生则gender取值为’m’，女学生则gender取值为’f’。
2022年春季学期4门课程的成绩依次保存在score1~score4中。
请编写函数double statistics(stuinfo stus[], int n)
分别统计男生4门课程总分的平均分，以及女生4门课程总分的平均分，
其中stus数组存储了班上所有学生的信息，n为班上学生的总人数。
函数最后返回男生总分平均分减去女生总分平均分的结果（浮点数）。
#include <iostream>
#include<string>
using namespace std;
struct stuinfo {
int id; // 学号
string name; // 姓名
char gender; // 性别
int score1; // 课程1成绩
int score2; // 课程2成绩
int score3; // 课程3成绩
int score4; // 课程4成绩
};
double statistics(stuinfo stus[], int n)
{
/**********Program**********/
double m = 0, f = 0;
int cntm = 0, cntf = 0;
for (int i = 0; i < n; i ++)
{
if (stus[i].gender == 'm')
{
m += stus[i].score1;
m += stus[i].score2;
m += stus[i].score3;
m += stus[i].score4;
cntm ++;
}
else
{
f += stus[i].score1;
f += stus[i].score2;
f += stus[i].score3;
f += stus[i].score4;
cntf ++;
}
}
return m / cntm - f / cntf;
/********** End **********/
}
int main()
{
int n;
stuinfo ptr[11] = {
{104, "Zhang San", 'f', 94, 97, 91, 94},
{105, "Li Si", 'm', 90, 86, 90, 75},
{106, "Wang Wu", 'm', 94, 88, 91, 86},
{107, "Zhzo Liu", 'f', 92, 95, 81, 87},
{108, "Qian, Jiu", 'f', 99, 90, 82, 91},
{109, "Ding Yi", 'm', 98, 86, 80, 94},
{110, "Zhou Er", 'f', 90, 90, 91, 93},
{111, "Chen Ba", 'm', 92, 83, 92, 77},
{112, "Zhu Qi", 'f', 90, 85, 88, 81},
{113, "Wu Shi", 'm', 91, 82, 89, 86},
{114, "Du Du", 'm', 93, 84, 82, 87}
};
cin >> n;
cout << statistics(ptr, n) << endl;
return 0;
}
偶节点
下面有结构node的定义，指针head中存放着node节点组成
的单链表的首节点地址，函数even(head)获取head指向链表
中的序号（注意不是node结构的data字段，且序号从0开始编号）
为偶数的节点，并将这些节点按原有序组成新链表返回。
要求新链表中的节点采用动态内存分配的方式构建，
从而不破坏原链表。如：head指向的链表为：1->2->3->4->5->6，
则even(head)得到的链表为：1->3->5。请完成函数even的编写。
#include <iostream>
using namespace std;
struct node { //链表节点定义
int data;
node* next;
};
node* even(node* h)
{
/**********Program**********/
node * head = NULL;
node * ptr = h;
// head->data = ptr->data;
// head->next = NULL;
// ptr = ptr->next;
bool judge = 0;
while (ptr != NULL)
{
if (judge == 0)
{
node * tmp = new node;
tmp->data = ptr->data;
tmp->next = NULL;
if (head == NULL)
{
head = tmp;
}
else
{
node * tmpptr = head;
node * tmppre = NULL;
while (tmpptr != NULL)
{
tmppre = tmpptr;
tmpptr = tmpptr->next;
}
tmppre->next = tmp;
}
}
judge = !judge;
ptr = ptr->next;
}
return head;
/********** End **********/
}
int main()
{
node* head = NULL, * t;
int n, j;
cin >> n;
n = n % 47;
head = new node;
head->data = n;
t = head;
for (j = 0; j < 20; j++)
{
cin >> n;
n = n % 47;
t->next = new node;
t = t->next;
t->data = n;
}
t->next = NULL;
t = even(head);
while (t)
{
cout << t->data << "->";
t = t->next;
}
cout << endl;
return 0;
}
浙公网安备 33010602011771号