CCF-CSP模拟考笔记

竞赛 / CCF-CSP认证 / 第三题
Word count: 5.5k   |   Reading time≈ 26 min

CCF-CSP模拟考第三题笔记

第三题

202212-3、JPEG 解码

题目：计算机软件能力认证考试系统

分析：

  1. 本问题的关键在于要准确地完成矩阵M的填充，由题目所给信息可知，我们可以提前定义矩阵M，并初始化其为全0；

  2. 在填充矩阵的过程中应该遵循以下规则：

    1. 定义i、j控制填充位置走向；
    2. 左上三角形与右下三角形的填充规则是不同的\textcolor{red}{左上三角形与右下三角形的填充规则是不同的}；
    3. 保证i+j<7的条件下：
      • 当i+j==奇数时，则i++，j–；切换到下一条左斜线时，j不变，i++；
      • 当i+j==偶数时，则i–，j++；切换到下一条左斜线时，i不变，j++；
    4. 保证7=<i+j<15的条件下：
      • 当i+j==奇数时，则i++，j–；切换到下一条左斜线时，i不变，j++；
      • 当i+j==偶数时，则i–，j++；切换到下一条左斜线时，j不变，i++；
    5. 同时注意i、j边界值的处理，什么时候应该切换到下一条左斜线。

    填充顺序

  3. 注意以上思路为解决思路，具体在编程过程中是应该–i还是++i需要根据i、j的实际值进行调整。

注意：

  1. 经过加 128 后并取整指的是四舍五入；这里用round()函数实现，或者用int(x+0.5)实现

  2. 计算最终矩阵时如果得到的整数大于 255，则取 255；如果得到的整数小于 0，则取 0。

AC参考：(105条消息) JPEG解码满分题解 | CSP认证202212-3_吴诗豪的博客-CSDN博客

解决代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/**
*	100分的代码：（第一次写，所以比较冗余）
*/

#include<bits/stdc++.h>
using namespace std;

#define PAI acos(-1)
int Q[8][8];//量化矩阵
int n;//扫描数据的个数
int T;//任务
//int m[n];//n个扫描数据 
double M[8][8];//填充矩阵 
int _M[8][8];

double alpha(int u){
	if(u==0)return sqrt(1.0/2);
	else return 1;
}

//离散余弦逆变换
double convert_matrix(double M[][8],int i,int j){
	double sum=0;
	for(int u=0;u<8;++u){
		for(int v=0;v<8;++v){
			sum+=alpha(u)*alpha(v)*M[u][v]*cos(PAI/8*(i+1.0/2)*u)*cos(PAI/8*(j+1.0/2)*v);
		}
	}
//	cout<<sum/4<<endl;
	return sum/4;
}


