A. 机器人变身（类与对象）【期中模拟】
题目描述
编写一个机器人类，包含属性有机器名、血量、伤害值、防御值、类型和等级。其中血量、伤害和防御和等级、类型相关：
普通型机器人，类型为N，血量、伤害、防御是等级的5倍
攻击型机器人，类型为A，攻击是等级的10倍，其他属性和普通的一样
防御型机器人，类型为D，防御是等级的10倍，其他属性和普通的一样
生命型机器人，类型为H，生命是等级的50倍，其他属性和普通的一样。
机器人操作包括：打印、各个属性的获取和设置方法，构造函数可有可无，根据需要自行编写，
编写一个全局函数用于机器人变身，使得各种类型机器人能够相互转变。参数包括机器人对象指针和变身后的机器人类型，功能是修改机器人类型，并更改相关的属性。如果变身类型和机器人原来的类型不同，则执行变身功能，并返回true；如果变身类型和原来类型相同，则不执行变身，并返回false.
要求所有数据成员都是私有属性，用C++语言和面向对象设计思想来编程实现上述要求
输入
第一行输入t，表示要执行t次机器人变身
接着每两行，一行输入一个机器人的属性，包括机器名、类型、等级，另一行输入变身类型
依次类推输入
输出
每行输出变身后的机器人信息，要求调用机器人的打印方法来输出，即使机器人不变身也输出
属性输出依次为：名称、类型、等级、血量、伤害、防御
最后一行输出执行变身的次数
输入样例1
3
X001 N 5
H
X002 A 5
D
X003 D 5
D
输出样例1
X001–H–5–250–25–25
X002–D–5–25–25–50
X003–D–5–25–25–50
The number of robot transform is 2
AC代码
#include<iostream>
using namespace std;
class Robot {
char type;
string name;
int dengji, xueliang, shanghai, fangyu;
static int cnt;
public:
Robot() {
cin >> name >> type >> dengji;
f();
}
//生成其他信息
void f() {
xueliang = shanghai = fangyu = dengji * 5;
if (type == 'A')
shanghai = dengji * 10;
else if (type == 'D')
fangyu = dengji * 10;
else if (type == 'H')
xueliang = dengji * 50;
}
void print() {
cout << name << "--" << type << "--" << dengji << "--" << xueliang << "--" << shanghai << "--" << fangyu << endl;
}
char getType() {
return type; }
string getName() {
return name; }
int getDengji() {
return dengji; }
int getXueliang() {
return xueliang; }
int getShanghai() {
return shanghai; }
int getFangyu() {
return fangyu; }
void setType(char c) {
type = c;
}
void setName(string name) {
this->name = name; }
void setDengji(int v) {
dengji = v; }
void setXueliang(int v) {
xueliang = v; }
void setShanghai(int v) {
shanghai = v; }
void setFangyu(int v) {
fangyu = v; }
static void print1() {
cout << "The number of robot transform is " << cnt << endl;
}
void add() {
cnt++; }
};
int Robot::cnt = 0;
bool trans(Robot* p, char desType) {
if (p->getType() == desType)
return false;
p->setType(desType);
p->f();
p->add();
return true;
}
int main() {
int n;
cin >> n;
while (n--)
{
Robot r;
char c;
cin >> c;
trans(&r, c);
r.print();
}
Robot::print1();
return 0;
}
B. 虚拟电话（构造与析构）【期中模拟】
题目描述
虚拟电话包含属性：电话号、状态、机主姓名。
1、电话号是一个类，它包含号码和类型，其中号码是整数类型，类型用单个字母表示用户类别，A表示政府，B表示企业、C表示个人。类操作包括构造、属性的获取和设置等方法，根据需要自行编写。
2、状态用一个数字表示，1表示在用，0表示未用，
3、机主姓名是一个字符串
电话操作包括：构造、析构、打印和查询。
1、构造函数需要考虑复合类成员的构造，并且输出提示信息。假设电话号码为12345678，则构造函数输出"12345678 constructed."
2、打印是输出电话的相关信息，其中如果电话状态是在用则输出use；状态是未用则输出unuse，输出格式看示例。
3、析构函数是输出提示信息。假设电话号为12345678，则析构函数输出"12345678 destructed. "
4、查询操作是根据给定的号码查询电话，如果电话自身号码和给定号码不相同，则返回0；如果电话自身号码和给定号码相同，则返回1
用C++和面向对象思想实现以下要求：
1、输入相关数据，创建三个电话对象，并通过构造方法初始化。
2、输入若干个电话号码，通过查询操作查询这些号码是否在三个电话对象中，如果不存在输出"wrong number."，存在则调用打印操作输出电话信息，具体看输出样例。
输入
头三行输入三个电话信息，每行包括电话号码、电话类型、状态、机主姓名
接着一行输入t，表示有t个号码要查询
接着t行输入t个电话号码
输出
t行输出t个号码的查询结果
输入样例1
80000001 A 1 tom
80000002 B 0 ken
80000003 C 1 mary
3
50000002
80000003
80000002
输出样例1
80000001 constructed.
80000002 constructed.
80000003 constructed.
wrong number.
Phone=80000003–Type=C–State=use–Owner=mary
Phone=80000002–Type=B–State=unuse–Owner=ken
80000003 destructed.
80000002 destructed.
80000001 destructed.
AC代码
#include<iostream>
#include<vector>
using namespace std;
class ID {
int id;
char type;
public:
ID(int i, char t) :id(i), type(t) {
}
ID() {
}
void setType(char c) {
type = c;
}
void setID(int i) {
id = i;
}
char getType() {
return type; }
int getId() {
return id;
}
};
class Phone {
ID _id;
int state;
string name;
public:
Phone() {
int id;
char c;
cin >> id >> c >> state >> name;
_id.setID(id);
_id.setType(c);
cout << _id.getId() << " constructed." << endl;
}
bool find(int num) {
return num == _id.getId();
}
~Phone()
{
cout << _id.getId() << " destructed." << endl;
}
void print() {
cout << "Phone=" << _id.getId() << "--Type=";
cout << _id.getType() << "--State=";
if (state == 0)
cout << "unuse";
else
cout << "use";
cout << "--Owner=" << name << endl;
}
};
int main() {
Phone* v = new Phone[3];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int id;
cin >> id;
bool f = 0;
for (int j = 0; j < 3; j++) {
if (v[j].find(id)) {
v[j].print();
f = 1;
break;
}
}
if (!f)
cout << "wrong number." << endl;
}
delete[]v;
return 0;
}
C. 银行账户（拷贝构造）【期中模拟】
题目描述
银行账户包括余额、利率、号码、类型等属性，其中号是固定8位整数，类型表示个人还是企业账户，如果是个人用P标识，企业用E标识。
账户又分为活期账户和定期账户，活期利率为0.5%，定期利率为1.5%。
账户操作有计息、查询操作。计息操作是根据利率计算利息，并把利息增加到余额中，并做相关信息输出。查询操作是输出账户的全部信息。
创建一个活期账户，并通过构造函数初始化各个属性。然后通过拷贝构造来创建一个定期账户，信息与活期账户基本相同，不同之处包括：定期账户号码是活期账户号码加50000000（7个0）；利率是定期利率。
要求所有数据成员都是私有属性
用C++语言的类与对象思想来编写程序实现上述要求
输入
输入测试个数t，表示有t个活期账户
先输入一个活期账户的账户号码、账户类型、余额（根据输入创建活期账户和定期账户）
接着输入两个操作符，第一个操作符对活期账户操作，第二个操作符对定期账户进行操作。若输入大写字母C表示计息操作，若输入大写字母P表示查询操作
以此类推输入其他账户的信息和操作
输出
每两行输出一对活期账户和定期账户的操作结果。
输入样例1
2
12345678 P 10000
C P
23456789 E 20000
P C
输出样例1
Account=12345678–sum=10050
Account=62345678–Person–sum=10000–rate=0.015
Account=23456789–Enterprise–sum=20000–rate=0.005
Account=73456789–sum=20300
AC代码
#include<iostream>
#include<vector>
using namespace std;
class Account {
double balance;
double rate;
int id;
char type;
public:
Account() {
cin >> id >> type >> balance;
rate = 0.005;
}
Account(const Account& a) {
balance = a.balance;
rate = 0.015;
id = a.id + 50000000;
type = a.type;
}
void print() {
}
void C() {
balance *= (1.0 + rate);
cout << "Account=" << id << "--";
cout << "sum=" << balance << endl;
}
void P() {
cout << "Account=" << id << "--";
if (type == 'P')
cout << "Person--";
else
cout << "Enterprise--";
cout << "sum=" << balance << "--";
cout << "rate=" << rate << endl;
}
};
int main() {
int n;
cin >> n;
while (n--)
{
Account a;
Account b(a);
char c1, c2;
cin >> c1 >> c2;
if (c1 == 'C')
a.C();
else
a.P();
if (c2 == 'P')
b.P();
else
b.C();
}
return 0;
}
D. 生日打折（复合类构造）
题目描述
定义一个日期类Date，包含数据成员year\month\day，还包含构造函数及其他函数(根据需要自己添加)
定义一个会员类VIP，包含数据成员id和birth，其中id是整数表示会员编号；birth是Date类型表示生日。
类VIP包含构造函数和其他函数（根据需要自己添加），还包含一个折扣函数Discount。函数Discount返回结果为浮点数表示折扣，函数包含1个参数为日期类型，函数功能是判断参数日期是否会员生日，是则折扣为0.5，不是则折扣为0.95
编写程序实现上述类功能并实现输入输出的要求
输入
第一行输入年、月、日，表示今天日期
第二行输入t表示有t个会员
第三行输入第1个会员的ID、生日的年、月、日
第四行输入第1个会员的消费金额
依次类推输入下一个会员的两行数据…
输出
根据会员的消费金额，调用Discount函数判断今天是否会员生日并得到折扣，然后计算会员打完折的消费金额
每一行先输出会员编号，再输出会员打完折的消费金额，消费金额只需要输出整数部分
提示把浮点数转整数
double x = 123.456
cout<<int(x)<<endl;
输入样例1
2017 4 20
2
1111 2000 4 20
136
2222 2000 3 30
125
输出样例1
1111’s consumption is 68
2222’s consumption is 118
AC代码
#include<iostream>
using namespace std;
class Date {
int y, m, d;
public:
Date() {
cin >> y >> m >> d; }
Date(int y, int m, int d) :
y(y), m(m), d(d)
{
}
bool operator ==(const Date& date)const {
return m == date.m && d == date.d;
}
};
class VIP {
int id;
Date birth;
public:
VIP(int id, Date b) :
id(id),
birth(b) {
}
double Discount(const Date& today) {
if (today == birth)
return 0.5;
return 0.95;
}
void print(double money, const Date& today) {
cout << id << "'s consumption is " << (int)(money * Discount(today)) << endl;
}
};
int main() {
Date today;
int n;
cin >> n;
while (n--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
VIP v(a, Date(b, c, d));
double money;
cin >> money;
v.print(money, today);
}
return 0;
}
E. 电视遥控（静态+友元）【期中模拟】
题目描述
电视机包含音量、模式、频道号等属性，其中模式分为TV和DVD两种。电视机在TV模式下，将播放相应频道的内容；在DVD模式下，电视机使用统一的频道号播放DVD的内容，频道号统一为99。另外，电视机采用静态成员的方法共享两个数据：播放电视的电视机数量和播放DVD的电视机数量，初始都为0。
电视机操作包括打印、相关静态函数、属性的获取和设置等，根据需要自行编写。
现编写一个遥控器函数，通过友元方法对电视机进行控制，它的参数包括电视机对象、模式、变化音量、频道号，无返回值。函数操作包括：
1、对电视机对象进行模式设置，如果设置为DVD模式，则频道号参数一定是99；如果设置TV模式，则要把频道号设置相应的值。
2、根据变化音量进行调整，例如原有音量为50，现输入变化音量为-30，则50-30=20，音量最终为20。音量值最低为0，最高为100，超过范围则音量不再变化。
3、更新当前播放电视和播放DVD的电视机数量
4、调用电视机对象的打印方法输出电视相关信息
提示：如果电视机原来模式和参数传递的模式是相同的，那么实际操作就是调整音量、切换频道和输出信息。
注意：函数第一个参数必须是一个电视机对象，不可以是整数类型，可以是对象、或对象指针、或对象引用，根据需要自行编写。
用动态数组方法创建n台电视机，从1开始编号，频道号为编号，音量初始为50，模式为TV，然后通过遥控器函数对电视机进行控制。
所有类的数据成员都是私有属性。请使用C++语言和面向对象思想来实现上述要求
输入
第一行输入n，表示有n台电视台
第二行输入t，表示将执行t次遥控操作
接着输入t行，每行依次输入电视机编号i、模式k、频道号x和变化音量，其中i表示第i台电视机，k为1表示TV模式，k为2表示DVD模式。
输出
每行输出执行遥控操作后的电视机信息
最后一行输出当前播放电视和播放DVD的电视机数量。
具体格式看样例
输入样例1
10
5
3 1 11 20
4 2 99 -20
5 2 99 80
5 1 55 -60
6 2 99 -70
输出样例1
第3号电视机–TV模式–频道11–音量70
第4号电视机–DVD模式–频道99–音量30
第5号电视机–DVD模式–频道99–音量100
第5号电视机–TV模式–频道55–音量40
第6号电视机–DVD模式–频道99–音量0
播放电视的电视机数量为8
播放DVD的电视机数量为2
AC代码
#include<iostream>
using namespace std;
class Tel {
static int cntTV, cntDVD;
int yinliang, pindao;
int moshi;
public:
Tel() {
moshi = 1;
cntTV++;
pindao = 0;
yinliang = 50;
}
void changeYin(int v) {
yinliang += v;
if (yinliang > 100)
yinliang = 100;
else if (yinliang < 0)
yinliang = 0;
}
void print1() {
if (moshi == 1)
cout << "TV模式--";
else if (moshi == 2)
cout << "DVD模式--";
cout << "频道" << pindao << "--";
cout << "音量" << yinliang << endl;
}
static void print() {
cout << "播放电视的电视机数量为" << cntTV << endl;
cout << "播放DVD的电视机数量为" << cntDVD << endl;
}
//2 DVD
//1 TV
friend void yaokongqi(Tel* p, int moshi, int pindao, int bianyin) {
if (p->moshi != moshi) {
if (p->moshi == 1)
p->cntTV--;
else if (p->moshi == 2)
p->cntDVD--;
p->moshi = moshi;
if (p->moshi == 1)
p->cntTV++;
else
p->cntDVD++;
}
p->pindao = pindao;
p->changeYin(bianyin);
p->print1();
}
};
int Tel::cntTV = 0;
int Tel::cntDVD = 0;
int main() {
int n, t;
cin >> n >> t;
Tel* p = new Tel[n];
while (t--)
{
int i, k, x, delta;
cin >> i >> k >> x >> delta;
cout << "第" << i << "号电视机--";
i--;
yaokongqi(p + i, k, x, delta);
}
Tel::print();
return 0;
}
F. 链表的冒泡排序（结构体+链表）
题目描述
根据输入，采用尾插法创建链表。对创建的链表使用冒泡排序进行降序排序，输出排序后的链表。
说明：程序中不可见数组、容器，否则计0分。
输入
测试次数t
每组测试数据格式为：
数据个数n
n行，每行一个字符串
输出
对每组测试数据，输出字符串按字典降序排序后的链表。各组输出间以空行分隔。
输入样例1
2
4
shenzhen
nanjing
beijing
wuhan
6
china
brazil
germany
philippines
switzerland
singapore
输出样例1
wuhan
shenzhen
nanjing
beijing
switzerland
singapore
philippines
germany
china
brazil
AC代码
#include<iostream>
using namespace std;
struct Node {
string v;
Node* next;
Node(string v = "", Node* next = NULL) {
this->v = v;
this->next = next;
}
};
class List {
Node* head;
int len;
public:
List() {
head = new Node();
cin >> len;
Node* p = head;
for (int i = 0; i < len; i++) {
string s;
cin >> s;
p->next = new Node(s);
p = p->next;
}
}
void print() {
Node* p = head->next;
while (p) {
cout << p->v << endl;
p = p->next;
}
cout << endl;
}
//交换p之后的两个节点
void swap(Node* p) {
Node* p1 = p->next;
Node* p2 = p1->next;
p->next = p2;
Node* q = p2->next;
p2->next = p1;
p1->next = q;
}
//找到第index个节点的前一个
Node* findNode(int index) {
Node* p = head;
while (index--)
p = p->next;
return p;
}
void BubbleSort() {
for (int i = 1; i < len; i++) {
bool flag = 0;
Node* prior;
int j;
for (j = 0, prior = head; j < len - i; j++, prior = prior->next)
{
if (prior->next->v < prior->next->next->v) {
swap(prior);
flag = 1;
}
}
if (!flag)
break;
}
}
~List() {
while (head) {
Node* p = head->next;
delete head;
head = p;
}
}
};
int main() {
int t;
cin >> t;
while (t--) {
List l;
l.BubbleSort();
l.print();
}
return 0;
}