C++_第十一周做题总结

id:68 A圆和圆柱体积算（继承）

题目描述

定义一个CPoint点类，包含数据成员x,y（坐标点）。

以CPoint为基类，派生出一个圆形类CCircle，增加数据成员r(半径）和一个计算圆面积的成员函数。

再以CCircle做为直接基类，派生出一个圆柱体类CCylinder，增加数据成员h(高)和一个计算体积的成员函数。

生成圆和圆柱体对象，调用成员函数计算面积或体积并输出结果。

输入

输入圆的圆心位置、半径

输入圆柱体圆心位置、半径、高

输出

输出圆的圆心位置半径

输出圆面积

输出圆柱体的圆心位置半径高

输出圆柱体体积

输入样例

0 0 1
1 1 2 3

输出样例

Circle:(0,0),1
Area:3.14
Cylinder:(1,1),2,3
Volume:37.68

题解

首先看Cpoint类的使用，定义两个私有变量用于存储点的横纵坐标，实现的方法有有参构造
然后定义他的派生类CCircle，定义有私有变量半径，实现的方法有构造和计算圆的面积，注意，在派生类的构造里面要给基类的构造函数提供参数，后面的派生类的定义大同小异
在主函数中，输入有关值，然后使用两个派生类作为数据类型定义两个变量，进行有参构造，然后调用计算函数进行计算输出

代码实现

#include <iostream>
using namespace std;

class Cpoint
{
protected:
    int x, y;
public:
    Cpoint(int x1, int y1); // 构造
};

Cpoint::Cpoint(int x1, int y1) // 构造
{
    x = x1;
    y = y1;
}

class CCircle : public Cpoint
{
protected:
    int r;
public:
    CCircle(int r1, int x1, int y1);
    void calCi(); // 计算圆面积
};

CCircle::CCircle(int r1, int x1, int y1)
    : Cpoint(x1, y1)
{
    r = r1;
    cout << x << "," << y << ")," << r;
}

void CCircle::calCi() // 计算圆面积
{
    double S;
    S = 3.14 * r * r;
    cout << endl << "Area:" << S << endl;
}

class CCylinder : public CCircle
{
private:
    int h;
public:
    CCylinder(int h1, int r1, int x1, int y1);
    void calCy(); // 计算体积
};

CCylinder::CCylinder(int h1, int r1, int x1, int y1)
    : CCircle(r1, x1, y1)
{
    h = h1;
    cout << "," << h << endl;
}

void CCylinder::calCy() // 计算体积
{
    double V, S;
    S = 3.14 * r * r;
    V = S * h;
    cout << "Volume:" << V << endl;
}

int main()
{
    int ix, iy, ir, yx, yy, yr, yh;
    cin >> ix >> iy >> ir; // 圆的圆心位置、半径
    cin >> yx >> yy >> yr >> yh; // 圆柱体圆心位置、半径、高

    cout << "Circle:(";
    CCircle p1(ir, ix, iy); // 圆的构造
    p1.calCi();
    cout << "Cylinder:(";
    CCylinder p2(yh, yr, yx, yy); // 圆柱的构造
    p2.calCy();

    return 0;
}

id:69 B.三维空间的点（继承）

题目描述

定义一个平面上的点C2D类，它含有一个getDistance()的成员函数，计算该点到原点的距离；从C2D类派生出三维空间的点C3D类，它的getDistance()成员函数计算该点到原点的距离。试分别生成一个C2D和C3D的对象，计算它们到原点的距离。
三维空间的两点（x, y, z）和（x1, y1, z1）的距离公式如下：
[(x-x1)^2+(y-y1)2+(z-z1)^2](1/2)

输入

第一行二维坐标点位置

第二行三维坐标点位置1

第三行三维坐标点位置2

输出

第一行二维坐标点位置到原点的距离

第二行三维坐标点位置1到原点的距离

第三行三维坐标点位置2到原点的距离

第四行三维坐标点位置2赋值给二维坐标点变量后，二维坐标点到原点的距离

输入样例

3 4
3 4 5
6 8 8

输出样例

5
7.07107
12.8062
10

题解

首先看C2D类的定义，首先定义两个私有变量用于存储点的横纵坐标，类中实现的方法有构造和计算距离
然后再定义一个派生类C3D，在这个类里面定义一个私有变量表示z轴坐标，类里面实现构造和计算到原点的距离
在主函数中，输入值，然后按照题目要求用不同的类定义变量，然后调用计算距离函数

代码实现

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

class C2D
{
protected:
    int x, y;
public:
    C2D(int x1, int y1); // 构造
    void getDistance(); // 计算该点到原点的距离
};

C2D::C2D(int x1, int y1) // 构造
{
    x = x1;
    y = y1;
}

void C2D::getDistance() // 计算该点到原点的距离
{
    double dis;
    dis = sqrt(x * x + y * y);
    cout << dis << endl;
}

class C3D : public C2D
{
private:
    int z;
public:
    C3D(int x1, int y1, int z1); // 构造
    void getDistance(); // 计算该点到原点的距离
};

C3D::C3D(int x1, int y1, int z1) // 构造
    :C2D(x1, y1)
{
    z = z1;
}

void C3D::getDistance() // 计算该点到原点的距离
{
    double dis;
    dis = sqrt(x * x + y * y + z * z);
    cout << dis << endl;
}

int main()
{
    int x1, y1, x2, y2, z2, x3, y3, z3;
    cin >> x1 >> y1; // 二维
    cin >> x2 >> y2 >> z2 >> x3 >> y3 >> z3; // 三维

    C2D c1(x1, y1);
    c1.getDistance(); // 二维距离输出

    C3D c2(x2, y2, z2);
    c2.getDistance();

    C3D c3(x3, y3, z3);
    c3.getDistance();

    C2D c4(x3, y3);
    c4.getDistance();

    return 0;
}

id:175 C.学生成绩计算（继承）

题目描述

定义Person类具有姓名、年龄等属性，具有输出基本信息的display函数。

选修《面向对象程序设计》课程的学生在Person类的基础上，派生出子类：免听生和非免听生。子类继承父类成员，新增其他成员、改写display函数。

非免听生具有平时成绩、考试成绩和总评成绩三个属性，总评成绩根据（平时成绩40%+考试成绩60%）计算的结果，85分（包含）以上为A，75分（包含）-85分（不包含）为B，65分（包含）-75分（不包含）为C，60分（包含）-65分（不包含）为D，60分（不包含）以下为F。

免听生只有考试成绩和总评成绩两个属性，总评成绩100%根据考试成绩对应上述等级制成绩。

定义上述类并编写主函数，输入类型符号，若输入R，根据学生基本信息、平时成绩和考试成绩，建立非免听生对象，若输入S，根据学生基本信息、考试成绩，建立免听生对象。计算学生的总评成绩，并输出。

输入

测试次数t

随后每行输入学生类型相关信息，姓名的最大字符长度为20

输出

每个学生基本信息和总评成绩

输入样例

2
R cindy 18 100 100
S sandy 28 59

输出样例

cindy 18 A
sandy 28 F

题解

首先看Person类的定义，定义两个私有变量，一个用于存储名字，一个用于存储年龄，在类里面实现构造和输出基本信息
然后定义一个Person类的派生类RPerson表示非免听生，定义两个私有变量一个是平时成绩，一个是期末成绩，在类里面实现构造和计算输出
再定义一个Person类的派生类SPerson类表示免听生，定义一个私有变量，表示期末成绩，在类里面实现构造和计算输出
在主函数中，输入相应的值，然后根据题目要求的类型定义不同类型的变量

代码实现

#include <iostream>
using namespace std;

class Person
{
protected:
    string name;
    int age;
public:
    Person(string n1, int a1);
    void display1(); // 输出基本信息
};

Person::Person(string n1, int a1)
{
    name = n1;
    age = a1;
}

void Person::display1() // 输出基本信息
{
    cout << name << " " << age << " ";
}

class RPerson : public Person
{
private:
    int usual, test;
public:
    RPerson(int u1, int t1, string n1, int a1); // 构造
    void display2(); // 输出
};

RPerson::RPerson(int u1, int t1, string n1, int a1) // 构造
    : Person(n1, a1)
{
    usual = u1;
    test = t1;
}

void RPerson::display2() // 输出
{
    int ans;
    ans = usual * 0.4 + test * 0.6;

    if (ans >= 85)
    {
        cout << 'A' << endl;
    }
    else if (ans >= 75)
    {
        cout << 'B' << endl;
    }
    else if (ans >= 65)
    {
        cout << 'C' << endl;
    }
    else if (ans >= 60)
    {
        cout << 'D' << endl;
    }
    else
    {
        cout << 'F' << endl;
    }
}

class SPerson : public Person
{
private:
    int test;
public:
    SPerson(int t1, string n1, int a1); // 构造
    void display3(); // 输出
};

SPerson::SPerson(int t1, string n1, int a1) // 构造
    : Person(n1, a1)
{
    test = t1;
}

void SPerson::display3() // 输出
{
    int ans;
    ans = test * 0.6;

    if (ans >= 85)
    {
        cout << 'A' << endl;
    }
    else if (ans >= 75)
    {
        cout << 'B' << endl;
    }
    else if (ans >= 65)
    {
        cout << 'C' << endl;
    }
    else if (ans >= 60)
    {
        cout << 'D' << endl;
    }
    else
    {
        cout << 'F' << endl;
    }
}

int main()
{
    int t, i, us, te, age;
    char type;
    string name;
    cin >> t; // 测试次数

    for (i = 0; i < t; i++)
    {
        cin >> type;
        if (type == 'R') // 非免听生
        {
            cin >> name >> age >> us >> te;
            RPerson p1(us, te, name, age);
            p1.display1();
            p1.display2();
        }
        else // 免听生
        {
            cin >> name >> age >> te;
            SPerson p2(te, name, age);
            p2.display1();
            p2.display3();
        }
    }

    return 0;
}

id:73 D.时钟模拟（继承）

题目描述

定义计数器类，包含保护数据成员value,公有函数increment计数加1。

定义循环计算器继承计数器类，增加私有数据成员：最小值minValue，maxValue,

重写公有函数increment，使得value在minValue~maxValue区间内循环+1。

定义时钟类，数据成员是私有循环计数器对象小时hour、分钟minute、秒second，公有函数time(int s)计算当前时间经过s秒之后的时间，即hour，minute，second的新value值。

定义时钟类对象，输入当前时间和经过的秒数,调用time函数计算新时间。

根据题目要求，增加必要的构造函数、析构函数和其他所需函数。

因为clock和time是系统内置函数，为了避免重名，请不要使用clock或者time作为类名或者函数名

输入

第一行测试次数n

2行一组，第一行为当前时间（小时分钟秒），第二行为经过的秒数。

输出

输出n行

每行对应每组当前时间和经过秒数后计算得到的新时间（小时：分钟：秒）。

输入样例

2
8 19 20
20
23 30 0
1801

输出样例

8:19:40
0:0:1

题解

首先看Counter类，类里面定义一个整形的私有变量表示值，实现的功能是让这个值加一，且将Clock类视为友元类
然后定义一个Counter类的派生类Cire，在这个类里面定义两私有变量，最大值和最小值，表示这个变量的最大值和最小值，这个类实现的方法有构造，还有使得value在minValue~maxValue区间内循环加一，即是当value的值大于等于最大值时，value的值变为最小值，因为时分秒没有等于最大值的说法。因为基类的实现里面没有构造函数，所以派生类的构造函数不需要给基类传递参数，即不需要初始化基类的参数
然后额外定义一个Clock类，定义Cire类型的三个私有变量，定义成这个类型是为了能使用这个Cire类里面的函数进行在范围内的value的值的加一操作，这个类的实现有构造和计算当前时间经过s秒之后的时间，构造函数中，因为变量的类型是Cire类型，所以首先要给Cire类的构造函数传递参数，调用Cire的构造函数初始化时分秒的最大值的最小值，然后因为时分秒是Cire类型的，所以其存在成员value，所以也需要对这个value值，即时分秒的大小初始化，即为参数的值
Clock类里面计算函数的过程是，因为调用的increment函数可以使得这个值在范围内加一，所以我们不需要考虑轮回的情况，直接把传入的，所需要加上的秒数作为循环的判断依据，在循环的内部，使用秒的变量调用increment函数首先实现秒的增加，因为秒的增加会影响到分的增加，再影响到时的增加，反之则不会，调用后对这个秒的大小进行判断，如果这个值等于0，则说明这个秒转了一轮，相应的分钟就要加一，加一则是调用分的increment函数进行操作，如果不等于0，则进入循环的下一轮，如果分钟等于0，同理，调用时的increment函数对时的大小进行加一操作，然后进行输出
在主函数中，读取输入进来的数，然后定义一个Clock的对象，进行有参构造，然后调用计算函数计算加秒数之后的时间

遇到的问题

在写计算加秒数后的的时间时，把时分秒进行割裂计算，导致当秒走过一轮后没有对分钟进行加一操作，单纯的把秒数换算成秒，分，时分别要进行多少次加一操作，后面考虑到存在秒数走过一轮后会对分钟产生影响，但是没有懂得从循环内部进行操作，没有思考到当秒数等于0时，即为转过了一轮，反而考虑在循环外部操作，从而导致无从下手，焦头烂额

代码实现

#include <iostream>
using namespace std;
class Clock;

class Counter
{
protected:
    int value;
public:
    void increment(); // 计数加1
    friend Clock;
};

void Counter::increment() // 计数加1
{
    value++;
}

class Cire : public Counter // 继承
{
private:
    int minValue, maxValue;
public:
    Cire(int min1, int max1); // 构造
    void increment(); // 使得value在minValue~maxValue区间内循环+1
};

Cire::Cire(int min1, int max1) // 构造
{
    minValue = min1;
    maxValue = max1;
}

void Cire::increment() // 使得value在minValue~maxValue区间内循环+1
{
    value++;
    if (value >= maxValue)
    {
        value = minValue;
    }
}

class Clock
{
private:
    Cire hour, minute, second;
public:
    Clock(int h1, int m1, int s1);
    void time(int s); // 计算当前时间经过s秒之后的时间
};

Clock::Clock(int h1, int m1, int s1)
    : hour(0, 24), minute(0, 60), second(0, 60)
{
    hour.value = h1;
    minute.value = m1;
    second.value = s1;
}

void Clock::time(int s) // 计算当前时间经过s秒之后的时间
{
    int i;
    for (i = 0; i < s; i++)
    {
        second.increment();
        if (second.value == 0)
        {
            minute.increment();
            if (minute.value == 0)
            {
                hour.increment();
            }
        }
    }
    cout << hour.value << ":" << minute.value << ":";
    cout << second.value << endl;
}

int main()
{
    int n, i, h, m, s, ss;
    cin >> n;

    for (i = 0; i < n; i++)
    {
        cin >> h >> m >> s >> ss;
        Clock c1(h, m, s); // 构造初始化
        c1.time(ss); // 重新计算时间
    }

    return 0;
}

id:74 E.新旧身份证（继承）

题目描述

按下述方式定义一个日期类CDate和描述15位身份证号的旧身份证类COldId:

class CDate
{
private:
	int year, month, day;
public:
	CDate(int, int, int);
	bool check(); //检验日期是否合法
	bool isLeap();
	void print();
};

class COldId
{
protected:
	char* pId15, * pName; //15位身份证号码，姓名
	CDate birthday; //出生日期
public:
	COldId(char* pIdVal, char* pNameVal, CDate& day);
	bool check(); //验证15位身份证是否合法
	void print();
	~COldId();
};

然后以COldId为基类派生18位身份证号的新身份证类CNewId,并增加3个数据成员:pId18(18位号码)、issueDay(签发日期)和validYear(有效期，年数)，并重新定义check()和print()。

15位身份证号扩展为18位身份证号的规则为：前6位号码保持一致，年份由2位变为4位（在前面加上19，例如88变为1988），剩余号码都保持一致，再加上第18位校验码。

身份证第18位校验码的生成方法：

将身份证号码前17位数分别乘以7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2。然后将其相加。
将17位数字与系数乘加的和除以11，得到余数。
余数与校验码的对应关系为1,0,X,9,8,7,6,5,4,3,2。也即：如果余数是3，身份证第18位就是9。如果余数是2，身份证的最后一位号码就是X。

主函数定义一个派生类对象，并用派生类对象调用check()，若返回false则输出“illegal id”否则调用print()输出身份证信息。check()对身份证合法性进行验证的规则：

确认18位号码是从15位号码扩展的，且第18位校验码正确.
身份证中的出生日期合法.
身份证号码中不含非法字符.
身份证号码的长度正确.
身份证目前处于有效期内，假设当前日期为2021年11月9日。
签发日期合法

输入

测试数据的组数 t

第一个人姓名、出生日期年月日、15位身份证号码、18位身份证号码、签发日期年月日、有效期(100年按长期处理)

第二个人姓名、出生日期年月日、15位身份证号码、18位身份证号码、签发日期年月日、有效期(100年按长期处理)

…

姓名的最大字符长度为20

输出

第一个人姓名

第一个人18位身份证号信息(号码、签发日期和有效期）或"illegal id"

第二个人姓名

第二个人18位身份证号信息(号码、签发日期和有效期）或"illegal id"

…

输入样例

10
AAAA 1988 2 28 440301880228113 440301198802281133 2006 1 20 20
BBBB 1997 4 30 440301980808554 440301199808085541 2015 2 2 10
CCCC 1920 5 8 530102200508011 53010219200508011X 1980 3 4 30
DDDD 1980 1 1 340524800101001 340524198001010012 1998 12 11 20
EEEE 1988 11 12 110203881112034 110203198811120340 2007 2 29 20
FFFF 1964 11 15 432831641115081 432831196411150810 2015 8 7 100
GGGG 1996 12 10 44030196121010 44030119961210109 2014 6 7 20
HHHH 1988 7 21 440301880721X12 44030119880721X122 2006 5 11 20
IIII 1976 3 30 440301760330098 440301197603300983 2003 4 15 20
JJJJ 1955 9 5 440301550905205 440301195509051052 2004 6 4 100

输出样例

AAAA
440301198802281133 2006年1月20日 20年
BBBB
illegal id
CCCC
illegal id
DDDD
illegal id
EEEE
illegal id
FFFF
432831196411150810 2015年8月7日长期
GGGG
illegal id
HHHH
illegal id
IIII
illegal id
JJJJ
illegal id

题解

首先看CDate类，类里面定义了三个私有变量，年月日，实现的方法有构造，检验日期是否合法，判断是否是闰年，打印日期，然后把CNewId类视为友元类，在检验日期是否合法的函数中，主要是检验这个日期是否超过当前题目说明的日期，然后判断这个月份是否超过了一月或者十二月，还有这个天数是否在正常的天数内，注意，返回bool类型的函数，即使每一个判断语句都有返回true或者false，函数的最后仍然要返回一个true或者false
然后看COldId类，在类里面定义三个私有变量，15位身份证号码，姓名和出生日期，其中，出生日期是CDate类，实现的方法是构造，验证15位身份证是否合法和析构，在构造里面输出姓名，煮波赌15位身份证一定正确，所以bool COldId::check()函数返回true
再定义一个派生类CNewId，定义三个私有变量，18位号码，签发日期和有效期年数，实现的方法是构造，验证18位身份证是否合法，输出和析构，在构造函数中，因为基类存在构造函数，所以派生类的构造函数需要给基类的构造函数提供参数
在验证18位身份证是否合法的函数中，因为余数与校验码的对应关系中存在字符型，所以我们需要将这个数组定义为char类型，注意，里面的数字也需要用单引号，首先我们需要检验确认18位号码是从15位号码扩展的，所以需要一位位的对比，然后在这个循环里面检验不含非法字符，及全部都是数字，然后顺便计算验证码，注意，18位身份证的类型是字符型，所以要把他们转换为数字，得到校验码后检验是否正确，再检验长度是否正确，检查出生日期合法，检查签发日期合法性，检查身份证是否在有效期内
在主函数中，进行数据输入，然后有参构造，控制输出

遇到的问题

余数与校验码的对应关系中的数组中的数字没有用单引号，计算校验码时，没有把18位身份证转换为数字来进行计算

代码实现

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

class CDate
{
private:
	int year, month, day;
public:
	CDate(int y1, int m1, int d1);
	bool check();  // 检验日期是否合法
	bool isLeap(); // 判断闰年
	void print();
	friend class CNewId;
};

CDate::CDate(int y1, int m1, int d1)
{
	year = y1;
	month = m1;
	day = d1;
}

bool CDate::check() // 检验日期是否合法
{
	// 检查年份是否有效
	if (year > 2021)
	{
		return false;
	}
	else if (year == 2021)
	{
		if (month > 11 || (month == 11 && day > 9))
		{
			return false;
		}
	}

	// 检查月份是否有效
	if (month < 1 || month > 12)
	{
		return false;
	}

	// 检查天数是否有效
	int daysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
	if (isLeap())
	{
		daysInMonth[1] = 29;
	}
	if (day < 1 || day > daysInMonth[month - 1])
	{
		return false;
	}
	return true;
}

bool CDate::isLeap() // 判断闰年
{
	return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

void CDate::print()
{
	cout << year << "年" << month << "月" << day << "日 ";
}

class COldId
{
protected:
	char *pId15, *pName; // 15位身份证号码，姓名
	CDate birthday;		 // 出生日期
public:
	COldId(char *pIdVal, char *pNameVal, CDate &day);
	bool check(); // 验证15位身份证是否合法
	~COldId();
};

COldId::COldId(char *pIdVal, char *pNameVal, CDate &day)
	: birthday(day)
{
	int len;
	pId15 = new char[16];
	strncpy(pId15, pIdVal, 15);
	pId15[15] = '\0';

	len = strlen(pNameVal);
	pName = new char[len + 1];
	strncpy(pName, pNameVal, len);
	pName[len] = '\0';
	cout << pName << endl; // 输出姓名
}

bool COldId::check() // 验证15位身份证是否合法
{
	return true;
}

COldId::~COldId()
{
	delete[] pId15;
	delete[] pName;
}

class CNewId : public COldId
{
private:
	char *pId18;	// 18位号码
	CDate issueDay; // 签发日期
	int validYear;	// 有效期，年数
public:
	CNewId(char *pId18, CDate &iss, int valid, char *pId15, char *name, CDate birth);
	bool check(); // 验证18位身份证是否合法
	void print();
	~CNewId();
};

CNewId::CNewId(char *pId, CDate &iss, int valid, char *pId15, char *name, CDate birth)
	: COldId(pId15, name, birth), issueDay(iss)
{
	pId18 = new char[19];
	strncpy(pId18, pId, 18);
	pId18[18] = '\0';
	validYear = valid;
}

bool CNewId::check() // 验证18位身份证是否合法
{
	int code, i, biryear;
	int a[17] = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
	char b[11] = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'};
	code = 0;

	for (i = 0; i < 17; i++)
	{
		if (i < 6) // 确认18位号码是从15位号码扩展的
		{
			if (pId18[i] != pId15[i])
			{
				return false;
			}
		}
		if (i > 7 && i < 15)
		{
			if (pId18[i] != pId15[i - 2])
			{
				return false;
			}
		}

		if (pId18[i] < '0' || pId18[i] > '9') // 不含非法字符
		{
			return false;
		}
		code += (pId18[i] - '0') * a[i];
	}
	code %= 11;

	if (b[code] != pId18[17]) // 第18位校验码不正确
	{
		return false;
	}

	if (strlen(pId18) != 18) // 长度正确
	{
		return false;
	}

	// 检查出生日期合法
	biryear = (pId18[6] - '0') * 1000 + (pId18[7] - '0') * 100 + (pId18[8] - '0') * 10 + (pId18[9] - '0');
	if (biryear != birthday.year)
	{
		return false;
	}

	if (!issueDay.check()) // 检查签发日期合法性
	{
		return false;
	}

	if (issueDay.year + validYear < 2021) // 检查身份证是否在有效期内
	{
		return false;
	}
	else if (issueDay.year + validYear == 2021)
	{
		if (issueDay.month < 11 || (issueDay.month == 11 && issueDay.day < 9))
		{
			return false;
		}
		}
	return true;
}

void CNewId::print()
{
	cout << pId18 << " ";
	issueDay.print();
	if (validYear != 100)
	{
		cout << validYear << "年" << endl;
	}
	else
	{
		cout << "长期" << endl;
	}
}

CNewId::~CNewId()
{
	delete[] pId18;
}

int main()
{
	int t, i, y1, m1, dd1, y2, m2, dd2, date, result;
	char *name, *num15, *num18;
	name = new char[21];
	num15 = new char[16];
	num18 = new char[19];
	cin >> t;

	for (i = 0; i < t; i++)
	{
		cin >> name >> y1 >> m1 >> dd1 >> num15 >> num18;
		cin >> y2 >> m2 >> dd2 >> date;
		CDate d1(y1, m1, dd1); // 生日
		CDate d2(y2, m2, dd2); // 签发日期
		CNewId id2(num18, d2, date, num15, name, d1);
		result = id2.check();
		if (result == 1)
		{
			id2.print(); // 输出
		}
		else
		{
			cout << "illegal id" << endl;
		}
	}
	delete[] name;
	delete[] num15;
	delete[] num18;

	return 0;
}