int main() {
	for(int i=0;i<8;++i){
		for(int j=0;j<8;++j){
			cin>>Q[i][j];
		}
	}
	cin>>n;
	int m[n];//n个扫描数据 
	cin>>T;
	for(int i=0;i<n;++i){
		cin>>m[i];
	}
	memset(M,0,sizeof(M));//赋值全0 
	int f=1,i=0,j=0;
	bool flag=true;//判断是否结束 填充数据
	M[0][0]=m[0];//填充第一个数据在第一个左斜线上 
	++j;
	//左上三角形填充规则： 
	for(;i+j<7;){//确保范围在8*8矩阵内 
		if((i+j)%2!=0){//在奇数左斜线上时 
			while(j!=-1){//开始从右上到左下填充 
				M[i++][j--]=m[f++];
				if(f>=n){//保证m不越界,同时减少循环次数
					flag=false;
					break;
				}
			}
			//转换到下一条左斜线上 
			--i;//因为前面while中有i++,因此多加了一次 
			++i; 
			j=0;//将j从-1变为从0开始 
		}else{//在偶数左斜线上时 
			while(i!=-1){//开始从左下到右上填充 
				M[i--][j++]=m[f++];
				if(f>=n){
					flag=false;
					break;
				}
			}
			//转换到下一条左斜线上 
			--j;
			++j;
			i=0;
		}
		if(!flag){//结束填充数据
			break;
		}
	}
	if(flag){
		//右上三角形填充规则：
        for(;7<=i+j<15;){//确保范围在8*8矩阵内 
            if((i+j)%2!=0){//在奇数左斜线上时 
                while(i!=8){//开始从右上到左下填充 
                    M[i++][j--]=m[f++];
                    if(f>=n){//保证m不越界,同时减少循环次数
                        flag=false;
                        break;
                    }
                }
                //转换到下一条左斜线上 
                --i;//因为前面while中有i++,因此多加了一次 
                j+=2;//将j拉2个单位回来 
            }else{//在偶数左斜线上时 
                while(j!=8){//开始从左下到右上填充 
                    M[i--][j++]=m[f++];
                    if(f>=n){
                        flag=false;
                        break;
                    }
                }
                //转换到下一条左斜线上 
                --j;//有j++,因此多加了一次 
                i+=2;//将i拉2个单位回来
            }
            if(!flag){//结束填充数据
                break;
            }
        }
	}
	if(T==0){//输出填充矩阵 
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				cout<<M[i][j]<<" ";
			}
			cout<<endl;
		}
	}else if(T==1){//输出量化后的矩阵 
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				M[i][j]=M[i][j]*Q[i][j];
			}
		}
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				cout<<M[i][j]<<" ";
			}
			cout<<endl;
		}
	}else if(T==2){//输出最终解码结果 
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				M[i][j]=M[i][j]*Q[i][j];
			}
		}
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				int res=round(convert_matrix(M,i,j)+128);//四舍五入
				if(res<=0){
					res=0;
				}else if(res>=255){
					res=255;
				}
				_M[i][j]=res;
			}
		}
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				cout<<_M[i][j]<<" ";
			}
			cout<<endl;
		}
	}
//	cout<<convert_matrix(M,0,3)<<" "<<PAI;
	return 0;
}

优化后的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
/**
*	100分的代码：（参考网上的代码对矩阵填充部分的代码进行优化，使其更简洁）
*/
#include<bits/stdc++.h>
using namespace std;

#define PAI acos(-1)
int Q[8][8];//量化矩阵
int n;//扫描数据的个数
int T;//任务
double M[8][8];//填充矩阵 
int _M[8][8];
//针对蛇形填充——定义4个方向 ：右，左下，下，右上(上三角形);(下三角形)需要交换dx[0]与dy[0]以及dx[2]与dy[2] 
int dx[4]={1,-1,0,1},dy[4]={0,1,1,-1};//dx控制列，dy控制行 

double alpha(int u){
	if(u==0)return sqrt(1.0/2);
	else return 1;
}

//离散余弦逆变换
double convert_matrix(double M[][8],int i,int j){
	double sum=0;
	for(int u=0;u<8;++u){
		for(int v=0;v<8;++v){
			sum+=alpha(u)*alpha(v)*M[u][v]*cos(PAI/8*(i+1.0/2)*u)*cos(PAI/8*(j+1.0/2)*v);
		}
	}
	return sum/4;
}


int main() {
	for(int i=0;i<8;++i){
		for(int j=0;j<8;++j){
			cin>>Q[i][j];
		}
	}
	cin>>n;
	cin>>T;
	memset(M,0,sizeof(M));//赋值全0 
	int y=0,x=0,md=0;
	cin>>M[y][x];
	for(int i=1;i<n;++i){//循环直到将所有的数据填充到矩阵中 
		y+=dy[md];
		x+=dx[md];
		cin>>M[y][x];
		if(md==0||md==2)md=(md+1)%4;//每一次在经过向右或向下操作后，需要转换为左下或右上。 
		else if(md==1||md==3){//确保是因下或右上操作
			if(x==0||y==0||x==7||y==7)md=(md+1)%4;//左下或右上达到矩阵边界之后需要进行操作的切换 
		}
		if(y==7&&x==0){//遍历到了右下三角形，需要交换dx[0]与dy[0]以及dx[2]与dy[2]
			swap(dx[0],dy[0]);
			swap(dx[2],dy[2]);
		}
	}
	if(T==0){//输出填充矩阵 
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				cout<<M[i][j]<<" ";
			}
			cout<<endl;
		}
	}else if(T==1){//输出量化后的矩阵 
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				M[i][j]=M[i][j]*Q[i][j];
			}
		}
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				cout<<M[i][j]<<" ";
			}
			cout<<endl;
		}
	}else if(T==2){//输出最终解码结果 
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				M[i][j]=M[i][j]*Q[i][j];
			}
		}
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				int res=round(convert_matrix(M,i,j)+128);//四舍五入
				if(res<=0){
					res=0;
				}else if(res>=255){
					res=255;
				}
				_M[i][j]=res;
			}
		}
		for(int i=0;i<8;++i){
			for(int j=0;j<8;++j){
				cout<<_M[i][j]<<" ";
			}
			cout<<endl;
		}
	}
	return 0;
}

