A. 日期比较（运算符重载之类型转换）
题目描述
定义一个日期类CDate，包含属性：年、月、日，都是整数。
构造函数含单个参数，参数是八位整数，默认值为0，实现整数转为日期类型，例如参数为20170612，转为year=2017, month=6, day=12
实现转换运算符重载，把日期类型转为整数，例如2017年6月8日转为20170608。注意，如果月或日小于10，转化为整数时要补0
实现日期的输出函数Print，具体格式看示范数据
主函数如下，不能修改，请实现上面的日期类
int main()
{
int t, t1, t2;
CDate C1, C2;
cin>>t;
while (t–)
{cin>>t1>>t2;
C1 = t1;
C2 = t2;
((C1>C2)?C1:C2).Print(); //日期大的输出，在代码C1>C2中，会自动把C1和C2转换为整数进行比较
}
return 0;
}
注意：本题目不需要也不要重载>运算符，只要实现转换运算符重载，能够把日期类型转为整数就可以了
输入
第一行输入t表示有t对日期
接着每两行输入两个日期
输入t对
输出
每行输出一对日期中，日期大的信息
输入样例1
2
20170630
20160528
19981111
20021212
输出样例1
2017年06月30日
2002年12月12日
AC代码
//定义一个日期类CDate，包含属性：年、月、日，都是整数。
//
//构造函数含单个参数，参数是八位整数，默认值为0，实现整数转为日期类型，例如参数为20170612，转为year = 2017, month = 6, day = 12
//
//实现转换运算符重载，把日期类型转为整数，例如2017年6月8日转为20170608。注意，如果月或日小于10，转化为整数时要补0
//
//实现日期的输出函数Print，具体格式看示范数据
//
//主函数如下，不能修改，请实现上面的日期类
#include<bits/stdc++.h>
using namespace std;
class CDate {
int y, m, d;
public:
CDate(int t = 0) {
if (!t) {
y = m = d = 0;
return;
} string temp = to_string(t);
string year = temp.substr(0, 4);
string month = temp.substr(4, 2);
string day = temp.substr(6, 2);
y = stoi(year);
m = stoi(month);
d = stoi(day);
}
operator int() {
return y * 10000 + m * 100 + d;
}
void Print() {
cout << y << "年" << setfill('0') << setw(2) << m << "月" << setfill('0') << setw(2) << d << "日" << endl;
}
//CDate operator >(const CDate& c)const {
// CDate t1 = *this;
// CDate t2 = c;
// cout << t1 << " " << t2 << endl;
// return (int)t1 > (int)t2 ? t1 : t2;
//}
};
int main()
{
int t, t1, t2;
CDate C1, C2;
cin >> t;
while (t--)
{
cin >> t1 >> t2;
C1 = t1;
C2 = t2;
((C1 > C2) ? C1 : C2).Print(); //日期大的输出，在代码C1>C2中，会自动把C1和C2转换为整数进行比较
}
return 0;
}
B. 元素查找（函数模板）
题目描述
编写一个在数组中进行查找的函数模板，其中数组为具有n个元素，类型为T，要查找的元素为key。
注意：必须使用模板函数
输入
第一行输入t表示有t个测试实例
第二行先输入一个大写字母表示数组类型，I表示整数类型，D表示双精度数类型，C表示字符型，S表示字符串型；然后输入n表示数组长度。
第三行输入n个数据
第四行输入key
依次输入t个实例
输出
每行输出一个结果，找到输出key是数组中的第几个元素（从1开始），找不到输出0
输入样例1
4
I 5
5 3 51 27 9
27
D 3
-11.3 25.42 13.2
2.7
C 6
a b g e u q
a
S 4
sandy david eason cindy
cindy
输出样例1
4
0
1
4
AC代码
#include<bits/stdc++.h>
using namespace std;
template<class T>
int Find(vector<T>& v, T key) {
for (int i = 0; i < v.size(); i++)
if (v[i] == key)
return i + 1;
return 0;
}
int main() {
int t;
cin >> t;
while (t--){
char c;int n;
cin >> c >> n;
if (c == 'I') {
vector<int>v(n);
for (auto& i : v)
cin >> i;
int key;
cin >> key;
cout << Find(v,key) << endl;
}
else if (c == 'C') {
vector<char>v(n);
for (auto& i : v)
cin >> i;
char key;
cin >> key;
cout << Find(v, key) << endl;
}
else if (c == 'D') {
vector<double>v(n);
for (auto& i : v)
cin >> i;
double key;
cin >> key;
cout << Find(v, key) << endl;
}
else {
vector<string>v(n);
for (auto& i : v)
cin >> i;
string key;
cin >> key;
cout << Find(v, key) << endl;
}
}
return 0;
}
C. 数据排序（函数模板）
题目描述
编写一个进行升序排序的函数模板，其中数组为具有n个元素，类型为T。
注意：必须使用模板函数
输入
第一行输入t表示有t个测试实例
第二行先输入一个大写字母表示数组类型，I表示整数类型，C表示字符型，S表示字符串型，D表示双精度数类型；然后输入n表示数组长度。
第三行输入n个数据
依次输入t个实例
输出
每行输出一个结果
输入样例1
4
I 10
15 3 51 27 9 35 78 14 65 8
D 3
-11.3 25.42 13.2
C 6
a b g e u q
S 4
sandy david eason cindy
输出样例1
3 8 9 14 15 27 35 51 65 78
-11.3 13.2 25.42
a b e g q u
cindy david eason sandy
AC代码
#include<bits/stdc++.h>
using namespace std;
template<class T>
void bubbleSort(vector<T>& v) {
int n = v.size();
for (int i = 1; i < n; i++)
for (int j = 0; j < n - i; j++)
if (v[j] > v[j + 1])
swap(v[j], v[j + 1]);
}
template<class T>
void print(vector<T>& v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
char c;
int n;
cin >> c >> n;
if (c == 'I') {
vector<int>v(n);
for (auto& i : v)
cin >> i;
bubbleSort(v);
print(v);
}
else if (c == 'C') {
vector<char>v(n);
for (auto& i : v)
cin >> i;
bubbleSort(v);
print(v);
}
else if (c == 'D') {
vector<double>v(n);
for (auto& i : v)
cin >> i;
bubbleSort(v);
print(v);
}
else {
vector<string>v(n);
for (auto& i : v)
cin >> i;
bubbleSort(v);
print(v);
}
}
return 0;
}
D. 谁的票数最高（函数模板）
题目描述
某小镇要票选镇长，得票最高者当选。但由于投票机制不健全，导致每届投票时，候选人在投票系统的识别码类型不一致。请编写函数模板，能针对多种类型的数据，查找出得票最高的元素。其中，每届投票的选票有n张，识别码类型为T
注意：必须使用模板函数
输入
第一行输入t表示有t个测试实例
第二行先输入一个大写字母表示识别码类型，I表示整数类型，C表示字符型，S表示字符串型；然后输入n表示数组长度。
第三行输入n个数据
依次输入t个实例
输出
每行输出一个结果，分别输出当选者的识别码和得票数，以空格分开。
输入样例1
3
I 10
5 3 5 2 9 7 3 7 2 3
C 8
a b a e b e e q
S 5
sandy david eason cindy cindy
输出样例1
3 3
e 3
cindy 2
AC代码
#include<bits/stdc++.h>
using namespace std;
template<class T>
void func(vector<T>&v) {
map<T, int>mapp;
for (auto& ii : v) {
mapp[ii]++;
}
T t = v[0];
for (auto& it : v) {
if (mapp[it] > mapp[t])
t = it;
}
cout << t << " " << mapp[t] << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
char c;
int n;
cin >> c >> n;
if (c == 'I') {
vector<int>v(n);
for (auto& i : v)
cin >> i;
func(v);
}
else if (c == 'C') {
vector<char>v(n);
for (auto& i : v)
cin >> i;
func(v);
}
else if (c == 'D') {
vector<double>v(n);
for (auto& i : v)
cin >> i;
func(v);
}
else {
vector<string>v(n);
for (auto& i : v)
cin >> i;
func(v);
}
}
return 0;
}
E. 矩形关系（运算符重载）
题目描述
假设坐标采用二维平面坐标。
定义点类CPoint，包含属性x,y（整型）。方法有：带参构造函数，getX，getY分别返回点的x坐标，y坐标。
定义矩形类CRectangle，包含属性：矩形的左上角坐标leftPoint，右下角坐标rightPoint。类中方法有：
1）带参构造函数，初始化矩形的左上角、右下角
2）重载>运算符，参数为CPoint点对象，假设为p，若p在矩形内，返回true,否则返回false。
3）重载>运算符，第一个矩形若包含第二个矩形（部分边界可以相等），返回true，否则返回false。（要求该函数调用2）实现）
4）重载==运算符，判断两个矩形是否一致，返回true或false。
5）重载*运算符，判断两个矩形是否有重叠部分，返回true或false。
6）重载类型转换运算符，计算矩形的面积并返回，面积是整型。
7）重载《运算符，输出矩形的两个角坐标和面积，具体格式见样例。
输入2个矩形，计算面积，判断矩形的关系。主函数如下，不可修改。
可根据需要，添加构造函数和析构函数。
输入
测试次数
每组测试数据如下：
矩形1的左上角、右下角坐标
矩形2的左上角、右下角坐标
输出
每组测试数据输出如下，中间以空行分隔：
矩形1的坐标和面积（具体格式见样例）
矩形2的坐标和面积（具体格式见样例）
矩形1和矩形2的关系（矩形1包含矩形2、矩形2包含矩形1、矩形2和矩形1相等、矩形1和矩形2相交、矩形1和矩形2不相交）
输入样例1
2
1 4 4 1
2 3 3 2
1 4 4 1
0 3 5 2
输出样例1
矩形1:1 4 4 1 9
矩形2:2 3 3 2 1
矩形1包含矩形2
矩形1:1 4 4 1 9
矩形2:0 3 5 2 5
矩形1和矩形2相交
AC代码
#include<bits/stdc++.h>
using namespace std;
class CPoint {
int x, y;
public:
CPoint(int x, int y) :
x(x), y(y) {
}
int getX() const { return x; }
int getY() const { return y; }
bool operator == (const CPoint& p)const {
return x == p.getX() && y == p.getY();
}
};
class CRectangle {
CPoint leftPoint, rightPoint;
public:
CRectangle(int x1, int y1, int x2, int y2) :
leftPoint(x1, y1), rightPoint(x2, y2)
{
}
bool operator > (const CPoint& p)const {
return !(p.getX() < leftPoint.getX() || p.getX() > rightPoint.getX() || p.getY() > leftPoint.getY() || p.getY() < rightPoint.getY());
}
bool operator >(const CRectangle& c) const {
return *this > c.leftPoint && *this > c.leftPoint;
}
bool operator ==(const CRectangle& c) const {
return leftPoint == c.leftPoint && rightPoint == c.rightPoint;
}
bool operator * (const CRectangle& c) const {
if (leftPoint.getX() > c.rightPoint.getX())
return false;
if (rightPoint.getX() < c.leftPoint.getX())
return false;
if (leftPoint.getY() < c.rightPoint.getY())
return false;
if (rightPoint.getY() > c.leftPoint.getY())
return false;
return true;
//return *this > c.rightPoint || *this > c.leftPoint || c > leftPoint || c > rightPoint;
}
operator int() {
return-(rightPoint.getX() - leftPoint.getX()) * (rightPoint.getY() - leftPoint.getY());
}
friend ostream& operator << (ostream& output, CRectangle& c) { //定义重载运算符“<<”
output << c.leftPoint.getX() << " " << c.leftPoint.getY() << " " << c.rightPoint.getX() << " " << c.rightPoint.getY();
return output;
}
};
int main() {
int t, x1, x2, y1, y2;
cin >> t;
while (t--)
{
cin >> x1 >> y1 >> x2 >> y2;
CRectangle rect1(x1, y1, x2, y2);
cin >> x1 >> y1 >> x2 >> y2;
CRectangle rect2(x1, y1, x2, y2);
cout << "矩形1:" << rect1 << " " << (int)rect1 << endl;
cout << "矩形2:" << rect2 << " " << (int)rect2 << endl;
if (rect1 == rect2)
cout << "矩形1和矩形2相等" << endl;
else if (rect2 > rect1)
cout << "矩形2包含矩形1" << endl;
else if (rect1 > rect2)
cout << "矩形1包含矩形2" << endl;
else if (rect1 * rect2)
cout << "矩形1和矩形2相交" << endl;
else
cout << "矩形1和矩形2不相交" << endl;
cout << endl;
}
return 0;
}
F. 栈的赋值（运算符重载）
题目描述
定义一个栈类Stack，实现栈与栈之间的相互赋值。成员top表示栈顶指针，max表示栈的最大长度，inflate函数表示栈中存放的数据超过栈的最大长度时，扩大栈的长度，保证能继续插入数据。
Stack类的基本形式如下：
要求如下：
1.实现Stack类；
2.push()函数能一直插入数据，当超过栈的最大长度时，调用inflate函数扩大栈的最大长度。
3.初始化2个Stack对象，对第二个对象执行一次pop操作后，交换这2个对象，并输出栈中的内容。
输入
第一行输入2个栈的大小。
第二行输入第一个栈的元素。
第三行输入第二个栈的元素。
输出
输出第二个对象pop操作，2个对象交换之后，每个对象的元素。
输入样例1
3 4
1 2 3
4 5 6 7
输出样例1
456
123
提示
34
12
AC代码
#include<bits/stdc++.h>
using namespace std;
class Stack {
int* sp, top, max;
void inflate(int lenth) {
int* s = new int[lenth];
for (int i = 0; i < max; i++)
s[i] = sp[i];
delete[]sp;
sp = s;
}
public:
Stack(int size = 10) {
top = 0;
max = size;
sp = new int[size];
}
Stack(const Stack& s) {
sp = new int[s.max];
top = s.top;
max = s.max;
for (int i = 0; i < top; i++) {
sp[i] = s.sp[i];
}
}
int pop() {
if (top == 0)
return -1;
top--;
return sp[top];
}
void push(int value) {
if (max == top) {
inflate(max * 2);
max *= 2;
}
sp[top++] = value;
}
Stack& operator=(Stack& rightValue) {
delete[]sp;
sp = new int[rightValue.max];
for (int i = 0; i < top; i++)
sp[i] = rightValue.sp[i];
max = rightValue.max;
top = rightValue.top;
return *this;
}
void show() {
for (int i = 0; i < top; i++)
cout << sp[i];
cout << endl;
}
};
int main() {
int n, m;
cin >> n >> m;
Stack s1(n), s2(m);
for (int i = 0; i < n; i++) {
int t;
cin >> t;
s1.push(t);
}
for (int i = 0; i < m; i++) {
int t;
cin >> t;
s2.push(t);
}
s2.pop();
//s1 : 1 2 3
//s2: 4 5 6
//swap(s1, s2);
Stack t = s1;
s1 = s2;
s2 = t;
s1.show();
s2.show();
return 0;
}
G. 集合（运算符重载）
题目描述
集合是由一个或多个确定的元素所构成的整体。集合的运算有并、交、相对补等。
集合A和集合B的交集：由属于A且属于B的相同元素组成的集合。
集合A和集合B的并集：由所有属于集合A或属于集合B的元素所组成的集合。
集合B关于集合A的相对补集，记做A-B：由属于A而不属于B的元素组成的集合。
假设集合A={10，20，30}，集合B={1，10，50，8}。则A与B的并是{10，20，30,1,50,8}，A与B的交是{10}，B关于A的相对补集是{20,30}。
定义整数集合类CSet，属性包括：集合中的元素个数n，整型指针data存储集合中的元素。
方法有：重载输出，按样例格式输出集合中的元素。
重载+运算符，求集合A和集合B的并集，并返回结果集合。
重载-运算符，求集合B关于集合A的相对补集，并返回结果集合。
重载*运算符，求集合A和集合B的交集，并返回结果集合。
主函数输入集合A、B的数据，计算集合的并、交、相对补。
可根据题目，为CSet类添加需要的成员函数。
输入
测试次数
每组测试数据两行，格式如下：
第一行：集合A的元素个数和元素
第二行：集合B的元素个数和元素
输出
每组测试数据输出如下：
第一行：集合A
第二行：集合B
第三行：A和B的并
第四行：A和B的交
第五行：B关于A的相对补集 与 A关于B的相对补集的并，即(A-B)+(B-A)
每组测试数据间以空行分隔。
输入样例1
2
3 10 20 30
4 10 1 2 3
5 100 2 3 4 -10
6 -34 12 2 4 90 100
输出样例1
A:10 20 30
B:10 1 2 3
A+B:10 20 30 1 2 3
A*B:10
(A-B)+(B-A):20 30 1 2 3
A:100 2 3 4 -10
B:-34 12 2 4 90 100
A+B:100 2 3 4 -10 -34 12 90
A*B:100 2 4
(A-B)+(B-A):3 -10 -34 12 90
AC代码
#include<bits/stdc++.h>
using namespace std;
class CSet {
int* data;
int n;
bool check(int value)const {
for (int i = 0; i < n; i++) {
if (value == data[i])
return true;
}
return false;
}
void push_back(int value) {
data[n++] = value;
}
public:
CSet() {
cin >> n;
data = new int[n];
for (int i = 0; i < n; i++)
cin >> data[i];
}
CSet(int n1) { n = 0; data = new int[n1]; }
CSet(const CSet& s) {
n = s.n;
data = new int[n];
for (int i = 0; i < n; i++)
data[i] = s.data[i];
}
CSet operator + (const CSet& s) const {
CSet c(n + s.n);
for (int i = 0; i < n; i++)
if (!c.check(data[i]))
c.push_back(data[i]);
for (int i = 0; i < s.n; i++)
if (!c.check(s.data[i]))
c.push_back(s.data[i]);
return c;
}
CSet operator - (const CSet& s) const {
CSet c(n);
for (int i = 0; i < n; i++)
if (s.check(data[i]))
continue;
else if (!c.check(data[i]))
c.push_back(data[i]);
return c;
}
CSet operator * (const CSet& s) const {
CSet c(n);
for (int i = 0; i < n; i++)
if (!s.check(data[i]))
continue;
else if (!c.check(data[i]))
c.push_back(data[i]);
return c;
}
void print() {
for (int i = 0; i < n; i++)
{
if (i)cout << " ";
cout << data[i];
}
cout << endl;
}
~CSet()
{
delete[]data;
}
};
int main() {
int t;
cin >> t;
while (t--) {
CSet s1, s2;
cout << "A:"; s1.print();
cout << "B:"; s2.print();
cout << "A+B:"; (s1 + s2).print();
cout << "A*B:"; (s1 * s2).print();
cout << "(A-B)+(B-A):"; ((s1 - s2) + (s2 - s1)).print();
cout << endl;
}
return 0;
}