202209-3、防疫大数据

题目：计算机软件能力认证考试系统

分析：

  1. 输入：每一天的所有数据都是一次输入的，而不是分类型进行输入；
  2. 生成风险名单的规则：
    1. 该用户在近 7 日内曾经出现在接收到的漫游数据中，并且近 7 日内有到访某个地区的记录；site[r]&&d1>=d-6&&d1<=d
    2. 该用户在近 7 日内到访的地区在到访的那一日处于风险状态；d1>=region[r].first
    3. 上述存在风险的地区自到访日至生成名单当日持续处于风险状态；region[r].second>=d
  3. 设置区域为风险区域的规则：
    1. 收到该消息的当日起 7 日内，该地区处于风险状态；
    2. 在 1 日收到地区 1 的风险信息，表示自 1 日（包含）至 8 日（不包含）地区 1 处于风险状态。如果分别在 1 日和 6 日收到地区 1 的风险信息，那么意味着地区 1 自 1 日（包含）至 13 日（不包含）持续处于风险状态。
    3. 如果r区域的风险持续时间是[0,6],也就是[0,7)，那么现在d=7时，也是可以延长持续时间的。（d为当前日期）
  4. 输出：按从小到大排序的存在风险的用户列表。

AC参考：(105条消息) 第27次CCF CSP(202209) T3非常详细题解 防疫大数据(C++)_csp 第27次 试题_不择手段也得赢的博客-CSDN博客

解决代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/**
*	20分的代码：（完全参照AC参考的思路和代码写的，不知道什么地方出的错）
*/
#include<bits/stdc++.h>
using namespace std;

int n;//天数——0<=n<=1000
int ri,mi;//当日收到的风险地区信息的数量、当日收到的漫游数据的条目数量 
int rp;//风险地区编号 

struct mes{
	int d,u,r;
}; 
vector<mes>message[1010];//存储漫游消息:vector<mes>message是一个一维数组，那么vector<mes>message[1010]就是一个二维数组 
map<int,bool>site;//判断区域是否为风险区
map<int,pair<int,int>>region;//存储区域的风险持续时间


//设置一个区域为风险区域，是否需要延长风险持续时间
void setf(int r,int d){//r是区域号，d是目前的日期 
	if(!site[r]){//如果不是风险区 
		region[r]={d,d+6};
	}else{//是风险区，是否顺延风险持续时间，或者重置风险持续时间 
		if(region[r].second+1>=d){//如果r区域的风险持续时间是[0,6],也就是[0,7)，那么现在d=7时，也是可以延长持续时间的 
			region[r].second=d+6;
		}else{//风险区的持续时间已经过去，现在重新设置风险持续时间 
			region[r]={d,d+6};
		}
	}
	site[r]=true;//标记为风险区 
} 

//判断是否将用户列入风险名单
bool check(int d1,int u,int r,int d){//<d1,u,r>,d为当前日期 
	if(site[r]&&d1>=d-6&&d1<=d&&d1>=region[r].first&&region[r].second>=d)return true;
	else return false;
} 

int main() {
	cin>>n;
	for(int i=0;i<n;++i){
		cin>>ri>>mi;
		for(int j=1;j<=ri;++j){
			cin>>rp;
			setf(rp,i);//设置风险区持续时间 
		}
		for(int j=1;j<=mi;++j){
			int d,u,r;
			cin>>d>>u>>r;
			if(d<=i)message[i].push_back({d,u,r});
		}
		//计算每天的风险名单
		vector<int>ans;
		for(int day=i-6>0?i-6:0;day<=i;day++){//遍历前6天以及今天得到的漫游数据 
			for(int k=0;k<message[day].size();++k){//遍历第day天的所有漫游消息 
				if(check(message[day][k].d,message[day][k].u,message[day][k].r,day)){
					ans.push_back(message[day][k].u);//添加风险名单 
				} 
			}
		}
		sort(ans.begin(),ans.end());//按照用户编号升序排序 
		ans.erase(unique(ans.begin(),ans.end()),ans.end());//删去去重处理后数组最后面的重复部分 
//		cout<<"风险名单："; 
		cout<<i;//输出第i天的风险名单 
		for(int k=0;k<ans.size();++k)cout<<" "<<ans[k];
		cout<<endl;
	}
	return 0;
}

202206-3、角色授权

题目：计算机软件能力认证考试系统

分析：

  1. 根据题意可知，本题一定需要用到结构体，并且需要用到结构体数组，存储角色、角色关联以及用户；
  2. 判断一个用户能否执行某个操作的过程是：
    1. 检查所有的角色关联的授权对象清单，如果清单中包含该用户的名称，或者该清单中包含该用户所属的某一个用户组的名称，那么选取该角色关联所关联的角色；
    2. 对于所有被选取的角色，判断这些角色是否能对该资源执行该操作，如果所有角色都不能执行该操作，那么不能执行该操作；
    3. 允许执行该操作。
  3. 判断一个角色能否对某个资源执行某个操作的过程是：
    1. 检查该角色的操作清单，如果该角色的操作清单中不包含该操作，且该角色的操作清单中也不包含字符串 *，那么不能执行该操作；
    2. 检查该角色的资源种类清单，如果该角色的资源种类清单中不包含该资源的种类，且该角色的资源种类清单中也不包含字符串 *，那么不能执行该操作；
    3. 检查该角色的资源名称清单，如果该角色的资源名称清单中不包含该资源的名称，且该角色的资源名称清单不是空数组，那么不能执行该操作；
    4. 允许执行该操作。

关键：

  1. 当涉及到大量数据的输入时，需要考虑将C++与C的标准输入输出同步机制关闭，这样能够显著提升效率。ios::sync_with_stdio(false);

    • image-20230318123936083

AC参考：(105条消息) 202206-3 CCF 角色授权 （运用stl容器模拟 + 优化 满分题解）_ccfcsp202206-3_一只可爱的小猴子的博客-CSDN博客

解决代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include<bits/stdc++.h>
using namespace std;

int n,m,q;
int nv,no,nn,ns,ng;

map<string,vector<string>>rolecon;//存储用户绑定有哪些角色
map<string,int>rid;//存储角色名与id的对应关系 

struct role{//角色 
	string name;
	set<string>oper;//set更好查询 
	set<string>res_type; 
	set<string>res_name;
};
role role[510];

//判断对应角色是否能够执行操作
bool check(string rname,string oper,string rs_type,string rs_name){
	int id=rid[rname];
	if(role[id].oper.count("*")==0&&role[id].oper.count(oper)==0)return false;
	if(role[id].res_type.count("*")==0&&role[id].res_type.count(rs_type)==0)return false;
	if(!role[id].res_name.empty()&&role[id].res_name.count(rs_name)==0)return false;
	return true;
}


//role初始化 
void init_role(int n){
	for(int i=0;i<n;++i){
		cin>>role[i].name;
		rid[role[i].name]=i;//存储对应下标id 
		cin>>nv;
		for(int j=0;j<nv;++j){
			string temp;
			cin>>temp;
			role[i].oper.emplace(temp);
		}
		cin>>no;
		for(int j=0;j<no;++j){
			string temp;
			cin>>temp;
			role[i].res_type.emplace(temp);
		}
		cin>>nn;
		for(int j=0;j<nn;++j){
			string temp;
			cin>>temp;
			role[i].res_name.emplace(temp);
		}
	}
}

//每个用户绑定的角色初始化 
void init_role_ass(int m){
	for(int i=0;i<m;++i){
		string rname;
		cin>>rname;
		cin>>ns;
		for(int j=0;j<ns;++j){
			string kind,name;
			cin>>kind>>name;
			rolecon[name].push_back(rname);//存储用户或是用户组包含的角色名称 
		}
	}
}


int main() {
	ios::sync_with_stdio(false);//当涉及到大量数据的输入时，需要考虑将C++与C的标准输入输出同步机制关闭，这样能够显著提升效率 
	cin>>n>>m>>q;
	init_role(n);
	init_role_ass(m);
	while(q--){//处理每一条待授权语句 
		string uname;
		cin>>uname>>ng;
		vector<string>uGroup;
		for(int i=0;i<ng;++i){
			string uG;
			cin>>uG;
			uGroup.push_back(uG);
		}
		string oper,rs_type,rs_name;
		cin>>oper>>rs_type>>rs_name;
		bool flag=false;
		//遍历用户所对应的角色 
		for(int i=0;i<rolecon[uname].size();++i){
			if(check(rolecon[uname][i],oper,rs_type,rs_name)){
				flag=true;
				break;
			}
		}
		if(flag){
			cout<<1<<endl;
			continue;
		}
		//遍历用户组对应的角色 
		for(int i=0;i<uGroup.size();++i){
			string uGname=uGroup[i];
			for(int j=0;j<rolecon[uGname].size();++j){
				if(check(rolecon[uGname][j],oper,rs_type,rs_name)){
					flag=true;
					break;
				}
			}
			if(flag){
				break;
			}
		}
		if(flag)cout<<1<<endl;
		else cout<<0<<endl;
	}
	
//	cout<<"test"<<endl;
	return 0;
}

202203-3、计算资源调度器

分析：

  1. 定义存储应用i运行在哪些计算结点上：unordered_map<int,vector<int>>ap_node；
  2. 定义存储可用区包含哪些计算结点：vector<int>area_node[N]；
  3. 定义存储每个计算结点包含多少个任务数：unordered_map<int,int>node_num；
  4. 定义存储每个节点在哪个区：int n_adr[N]

AC参考：(105条消息) 202203-3 CCF 计算资源调度器 （运用stl容器模拟 满分题解）_一只可爱的小猴子的博客-CSDN博客

解决代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/**
*	20分的代码：（完全参照AC参考的思路和代码写的，不知道什么地方出的错）
*/
#include<bits/stdc++.h>
using namespace std;

const int N=1010,M=1010,G=2010;
int n,m,g; 

int n_adr[N];//存储每个节点在哪个区
vector<int>area_node[N];//存储可用区包含哪些计算结点
unordered_map<int,vector<int>>ap_node;//存储应用i运行在哪些计算结点上
unordered_map<int,int>node_num;//存储每个计算结点包含多少个任务数

bool check_na(int nodeid,int arid){//计算节点亲和性要求
	if(arid==0)return true;
	bool flag=false;
	for(auto x:area_node[arid]){//nodeid计算结点在arid可用区包含的计算结点中
		if(nodeid==x){
			flag=true;
			break;
		}
	}
	return flag;
}

bool check_pa(int nodeid,int apid){//计算任务亲和性要求
	if(apid==0)return true;
	bool flag=false;
	for(auto x:ap_node[apid]){
		if(n_adr[nodeid]==n_adr[x]){//nodeid计算结点所在区与apid应用所在计算结点所属的区域一致即可 
			flag=true;
			break;
		}
	}
	return flag;
}

bool check_paa(int nodeid,int apid){//计算任务反亲和性要求
	if(apid==0)return true;
	bool flag=true;
	for(auto x:ap_node[apid]){
		if(nodeid==x){//nodeid计算结点存在于apid应用所在计算结点
			flag=false;
			break;
		}
	}
	return flag;
}



int main() {
	cin>>n>>m;
	for(int i=1;i<=n;++i){
		int x;
		cin>>x;
		n_adr[i]=x;
		area_node[x].push_back(i);
	}
	cin>>g;
	int f,a,na,pa,paa,paar;
	while(g--){
		cin>>f>>a>>na>>pa>>paa>>paar;
		for(int k=0;k<f;++k){//分配f个任务 
			vector<int>res,t;
			for(int i=1;i<=n;++i){
				if(check_na(i,na)&&check_pa(i,pa)&&check_paa(i,paa))res.push_back(i);//满足三个要求的计算结点
				if(!paar&&check_na(i,na)&&check_pa(i,pa))t.push_back(i);//不考虑任务反亲和性要求
			}
			if(res.size()==0&&!paar) res=t;//paar=0时，可以不用满足全部三个要求
			if(res.size()==0)cout<<0<<" ";//如果必须满足三个要求，但是res为空，表明当前任务无法分配 
			else{//将过滤后满足要求的结点排序输出 
				vector<pair<int,int>>node;
				for(auto x:res){
					node.push_back({node_num[x],x});//存储对应结点的任务数以及对应结点编号 
				}
				sort(node.begin(),node.end());//进行排序
				cout<<node[0].second<<" ";
				++node_num[node[0].second];
				area_node[a].push_back(node[0].second);
			}
		}
		cout<<endl;
	}
	return 0;
}

202112-3、登机牌条码

题目：计算机软件能力认证考试系统

分析：

AC参考：(105条消息) CCF-CSP 202112-3登机牌条码 解题思路+满分题解+详细注释_csp202112-3_只须一笑不须愁X的博客-CSDN博客

解决代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
/**
*	10分的代码：（应该是40的，不知道什么地方出的错；没有考虑校验码）
*/
#include<bits/stdc++.h>
using namespace std;

map<char,int>dict;

int main() {
	ios::sync_with_stdio(false);
	int w,s;
	cin>>w>>s;
	string str;
	cin>>str;
	char ch=65;//+32变小写字母 
	for(int i=0;i<26;++i){
		dict[ch++]=i;
	}
	vector<int>dataCode;
	int flag=1;//初始为大写——大写：1，小写：-1，数字：0 
	for(auto s:str){
		if(isdigit(s)){
			if(flag!=0){
				dataCode.push_back(28);//当前一个字符不是数字时 
				flag=0;
			}
			dataCode.push_back(s-'0');
		}else if(isalpha(s)){
			if(islower(s)){//前一个字符不是小写并且当前字符为小写 
				if(flag!=-1){
					dataCode.push_back(27);//转小写 
					flag=-1;
				}
				s-=32;
			}
			if(isupper(s)){
				if(flag!=1&&flag==-1){//小写转大写 
					dataCode.push_back(28);//先转数字 
					dataCode.push_back(28);//再转大写 
				}else if(flag!=1&&flag==0){
					dataCode.push_back(28);//数字转大写 
				} 
				flag=1;
			}
			dataCode.push_back(dict[s]);
		}
	}
	if(dataCode.size()%2==1){//奇数个需要补29 
		dataCode.push_back(29);
	}
	vector<int>ans;
	for(int k=1;k<dataCode.size();k+=2){
		int cWord=30*dataCode[k-1]+dataCode[k];
		ans.push_back(cWord);//存储两两计算得到的码字 
	}
	if((ans.size()+1)%w!=0){//是否需要在最后的码字中加入900 
		ans.push_back(900);
	}
	//输出
	cout<<ans.size()+1<<endl;
	for(const auto&p:ans){
		cout<<p<<endl;
	} 
	return 0;
}
  • Copyright： Copyright is owned by the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.
  • Copyrights © 2023-2024 Guijie Wang
  • Visitors: | Views:

请我喝杯咖啡吧~

支付宝
微信