This article is mainly to prepare for students who attend the Zhejiang university PAT basic level test to provide some help, and it is also an article to provide all the answers to the question bank, this article has some code quoted from zhihu, CSDN excellencer’s answer, if there is infringement, private chat.
Catalogue
一.
** 1.正则表达式——B1024
-
利用C++STL库中的prev_permutation和next_permutation来求全排列
-
贪心算法（简单贪心和区间贪心）——B1023/B1020
-
PAT常用的一些函数
##求素数
##进制转换
##二分法
##最大公约数
##最小公倍数
##分数的四则运算
##质因子分解
5. STL之stack–后进先出在PAT中的应用 ——————B1009
6. . 小白易错点 ##用char进行加减乘除的细节*** **
7. PAT不同考场提供的编译器信息-----转载知乎Abner**** **
二、.answer for B1001~B1095*
1001 害死人不偿命的(3n+1)猜想
1002 写出这个数
1003 我要通过！
1004 成绩排名
1005 继续(3n+1)猜想
1006 换个格式输出整数
1007 素数对猜想
1008 数组元素循环右移问题
1009 说反话
1010 一元多项式求导
1011 A+B 和 C
1012 数字分类
1013 数素数
1014 福尔摩斯的约会
1015 德才论
1016 部分A+B
1017 A除以B
1018 锤子剪刀布
1019 数字黑洞
1020 月饼
1021 个位数统计
1022 D进制的A+B
1023 组个最小数
1024 科学计数法
1025 反转链表
1026 程序运行时间
1027 打印沙漏
1028 人口普查
1029 旧键盘
1030 完美数列
1031 查验身份证
1032 挖掘机技术哪家强
1033 旧键盘打字
1034 有理数四则运算
1035 插入与归并
1036 跟奥巴马一起编程
1037 在霍格沃茨找零钱
1038 统计同成绩学生
1039 到底买不买
1040 有几个PAT
1041 考试座位号
1042 字符统计
1043 输出PATest
1044 火星数字
1045 快速排序
1046 划拳
1047 编程团体赛
1048 数字加密
1049 数列的片段和
1050 螺旋矩阵
1051 复数乘法
1052 卖个萌
1053 住房空置率
1054 求平均值
1055 集体照
1056 组合数的和
1057 数零壹
1058 选择题
1059 C语言竞赛
1060 爱丁顿数
1061 判断题
1062 最简分数
1063 计算谱半径
1064 朋友数
1065 单身狗
1066 图像过滤
1067 试密码
1068 万绿丛中一点红
1069 微博转发抽奖
1070 结绳
1071 小赌怡情
1072 开学寄语
1073 多选题常见计分法
1074 宇宙无敌加法器
1075 链表元素分类
1076 Wifi密码
1077 互评成绩计算
1078 字符串压缩与解压
1079 延迟的回文数
1080 MOOC期终成绩
1081 检查密码
1082 射击比赛
1083 是否存在相等的差
1084 外观数列
1085 PAT单位排行
1086 就不告诉你
1087 有多少不同的值
1088 三人行
1089 狼人杀-简单版
1090 危险品装箱
1091 N-自守数
1092 最好吃的月饼
1093 字符串A+B
1094 谷歌的招聘
1095 解码PAT准考证*
一.
1.正则表达式
正则表达式与C++STL库中的map一起用可以基本解决字符串匹配的问题，在GItHub上有一个教正则表达式的大佬，还有一个在线测试的系统—Online regex expression----MIT @ziishaned
链接：https://github.com/ziishaned/learn-regex -----Github
界面大概就是这样子：emmmmmmmmm
tip：一下是我对各个知识点的测试，原文来自上面的GitHub的链接，有多个语言版本
B1024这道有点和正则表达式挂钩，就pose出来emmmmmmmmm
1024 科学计数法 (20 分)
科学计数法是科学家用来表示很大或很小的数字的一种方便的方法，其满足正则表达式
[±][1-9].[0-9]+E[±][0-9]+，即数字的整数部分只有 1 位，小数部分至少有 1
位，该数字及其指数部分的正负号即使对正数也必定明确给出。现以科学计数法的格式给出实数 A，请编写程序按普通数字表示法输出 A，并保证所有有效位都被保留。 输入格式：
每个输入包含 1 个测试用例，即一个以科学计数法表示的实数 A。该数字的存储长度不超过 9999 字节，且其指数的绝对值不超过 9999。
输出格式：对每个测试用例，在一行中按普通数字表示法输出 A，并保证所有有效位都被保留，包括末尾的 0。 输入样例 1：
+1.23400E-03
输出样例 1：
0.00123400
输入样例 2：
-1.2E+10
输出样例 2：
-12000000000
#include<iostream>
using namespace std;
int main()
{
string s;
cin >> s;
int i = 0;
while( s[i] != 'E' ) i++;//定位E
string t = s.substr(1, i-1);//t保存E之前的字符串（不包含符号）
int n = stoi(s.substr(i+1));//n保存E之后的字符串对应的数字
if(s[0] == '-') cout << '-';
if(n < 0) {//左移
cout << "0.";
for(int j=0; j<abs(n)-1; j++) cout << '0';
for(int j=0; j<t.length(); j++)
if(t[j] != '.') cout << t[j];
} else {
cout << t[0];//小数点前
int cnt,j;
for(j=2,cnt=0; j<t.length()&&cnt<n; j++,cnt++) cout << t[j];
if(j == t.length()){//j已经走完t,n还没用完或者刚好用完，补0
for(int k=0; k<n-cnt; k++) cout << '0';
} else {//n已经用完，j还没走完t,继续输出剩下的t
cout << '.';
for(int k=j; k<t.length(); k++) cout << t[k];
}
}
return 0;
}
2. 利用C++STL库中的prev_permutation和next_permutation来求全排列*
例如：输出四个数，求出它的全排列
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
bool cmp(int a,int b)
{
return a>b;
}
int main()
{
int a[4];
for(int i=0;i<4;i++)
{
scanf("%d",&a[i]);
}
sort(a,a+4,cmp);
do{
cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<" "<<a[3]<<endl;
}while(prev_permutation(a,a+4));
getchar();
return 0;
}
输入1,2,3,4
dos运行界面：
3.贪心算法
在PAT乙级中贪心算法可以用来解决局部最优问题
1）1020 月饼 (25 分)*
比如：1020 月饼 (25 分)
月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。
注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为
75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第
3 种月饼，获得 72 + 45/2 = 94.5（亿元）。 输入格式： 每个输入包含一个测试用例。每个测试用例先给出一个不超过 1000
的正整数 N 表示月饼的种类数、以及不超过 500（以万吨为单位）的正整数 D 表示市场最大需求量。随后一行给出 N
个正数表示每种月饼的库存量（以万吨为单位）；最后一行给出 N 个正数表示每种月饼的总售价（以亿元为单位）。数字间以空格分隔。 输出格式：
对每组测试用例，在一行中输出最大收益，以亿元为单位并精确到小数点后 2 位。 输入样例： 3 20 18 15 10 75 72 45
输出样例：
94.50
emmmmm其实这道题有点像高中的数学求解最优问题，给出三种商品，每种商品单价不同，给出市场需求M，（其实就是三种商品总共能销售的量），然后求收益最大化。
思路：将三种商品单价按递减排序，假设单价最高的商品的库存小于市场需求，则全部购买这种商品，以此类推…
代码：
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 1001;
struct mooncake{
double store;//库存
double sell;//销售量
double price;//单价
}m[maxn];
bool cmp(mooncake m1, mooncake m2){ //按单价递减排序
return m1.price > m2.price;
}
int main(){
int n;
double need;
cin>>n>>need;
for(int i = 0; i < n; i++){
cin>>m[i].store;
}
for(int i = 0; i < n; i++){
cin>>m[i].sell;
m[i].price = m[i].sell / m[i].store;
}
sort(m, m + n, cmp); //将三种月饼的单价按递减排序
double ans = 0; //总收益
for(int i = 0; i < n; i++){
if(need >= m[i].store){ 大于库存//假设市场需求
ans += m[i].sell;
need -= m[i].store;
}else{
ans += need * m[i].price;
break;
}
}
printf("%.2f", ans);
return 0;
}
2）1023 组个最小数
1023 组个最小数 (20 分)
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0
不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。现给定数字，请编写程序输出能够组成的最小的数。 输入格式：
输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……数字 9 的个数。整数间用一个空格分隔。10
个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。 输出格式：在一行中输出能够组成的最小的数。 输入样例：
2 2 0 0 0 3 0 0 1 0
输出样例：
10015558
思路：先从1-9中选择个数不为0的最小的数输出，然后从0-9输出数字，每个数字输出次数为其剩余个数
#include<stdio>
#include<iostream>
using namespace std;
int main()
{
int cout[10];//记录0-9的个数
for(int i=0;i<10;i++)
{
scanf("%d",&cout[i]);
}
for(int i=1;i<10;i++)
{
if(cout[i]>0)
{
coout<<i;
cout[i]--;
break;//输出第一个非0的数字，然后中断
}
}
for(int i=0;i<10;i++)//从0-9输出对应个数的数字
{
for(int j=0;j<cout[i];j++)
{
cout<<i;
}
}
return 0;
}
- PAT常用的一些函数
##求素数(从2-根号n）
bool isPrime(int n)
{
if(n<=1) return false;
int sqr=(int)sqrt(n*1.0);
for(int i=2;i<sqr;i++)
{
if(n%i==0) return false;
}
return true;
}
##进制转换
1）将p进制的数转化为十进制的数
int y=0,product=1;
while(x!=0)
{
y=y+(x%10)*product;
x=x/10;//去掉x的个位
product=product*p;
}
2)将十进制的数转化为Q进制数
int z[40],num=0;
do{
z[num++]=y%Q;
y=y/Q;
}while(y!=0);
##二分法
int binarySearch(int A[],int left,int right,int x)
{
int mid;
while(left<=right)
{
mid=(left+right)/2;
if(A[mid]==x) return mid;
else if(A[mid]>x)
{
right=mid-1;
}else
{
left=mid+1;
}
}
return -1;
}
##最大公约数
int gcd(int a,int b)
{
if(b==0) return a;
else return gcd(b,a%b);
}
##最小公倍数
由最大公约数计算
*a和b的最小公倍数=a/db***d是a和b的最大公约数
4. STL之stack–后进先出在PAT中的应用 ——————B1009
栈可以这样子通俗理解：在一个箱子里放入一些书，先放进去的书在箱子下面，后放进去的书放在箱子的上面，所以后来放进去的书先拿出来，先放进去的书后拿出来
1）stack主要操作：
a.插入：stack.push();
b.取顶：stack.top();
c.去除第一个元素:stack.pop();
d.判空：stack.empty(); 常用while(!stack.empty)
2）B1009
1009 说反话 (20 分)
给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。 输入格式：
测试输入包含一个测试用例，在一行内给出总长度不超过 80
的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用 1
个空格分开，输入保证句子末尾没有多余的空格。 输出格式：每个测试用例的输出占一行，输出倒序后的句子。 输入样例：
Hello World Here I Come
输出样例：
> Come I Here World Hello
#include<stack>
#include<cstdio>
#include<string>
#include<iostream>
using namespace std;
int main()
{ char c;
string str;
stack<string>st;
while(cin>>str)
{
st.push(str);
if((c=getchar())=='\n')break;
} //输入，直到匹配的凹换行符
cout<<st.top();
st.pop();
while(!st.empty())
{
cout<<" "<<st.top();
st.pop();
}
getchar();
return 0;
}
5. 小白易错点
1）用char进行加减乘除的细节
注意：在多数据计算中，需要建立一个字符串指针，不管是在while,if语句中还是在等式计算中，都需要用*n的形式，然后建立一个Int型的数据进行int型的数据和char型数据的计算；假设数字的位数很少，例如只有5位数，则可以直接提取各个部分的数字，再进行求和
{
int a,i=0;
while(n!=0)
{
a=n%10;
num[i]=a;
n=n/10;
i++;
}
}
比如：输入一个不超过1000位的正实数，求出这个数不同位置数字之和。
思路：可以用STL库中的string或者char来进行输入操作，假设建立int型数据，则输入数据可能会超出范围
#include<cstring>
#include<cstdio>
#include<iostream>
using namespace std;
int main()
{
char a[101];
char *b;
b=a;
cin>>a;//用scanf("%s",&a);会发生错误
int sum=0;
while(*b!='\0')
{
sum=sum+(*b-'0'); //不是sum+*b,因为b是char型的指针
b++;
}
cout<<sum<<endl;
return 0;
}
5.PAT不同考场提供的编译器信息-----转载知乎Abner
考试主服务器可以接受二十余种编程语言，但各考场只保证提供C、C++、Java的程序编译调试环境如下：
– 杭州浙江大学玉泉考点：MS Visual Studio 2010 旗舰版, Eclipse (Kepler Release, Build id: 20130614-0229)
– 杭州浙江大学紫金港考点：VS2010, VC++ 6.0, C-Free 标准版, DEV-C++, Turbo C 2.0, Eclipse SDK, Python 3.4.2
– 宁波浙江大学宁波理工学院考点：VC++ 6.0, VS2008, Eclipse 3.7
– 宁波浙江大学软件学院考点：Eclipse 3.5.2, Visual Studio 6.0, TurboC 3.0
– 福州福州大学考点：VC++ 6.0, VS2005, VS2008, Myeclipse 9, Myeclipse 10
– 西安西安交通大学考点：VC++ 6.0, VS2008, VS2013, JDK, Netbean
– 杭州临安浙江农林大学考点：VC++ 6.0
– 杭州下沙浙江传媒学院考点：VC++ 6.0, VS 2005/2010, Eclipse
– 烟台烟台大学考点：MS Visual Studio 2010 旗舰版, Eclipse 3.5.2, Visual Studio 6.0
– 郑州河南中医学院信息技术学院考点：VC++ 6.0, MS Visual Studio 2010, Myeclipse 8
– 青岛青岛大学信息工程学院考点：MinGW+codeblocks12.11, Dev-C++, jdk6+Eclipse Juno
– 嘉兴嘉兴学院数理与信息工程学院考点：VC++ 6.0, VS2008, Myeclipse
– 杭州浙江大学城市学院计算机与计算科学学院考点：VC++ 6.0，Eclipse V3.5.2
– 南昌航空大学数学与信息科学学院考点：Win-TC，Dev-C++，VC++ 6.0，Eclipse SDK
– 兰州交通大学国家级计算机科学与技术实验教学示范中心考点：Turbo C 2.0, VC++ 6.0, Eclipse SDK 3.41
– 苏州大学计算机科学与技术学院考点：VC++ 6.0，VS2010, Eclipse SDK 3.1, Dev C++ 5.4.0
– 上海大学计算中心考点：Guide2.0, Dev-C++, VS2008, Eclipse SDK
– 中山大学教学实验中心考点：Microsoft Visual Studio 2015 (C、C++), Eclipse+JDK1.8(Java)，Python3.5.2(python)
– 浙江中医药大学考点：VC++ 6.0，C-Free 标准版，VS2008，Eclipse+JDK1.7
6.answer for B1001~B1095
1)1001 害死人不偿命的(3n+1)猜想 (15 分)
卡拉兹(Callatz)猜想：
对任何一个正整数 n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把 (3n+1) 砍掉一半。这样一直反复砍下去，最后一定在某一步得到
n=1。卡拉兹在 1950
年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证
(3n+1)，以至于有人说这是一个阴谋，卡拉兹是在蓄意延缓美国数学界教学与科研的进展……我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过 1000 的正整数 n，简单地数一下，需要多少步（砍几下）才能得到 n=1？
输入格式：每个测试输入包含 1 个测试用例，即给出正整数 n 的值。 输出格式：
输出从 n 计算到 1 需要的步数。 输入样例：
3
输出样例：
5
tip:简单的操作emmmmmmmmmm
#include<cstdio>
#include<cmath>
#include<iostream>
using namespace std;
int main()
{int n;
cin>>n;
int step=0;
while(n!=1)
{
if(n%2==0) n=n/2;
else n=(3*n+1)/2;
step++;
}
cout<<step<<endl;
getchar();
return 0;
}
2)1002 写出这个数 (20 分)
读入一个正整数 n，计算其各位数字之和，用汉语拼音写出和的每一位数字。 输入格式：
每个测试输入包含 1 个测试用例，即给出自然数 n 的值。这里保证 n 小于 10100。 输出格式：
在一行内输出 n 的各位数字之和的每一位，拼音数字间有 1 空格，但一行中最后一个拼音数字后没有空格。 输入样例：
1234567890987654321123456789
输出样例：
yi san wu
```
#include<stdio.h>
#include<string.h>
#include <stdlib.h>
void print_sum(int n){
char *name[] ={"ling","yi","er","san","si","wu","liu","qi","ba","jiu","shi"};
int a[10];
int i=0;
for(i=0;n>=10;i++){
a[i]=n%10;
n=n/10;
}
a[i++]=n;
while(i--){
if(i!=0){
printf("%s ",name[a[i]]);
}else{
printf("%s\n",name[a[i]]);
}
}
}
int main(){
char s[100];
char *n=s;
scanf("%s",s);
int sum=0;
while(*n!='\0'){
sum=sum+(*n-'0');
n++;
}
print_sum(sum);
}
----------------------------------------
3)1003 我要通过！ (20 分)
“答案正确”是自动判题系统给出的最令人欢喜的回复。本题属于 PAT 的“答案正确”大派送 ——
只要读入的字符串满足下列条件，系统就输出“答案正确”，否则输出“答案错误”。得到“答案正确”的条件是：
字符串中必须仅有 P、 A、 T这三种字符，不可以包含其它字符；
任意形如 xPATx 的字符串都可以获得“答案正确”，其中 x 或者是空字符串，或者是仅由字母 A 组成的字符串；
如果 aPbTc 是正确的，那么 aPbATca 也是正确的，其中 a、 b、 c 均或者是空字符串，或者是仅由字母 A 组成的字符串。现在就请你为 PAT 写一个自动裁判程序，判定哪些字符串是可以获得“答案正确”的。 输入格式：
每个测试输入包含 1 个测试用例。第 1 行给出一个正整数 n (<10)，是需要检测的字符串个数。接下来每个字符串占一行，字符串长度不超过
100，且不包含空格。 输出格式：每个字符串的检测结果占一行，如果该字符串可以获得“答案正确”，则输出 YES，否则输出 NO。 输入样例：
8 PAT PAAT AAPATAA AAPAATAAAA xPATx PT Whatever APAAATAA
输出样例：
YES YES YES YES NO NO NO NO
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
bool selectStr(char str[],int length)
{
for(int i=0; i<length; i++)
{
if(str[i]!='A' && str[i]!='P' && str[i]!='T')
return false;
else return true;
}
}
int main()
{
int n,cnt;
char str[101];
scanf("%d",&n);
while(n--)
{ memset(str,0,101); //void *memset(void *s, int ch, size_t n); 对数组以‘0’进行初始化
scanf("%s",str); int length = strlen(str); //extern unsigned int strlen(char *s); 返回字符串长度，不包括结束符'\0' 只能用于字符数组
if(selectStr(str,length))
{ int lena = 0; //a中包含A的个数
int lenb = 0; //b中包含A的个数
int lenc = 0; //c中包含A的个数
for(int i=0;i<length;i++)
{
if(str[i]!='P') lena++;
else break;
}
for(int i=0,cnt=0;i<length;i++)
{
if(str[i]!='T') cnt++; //T前所有字符个数
else
{
lenb = cnt-lena-1; //前面包括a中的A和'P'字符，所以减去lena再减1
lenc = length-cnt-1; //同理，c前面还有'T'字符
break; }
}
if(lenb == 0)
printf("NO\n");
else {
if(lena*lenb == lenc)
{ printf("YES\n"); }
else { printf("NO\n"); }
} //test
} else { printf("NO\n"); } } return 0; }
4)1004 成绩排名 -----用结构体解决
读入 n（>0）名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。 输入格式：
每个测试输入包含 1 个测试用例，格式为
第 1 行：正整数 n 第 2 行：第 1 个学生的姓名 学号 成绩 第 3 行：第 2 个学生的姓名 学号 成绩 … …
… 第 n+1 行：第 n 个学生的姓名 学号 成绩其中姓名和学号均为不超过 10 个字符的字符串，成绩为 0 到 100 之间的一个整数，这里保证在一组测试用例中没有两个学生的成绩是相同的。
输出格式：对每个测试用例输出 2 行，第 1 行是成绩最高学生的姓名和学号，第 2 行是成绩最低学生的姓名和学号，字符串间有 1 空格。 输入样例：
3 Joe Math990112 89 Mike CS991301 100 Mary EE990830 95
输出样例：
Mike CS991301 Joe Math990112
Administrator:
#include<cstdio>
#include<cstring>
#include<string>
struct student
{
char name[15];
char id[15];
int score;
}stu,stuMAx,stuMIN;
int main()
{
int n;
stuMAx.score=0,stuMIN.score=100;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%s%s%d",&stu.name,&stu.id,&stu.score);
if(stu.score>stuMAx.score) stuMAx=stu;
if(stu.score<stuMIN.score) stuMIN=stu;
getchar();
}
printf("%s %s\n",stuMAx.name,stuMAx.id);
printf("%s %s\n",stuMIN.name,stuMIN.id);
getchar();
getchar();
return 0;
}
1005 继续(3n+1)猜想 (25 分)
卡拉兹(Callatz)猜想已经在1001中给出了描述。在这个题目里，情况稍微有些复杂。
当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对 n=3 进行验证的时候，我们需要计算
3、5、8、4、2、1，则当我们对 n=5、8、4、2 进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重复计算，因为这 4
个数已经在验证3的时候遇到过了，我们称 5、8、4、2 是被 3“覆盖”的数。我们称一个数列中的某个数 n 为“关键数”，如果 n
不能被数列中的其他数字所覆盖。现在给定一系列待验证的数字，我们只需要验证其中的几个关键数，就可以不必再重复验证余下的数字。你的任务就是找出这些关键数字，并按从大到小的顺序输出它们。
输入格式：每个测试输入包含 1 个测试用例，第 1 行给出一个正整数 K (<100)，第 2 行给出 K 个互不相同的待验证的正整数 n
(1<n≤100)的值，数字间用空格隔开。 输出格式：每个测试用例的输出占一行，按从大到小的顺序输出关键数字。数字间用 1 个空格隔开，但一行中最后一个数字后没有空格。 输入样例：
6 3 5 6 7 8 11
输出样例：
7 6
#include<iostream>
using namespace std;
int m[105] = { 0 };
int s[105];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]] = 1;
}
for (int i = 0; i < n; i++) {
while ( s[i] != 1) {
if (s[i] % 2 == 1) s[i] = (3 * s[i] + 1) / 2;
else s[i] /= 2;
if (s[i] < 105) m[s[i]] = 0;
}
}
bool first = true;
for (int i = 104; i > 0; i--)
if (m[i]) {
if (!first) cout << ' ';
cout << i;
first = false;
}
cout << endl;
return 0;
}
B1006 换个格式输出整数 (15 分)
让我们用字母 B 来表示“百”、字母 S 表示“十”，用 12…n 来表示不为零的个位数字 n（<10），换个格式来输出任一个不超过 3
位的正整数。例如 234 应该被输出为 BBSSS1234，因为它有 2 个“百”、3 个“十”、以及个位的 4。 输入格式：每个测试输入包含 1 个测试用例，给出正整数 n（<1000）。 输出格式：
每个测试用例的输出占一行，用规定的格式输出 n。 输入样例 1：
234
输出样例 1：
BBSSS1234
输入样例 2：
23
输出样例 2：
SS123
#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int main()
{
int num_B,num_S;
int n;
cin>>n;
int a[9];
for(int i=0;i<9;i++)
{
a[i]=i+1;
}
int gewei;
num_B=n/100;
num_S=(n/10)%10;
gewei=n%10;
while(num_B--)
{
cout<<"B";
}
while(num_S--)
{
cout<<"S";
}
for(int s=0;s<gewei;s++)
{
cout<<a[s];
}
system("pause");
getchar();
return 0;
}
B1007 素数对猜想 (20 分)
让我们定义dn为：dn=pn+1−pn，其中pi是第i个素数。显然有d1=1，且对于n>1有dn是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。
现给定任意正整数N(<105)，请计算不超过N的满足猜想的素数对的个数。 输入格式:
输入在一行给出正整数N。 输出格式:
在一行中输出不超过N的满足猜想的素数对的个数。 输入样例:
20
输出样例:
4
#include<cstdio>
#include<cmath>
bool judge(int a){
int flag=1;
int x=floor(sqrt(a));
int k=2;
if(a==1)
return 0;
while(k<=x&&a%k!=0)
k++;
if(k<=x)
return 0;
else
return 1;
}
int main(){
int N;
int num=0;
scanf("%d",&N);
if(N==1||N==2)
printf("0\n");
else{
for(int j=3;j<=N;j++){
if(judge(j)&&judge(j-2))//巧妙啊
num++;
}
printf("%d\n",num);
}
return 0;
}
B1008 数组元素循环右移问题 (20 分)
注意分两种情况，即有没有右移
一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（≥0）个位置，即将A中的数据由（A0A1⋯AN−1）变换为（AN−M⋯AN−1A0A1⋯AN−M−1）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？
输入格式:每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。 输出格式:
在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。 输入样例:
6 2 1 2 3 4 5 6
输出样例:
5 6 1 2 3 4
#include<iostream>
using namespace std;
int main()
{
int a,b;
int count=0;
cin>>a>>b;
b=b%a;
int c[a];
for(int i=0;i<a;i++)
cin>>c[i];
if(b==0)
for(int i=0;i<a;i++)
{
if(i!=a-1)
cout<<c[i]<<" ";
else
cout<<c[i];
}
else
{
for(int i=a-b;i<a;i++)
cout<<c[i]<<" ";
for(int i=0;i<a-b-1;i++)
cout<<c[i]<<" ";
cout<<c[a-b-1];
}
return 0;
}
B1010 一元多项式求导
设计函数求一元多项式的导数。（注：xn（n为整数）的一阶导数为nxn−1。） 输入格式:
以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过 1000 的整数）。数字间以空格分隔。 输出格式:
以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是 0，但是表示为
0 0。 输入样例:3 4 -5 2 6 1 -2 0
输出样例:
12 3 -10 1 6 0
#include<iostream>
#include<algorithm>
#include<string>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
int a[1010];
int main()
{
int k,e; //k为系数，e为指数
int cnt = 0;
while(scanf("%d%d",&k,&e)!=EOF)
a[e] = k;
a[0] = 0;
for(int i=1;i<=1000;i++)
{
a[i-1] = a[i]*i; //求导公式
if(a[i-1]!=0) //记录导数 非零项的个数
cnt++;
a[i] = 0; //因为不知道求导后有没有这一项，所以先置零，如果有的话，在后面会被覆盖
}
if(cnt==0) //特判
printf("0 0");
else
{
for(int i=1000;i>=0;i--)
{
if(a[i]!=0)
{
printf("%d %d",a[i],i);
cnt--;
if(cnt!=0) printf(" ");
}
}
}
return 0;
}
1012 数字分类 (20 分)
给定一系列正整数，请按要求对数字进行分类，并输出以下 5 个数字：
A1 = 能被 5 整除的数字中所有偶数的和； A2 = 将被 5 除后余 1 的数字按给出顺序进行交错求和，即计算 n1−n2+n3−n4⋯； A3 = 被 5 除后余 2 的数字的个数； A4 = 被 5 除后余 3 的数字的平均数，精确到小数点后 1 位； A5 = 被 5 除后余 4 的数字中最大数字。输入格式：
每个输入包含 1 个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N，随后给出 N 个不超过 1000
的待分类的正整数。数字间以空格分隔。 输出格式：对给定的 N 个正整数，按题目要求计算 A1~A5 并在一行中顺序输出。数字间以空格分隔，但行末不得有多余空格。
若其中某一类数字不存在，则在相应位置输出 N。 输入样例 1：
13 1 2 3 4 5 6 7 8 9 10 20 16 18
输出样例 1：
30 11 2 9.7 9
输入样例 2：
8 1 2 4 5 6 7 9 16
输出样例 2：
N 11 2 N 9
#include<cstdio>
#include<vector>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<iostream>
using namespace std;
bool cmp(int x,int y)
{
return x>y;
}
int main()
{
int N,n;
vector<int>num_case1;
vector<int>num_case2;
vector<int>num_case3;
vector<int>num_case4;
vector<int>num_case5;
while(N--)
{
cin>>n;
if(n%5==0&&n%2==0) { num_case1.push_back(n); }
else if(n%5==1) { num_case2.push_back(n); }
else if(n%5==2) { num_case3.push_back(n); }
else if(n%5==3) { num_case4.push_back(n); }
else if(n%5==4) { num_case5.push_back(n); }
}
int t1=0,t2=0,t3,t4,t5;
vector<int>::iterator case1=num_case1.begin();
for(case1;case1!=num_case1.end();case1++)
{
t1=t1+*case1;
}
vector<int>::iterator case2=num_case2.begin();
int temp=1;
for(case2;case2!=num_case2.end();case2++)
{
t2=t2+*case2*temp;
temp=temp*(-1);
}
t3=num_case3.size();
vector<int>::iterator case4=num_case4.begin();
for(case4;case4!=num_case4.end();case4++)
{
t4=t4+*case4;
}
t4=t4/num_case4.size();
sort(num_case5.begin(),num_case5.end(),cmp);
t5=num_case5[0];
//printf
if(!num_case1.empty()) cout<<t1<<" ";
else cout<<"N";
if(!num_case2.empty()) cout<<t2<<" ";
else cout<<"N";
if(!num_case3.empty()) cout<<t3<<" ";
else cout<<"N";
if(!num_case4.empty()) cout<<t4<<" ";
else cout<<"N";
if(!num_case5.empty()) cout<<t5<<endl;
else cout<<"N"<<endl;
getchar();
getchar();
return 0;
}
B1013 数素数
令 Pi 表示第 i 个素数。现任给两个正整数 M≤N≤104，请输出 PM 到 PN 的所有素数。 输入格式：
输入在一行中给出 M 和 N，其间以空格分隔。 输出格式：
输出从 PM 到 PN 的所有素数，每 10 个数字占 1 行，其间以空格分隔，但行末不得有多余空格。 输入样例：
5 27
输出样例：
11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103
#include<algorithm>
#include<cstdio>
#include<cmath>
const int maxn=1000010;
using namespace std;
bool isPrime(int n)
{
if(n==1) return 0;
else if(n==2) return 1;
else if(n<=1) return 0;
int sqr=floor(sqrt(n));
int k=2;//bei chu shu
for(int i=2;i<=sqr;i++)
{
if(n%i==0) return 0;
}
return 1;
}
int main()
{
int M,N;
cin>>M>>N;
int num=1;
int cnt=0;
for(int n=1;n<maxn;n++)
{
if(num>N) break;
else if(num<=N&&isPrime(n)==1)
{
if(num>=M)
{
cout<<n;
cnt++;
if(num<N&&cnt%10!=0) cout<<" ";
else if(cnt%10==0) cout<<'\n';
}
num++;
}
}
getchar();
getchar();
getchar();
return 0;
}
1014 福尔摩斯的约会 (20 分)
大侦探福尔摩斯接到一张奇怪的字条：我们约会吧！ 3485djDkxh4hhGE 2984akDfkkkkggEdsb s&hgsfdk
d&Hyscvnm。大侦探很快就明白了，字条上奇怪的乱码实际上就是约会的时间星期四 14:04，因为前面两字符串中第 1
对相同的大写英文字母（大小写有区分）是第 4 个字母 D，代表星期四；第 2 对相同的字符是 E ，那是第 5 个英文字母，代表一天里的第
14 个钟头（于是一天的 0 点到 23 点由数字 0 到 9、以及大写字母 A 到 N 表示）；后面两字符串第 1 对相同的英文字母 s
出现在第 4 个位置（从 0 开始计数）上，代表第 4 分钟。现给定两对字符串，请帮助福尔摩斯解码得到约会的时间。 输入格式：输入在 4 行中分别给出 4 个非空、不包含空格、且长度不超过 60 的字符串。 输出格式：
在一行中输出约会的时间，格式为 DAY HH:MM，其中 DAY 是某星期的 3 字符缩写，即 MON 表示星期一，TUE
表示星期二，WED 表示星期三，THU 表示星期四，FRI 表示星期五，SAT 表示星期六，SUN
表示星期日。题目输入保证每个测试存在唯一解。 输入样例：3485djDkxh4hhGE 2984akDfkkkkggEdsb s&hgsfdk d&Hyscvnm
输出样例：
THU 14:04
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
char a[70],b[70],c[70],d[70];
cin>>a>>b>>c>>d;
int w = strlen(a);
int y = strlen(c);
int i;
for(i = 0; i < w; i++)
{
if(a[i] >= 'A' && a[i] <= 'G') //判断第一个相同的大写英文字母,!!!必须注意区间是A到G，否则就会没有输出
{
if(a[i] == b[i])
break;
}
else
continue;
}
if( a[i] == 'A')
{
cout<<"MON"<<" ";
}
else if( a[i] == 'B')
{
cout<<"TUE"<<" ";
}
else if( a[i] == 'C')
cout<<"WED"<<" ";
else if(a[i] == 'D')
cout<<"THU"<<" ";
else if( a[i] == 'E')
cout<<"FRI"<<" ";
else if( a[i] == 'F')
cout<<"SAT"<<" ";
else if( a[i] == 'G')
cout<<"SUN"<<" ";
for(i += 1; i < w; i++) //i保存的是第一个相同的大写英文字母，继续往后找第二个相同的英文字母
{
if((a[i] >= 'A' && a[i] <= 'N') || (a[i] >= '0' && a[i] <= '9'))
{
if(a[i] == b[i])
break;
}
else
continue;
}
if(a[i] >= '0' && a[i] <= '9') //若不足两位，用零补齐
cout<<"0"<<(int)a[i] - 48<<":";
else
cout<<(int)a[i] - 65 + 10<<":"; //利用ASCII码值来计算是第几个钟头
for(i = 0;i < y; i++)
{
if((c[i] >= 'a' && c[i] <= 'z') || (c[i] >= 'A' && c[i] <= 'Z'))
{
if(c[i] == d[i])
break;
}
}
if(i < 10)
cout<<"0"<<i<<endl;
else
cout<<i<<endl;
return 0;
}
`
1015 德才论 (25 分)
宋代史学家司马光在《资治通鉴》中有一段著名的“德才论”：“是故才德全尽谓之圣人，才德兼亡谓之愚人，德胜才谓之君子，才胜德谓之小人。凡取人之术，苟不得圣人，君子而与之，与其得小人，不若得愚人。”
现给出一批考生的德才分数，请根据司马光的理论给出录取排名。 输入格式：
输入第一行给出 3 个正整数，分别为：N（≤105），即考生总数；L（≥60），为录取最低分数线，即德分和才分均不低于 L
的考生才有资格被考虑录取；H（<100），为优先录取线——德分和才分均不低于此线的被定义为“才德全尽”，此类考生按德才总分从高到低排序；才分不到但德分到线的一类考生属于“德胜才”，也按总分排序，但排在第一类考生之后；德才分均低于
H，但是德分不低于才分的考生属于“才德兼亡”但尚有“德胜才”者，按总分排序，但排在第二类考生之后；其他达到最低线 L
的考生也按总分排序，但排在第三类考生之后。随后 N 行，每行给出一位考生的信息，包括：准考证号 德分 才分，其中准考证号为 8 位整数，德才分为区间 [0, 100]
内的整数。数字间以空格分隔。 输出格式：输出第一行首先给出达到最低分数线的考生人数 M，随后 M
行，每行按照输入格式输出一位考生的信息，考生按输入中说明的规则从高到低排序。当某类考生中有多人总分相同时，按其德分降序排列；若德分也并列，则按准考证号的升序输出。
输入样例：14 60 80 10000001 64 90 10000002 90 60 10000011 85 80 10000003 85 80
10000004 80 85 10000005 82 77 10000006 83 76 10000007 90 78 10000008
75 79 10000009 59 90 10000010 88 45 10000012 80 100 10000013 90 99
10000014 66 60输出样例：
12 10000013 90 99 10000012 80 100 10000003 85 80 10000011 85 80
10000004 80 85 10000007 90 78 10000006 83 76 10000005 82 77 10000002
90 60 10000014 66 60 10000008 75 79 10000001 64 90
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
struct Student{
int stid,de,cai;
};//定义结构体，成员为考号，德分，才分
bool cmp(Student a,Student b)//设计适应题目的比较函数以调用排序算法
{
if(a.de+a.cai!=b.de+b.cai)
return a.de+a.cai>b.de+b.cai;//降序
else
{
if(a.de!=b.de)
return a.de>b.de;//降序
else
return a.stid<b.stid;//升序
}
}
int main()
{
std::ios::sync_with_stdio(false);//注意加上这句以应对大量IO
int N,L,H,M=0;
Student t;//定义结构体变量
vector<Student>stu1,stu2,stu3,stu4;//使用vector线性存储结构体，以方便调用排序算法
cin>>N>>L>>H;
for(int i=0;i<N;i++)
{
cin>>t.stid>>t.de>>t.cai;
if(t.de>=L&&t.cai>=L)
{
M++;//统计达到最低分数线的考生人数
if(t.de>=H&&t.cai>=H)
stu1.push_back(t);
else if(t.de>=H&&t.cai<H)//才分不到但德分到线，德分到线的意思是德分不小于此线
stu2.push_back(t);
else if(t.de<H&&t.cai<H&&t.de>=t.cai)
stu3.push_back(t);
else
stu4.push_back(t);
}
}
//调用排序算法
sort(stu1.begin(),stu1.end(),cmp);
sort(stu2.begin(),stu2.end(),cmp);
sort(stu3.begin(),stu3.end(),cmp);
sort(stu4.begin(),stu4.end(),cmp);
//输出，注意换行时使用endl耗时很长，会超时，故用'\n'或“\n”
cout<<M<<'\n';
for(int i=0;i<stu1.size();i++)
cout<<stu1[i].stid<<' '<<stu1[i].de<<' '<<stu1[i].cai<<'\n';
for(int i=0;i<stu2.size();i++)
cout<<stu2[i].stid<<' '<<stu2[i].de<<' '<<stu2[i].cai<<'\n';
for(int i=0;i<stu3.size();i++)
cout<<stu3[i].stid<<' '<<stu3[i].de<<' '<<stu3[i].cai<<'\n';
for(int i=0;i<stu4.size();i++)
cout<<stu4[i].stid<<' '<<stu4[i].de<<' '<<stu4[i].cai<<'\n';
return 0;
}
1016 部分A+B (15 分)
正整数 A 的“DA（为 1 位整数）部分”定义为由 A 中所有 DA 组成的新整数 PA。例如：给定
A=3862767，DA=6，则 A 的“6 部分”PA 是 66，因为 A 中有 2 个 6。现给定 A、DA、B、DB，请编写程序计算 PA+PB。 输入格式：
输入在一行中依次给出 A、DA、B、DB，中间以空格分隔，其中 0<A,B<1010。 输出格式：
在一行中输出 PA+PB 的值。 输入样例 1：
3862767 6 13530293 3
输出样例 1：
399
输入样例 2：
3862767 1 13530293 8
输出样例 2：
0
#include<cstdio>
#include<math.h>
int main()
{
long int a,da,b,db,pa,pb;
scanf("%ld%ld%ld%ld",&a,&da,&b,&db);
pa=0,pb=0;
while(a!=0)
{
if(a%10==da)
{
pa=pa*10+da;
}
a=a/10;
}
while(b!=0)
{
if(b%10==db)
{
pb=pb*10+db;
}
b=b/10;
}
printf("%ld",pa+pb);
getchar();
return 0;
}
1017 A除以B (20 分)
本题要求计算 A/B，其中 A 是不超过 1000 位的正整数，B 是 1 位正整数。你需要输出商数 Q 和余数 R，使得 A=B×Q+R
成立。 输入格式：输入在一行中依次给出 A 和 B，中间以 1 空格分隔。 输出格式：
在一行中依次输出 Q 和 R，中间以 1 空格分隔。 输入样例：
123456789050987654321 7
输出样例：
17636684150141093474 3
#include<iostream>
using namespace std;
int main()
{
string s;
int a,t=0,temp=0;
cin>>s>>a;
int len=s.length();
t=(s[0]-'0')/a;
if((t!=0&&len>1)||len==1)
cout<<t;
temp=(s[0]-'0')%a;
for(int i=1;i<len;i++){
t=(temp*10+s[i]-'0')/a;
cout<<t;
temp=(temp*10+s[i]-'0')%a;
}
cout<<" "<<temp;
return 0;
}
1018 锤子剪刀布 (20 分)
大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：
FigCJB.jpg
现给出两人的交锋记录，请统计双方的胜、平、负次数，并且给出双方分别出什么手势的胜算最大。 输入格式：
输入第 1 行给出正整数 N（≤105），即双方交锋的次数。随后 N 行，每行给出一次交锋的信息，即甲、乙双方同时给出的的手势。C
代表“锤子”、J 代表“剪刀”、B 代表“布”，第 1 个字母代表甲方，第 2 个代表乙方，中间有 1 个空格。 输出格式：输出第 1、2 行分别给出甲、乙的胜、平、负次数，数字间以 1 个空格分隔。第 3 行给出两个字母，分别代表甲、乙获胜次数最多的手势，中间有
1 个空格。如果解不唯一，则输出按字母序最小的解。 输入样例：10 C J J B C B B B B C C C C B J B B C J J
输出样例：
5 3 2 2 3 5 B B
#include<iostream>
#include<map>
using namespace std;
map<char,int>m[2];//m[0]表示甲的情况，m[1]表示乙的情况。
int ans[2][3];//ans[0]表示甲的胜、平、负的次数，ans[1]代表乙的情况
int main()
{
int n;
scanf("%d",&n);
while(n--)
{
char c1,c2;
scanf(" %c %c",&c1,&c2);
int temp=c1-c2;
if(temp==0)//平
{
ans[0][1]++;//甲平次数加一
ans[1][1]++;//乙平次数加一
}
else if(temp==-1||temp==-7||temp==8)//甲胜
{
ans[0][0]++;//甲胜次数加一
ans[1][2]++;//乙负次数加一
m[0][c1]++;//甲获胜，出c1手势的次数加一
}
else//乙胜
{
ans[0][2]++;//甲负次数加一
ans[1][0]++;//乙胜次数加一
m[1][c2]++;//乙获胜，出c2手势的次数加一
}
}
printf("%d %d %d\n%d %d %d\n",ans[0][0],ans[0][1],ans[0][2],ans[1][0],ans[1][1],ans[1][2]);
for(int i=0;i<2;i++)
{
int ch='B';
if(m[i][ch]<m[i]['C'])
ch='C';
if(m[i][ch]<m[i]['J'])
ch='J';
if(i) printf(" ");
printf("%c",ch);
}
printf("\n");
return 0;
}
1019 数字黑洞 (20 分)
给定任一个各位数字不完全相同的 4 位正整数，如果我们先把 4 个数字按非递增排序，再按非递减排序，然后用第 1 个数字减第 2
个数字，将得到一个新的数字。一直重复这样做，我们很快会停在有“数字黑洞”之称的 6174，这个神奇的数字也叫 Kaprekar 常数。例如，我们从6767开始，将得到
7766 - 6677 = 1089 9810 - 0189 = 9621 9621 - 1269 = 8352 8532 - 2358 =
6174 7641 - 1467 = 6174 … …现给定任意 4 位正整数，请编写程序演示到达黑洞的过程。 输入格式：
输入给出一个 (0,104) 区间内的正整数 N。 输出格式：
如果 N 的 4 位数字全相等，则在一行内输出 N - N = 0000；否则将计算的每一步在一行内输出，直到 6174
作为差出现，输出格式见样例。注意每个数字按 4 位数格式输出。 输入样例 1：6767
输出样例 1：
7766 - 6677 = 1089 9810 - 0189 = 9621 9621 - 1269 = 8352 8532 - 2358 =
6174输入样例 2：
2222
输出样例 2：
2222 - 2222 = 0000
#include<cstdio>
#include<algorithm>
using namespace std;
bool cmp(int a,int b){
return a>b;
}///递减排序
void to_array(int n,int num[]){///将n的每一位存到num数组
for(int i=0;i<4;i++){
num[i]=n%10;
n/=10;
}
}
int to_number(int num[]){///将num数组转换为数字
int sum=0;
for(int i=0;i<4;i++)
{
sum=sum*10+num[i];
}
return sum;
}
int main()
{
int n,minm,maxm;
scanf("%d",&n);
int num[5];
while(1){
to_array(n,num);
sort(num,num+4);
minm=to_number(num);
sort(num,num+4,cmp);
maxm=to_number(num);
n=maxm-minm;
printf("%04d - %04d = %04d\n",maxm,minm,n);
if(n==0||n==6174) break;
}
return 0;
}
1020 月饼 (25 分)
月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。
注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为
75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第
3 种月饼，获得 72 + 45/2 = 94.5（亿元）。 输入格式：每个输入包含一个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N 表示月饼的种类数、以及不超过 500（以万吨为单位）的正整数
D 表示市场最大需求量。随后一行给出 N 个正数表示每种月饼的库存量（以万吨为单位）；最后一行给出 N
个正数表示每种月饼的总售价（以亿元为单位）。数字间以空格分隔。 输出格式：对每组测试用例，在一行中输出最大收益，以亿元为单位并精确到小数点后 2 位。 输入样例：
3 20 18 15 10 75 72 45
输出样例：
94.50
#include<iostream>
#include<iomanip>
#include<vector>
#include<algorithm>
using namespace std;
struct cake {
float amount;
float total_price;
float price;
};
bool cmp(cake c1, cake c2) { return c1.price > c2.price; }
cake v[1005];
int main() {
int n;
float d;
cin >> n >> d;
for (int i = 0; i < n; i++)
cin >> v[i].amount;
for (int i = 0; i < n; i++) {
cin >> v[i].total_price;
v[i].price = v[i].total_price * 1.0 / v[i].amount;
}
sort(v, v + n, cmp);
float profit = 0.0;
int i = 0;
while (d && i < n) {
if (d - v[i].amount > 0) {
d -= v[i].amount;
profit += v[i].total_price;
}
else {
profit += d * v[i].price;
d = 0;
}
i++;
}
cout << fixed << setprecision(2) << profit << endl;
return 0;
}
1021 个位数统计 (15 分)
给定一个 k 位整数 N=dk−110k−1+⋯+d1101+d0 (0≤di≤9,
i=0,⋯,k−1, dk−1>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定 N=100311，则有 2 个 0，3
个 1，和 1 个 3。 输入格式：每个输入包含 1 个测试用例，即一个不超过 1000 位的正整数 N。 输出格式：
对 N 中每一种不同的个位数字，以 D:M 的格式在一行中输出该位数字 D 及其在 N 中出现的次数 M。要求按 D 的升序输出。
输入样例：100311
输出样例：
0:2 1:3 3:1
#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
int main()
{
char a[1001];
scanf("%s",&a);
char cout[10]={0};
for(int i=0;i<strlen(a);i++)
{
cout[a[i]-'0']++;
}
for(int s=0;s<10;s++)
{
if(cout[s]!=0)
printf("%d:%d\n",s,cout[s]);
}
getchar();
return 0;
}
1022 D进制的A+B (20 分)
输入两个非负 10 进制整数 A 和 B (≤230−1)，输出 A+B 的 D (1<D≤10)进制数。 输入格式：
输入在一行中依次给出 3 个整数 A、B 和 D。 输出格式：
输出 A+B 的 D 进制数。 输入样例：
123 456 8
输出样例：
1103
#include<cstdio>
#include<cmath>
int main()
{
int A,B,D,sum;
scanf("%d %d %d",&A,&B,&D);
sum=A+B;
int a[40],num=0;
do
{
a[num]=sum%D;
sum=sum/D;
num=num+1;
}while(sum!=0);
for(int i=num-1;i>=0;i--)//记得写好
{
printf("%d",a[i]);
}
getchar();
return 0;
}
1023 组个最小数 (20 分)
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0
不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。现给定数字，请编写程序输出能够组成的最小的数。 输入格式：
输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……数字 9 的个数。整数间用一个空格分隔。10
个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。 输出格式：在一行中输出能够组成的最小的数。 输入样例：
2 2 0 0 0 3 0 0 1 0
输出样例：
10015558
#include <cstdio>
#include <string>
int main()
{
int number[10] = { 0 };
for (int i = 0; i < 10; i++)
{
scanf("%d", &number[i]);
}
for (int i = 1; i < 10; i++)
{
if (number[i]>0)
{
printf("%d", i);
number[i]--; //数字减掉一个次数了
break;
}
}//在1~ 找到第一个不为0的数，因为第一个肯定不是0
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < number[i]; j++)
{
printf("%d", i);
}
}
}
1024 科学计数法 (20 分)
科学计数法是科学家用来表示很大或很小的数字的一种方便的方法，其满足正则表达式
[±][1-9].[0-9]+E[±][0-9]+，即数字的整数部分只有 1 位，小数部分至少有 1
位，该数字及其指数部分的正负号即使对正数也必定明确给出。现以科学计数法的格式给出实数 A，请编写程序按普通数字表示法输出 A，并保证所有有效位都被保留。 输入格式：
每个输入包含 1 个测试用例，即一个以科学计数法表示的实数 A。该数字的存储长度不超过 9999 字节，且其指数的绝对值不超过 9999。
输出格式：对每个测试用例，在一行中按普通数字表示法输出 A，并保证所有有效位都被保留，包括末尾的 0。 输入样例 1：
+1.23400E-03
输出样例 1：
0.00123400
输入样例 2：
-1.2E+10
输出样例 2：
-12000000000
#include<iostream>
using namespace std;
int main()
{
string s;
cin >> s;
int i = 0;
while( s[i] != 'E' ) i++;//定位E
string t = s.substr(1, i-1);//t保存E之前的字符串（不包含符号）
int n = stoi(s.substr(i+1));//n保存E之后的字符串对应的数字
if(s[0] == '-') cout << '-';
if(n < 0) {//左移
cout << "0.";
for(int j=0; j<abs(n)-1; j++) cout << '0';
for(int j=0; j<t.length(); j++)
if(t[j] != '.') cout << t[j];
} else {
cout << t[0];//小数点前
int cnt,j;
for(j=2,cnt=0; j<t.length()&&cnt<n; j++,cnt++) cout << t[j];
if(j == t.length()){//j已经走完t,n还没用完或者刚好用完，补0
for(int k=0; k<n-cnt; k++) cout << '0';
} else {//n已经用完，j还没走完t,继续输出剩下的t
cout << '.';
for(int k=j; k<t.length(); k++) cout << t[k];
}
}
return 0;
}
1025 反转链表 (25 分)
给定一个常数 K 以及一个单链表 L，请编写程序将 L 中每 K 个结点反转。例如：给定 L 为 1→2→3→4→5→6，K 为
3，则输出应该为 3→2→1→6→5→4；如果 K 为 4，则输出应该为 4→3→2→1→5→6，即最后不到 K 个元素不反转。 输入格式：每个输入包含 1 个测试用例。每个测试用例第 1 行给出第 1 个结点的地址、结点总个数正整数 N (≤105)、以及正整数 K
(≤N)，即要求反转的子链结点的个数。结点的地址是 5 位非负整数，NULL 地址用 −1 表示。接下来有 N 行，每行格式为：
Address Data Next
其中 Address 是结点地址，Data 是该结点保存的整数数据，Next 是下一结点的地址。 输出格式：
对每个测试用例，顺序输出反转后的链表，其上每个结点占一行，格式与输入相同。 输入样例：
00100 6 4 00000 4 99999 00100 1 12309 68237 6 -1 33218 3 00000 99999 5
68237 12309 2 33218输出样例：
00000 4 33218 33218 3 12309 12309 2 00100 00100 1 99999 99999 5 68237
68237 6 -1
#include <bits/stdc++.h>
using namespace std;
map<int, pair<int, int> >SN;
struct GZ { // 结构体构造 函数 解决
int NO_this;
int data;
int last;
};
struct GZ T[100000 + 100000 + 10];
void solve() {
int toulist = -1, x, FZ;
scanf("%d%d%d", &toulist, &x, &FZ);
if (x == 0)
toulist = -1;
for (int i = 0, tNO_, P1, P2; i < x; i++) {
scanf("%d", &tNO_), tNO_;
scanf("%d", &P1), P1;
scanf("%d", &P2), P2;
SN[tNO_] = { P1 ,P2 };
}
int Tcnt = 0;
for (int j = toulist; j != -1; j = SN[j].second)
T[Tcnt++] = { j,SN[j].first,SN[j].second };
for (int i = Tcnt, j = 0; i >= FZ; i -= FZ, j += FZ) {
reverse(T+j, T+j + FZ);
}
for (int i = 0; i < Tcnt; i++) {
i == Tcnt - 1 ? printf("%05d %d -1\n", T[i].NO_this, T[i].data) : printf("%05d %d %05d\n", T[i].NO_this, T[i].data, T[i + 1].NO_this);
}
}
int main() {
solve();
system("pause");
return 0;
}
1026 程序运行时间 (15 分)
要获得一个 C 语言程序的运行时间，常用的方法是调用头文件 time.h，其中提供了 clock() 函数，可以捕捉从程序开始运行到
clock() 被调用时所耗费的时间。这个时间单位是 clock tick，即“时钟打点”。同时还有一个常数
CLK_TCK，给出了机器时钟每秒所走的时钟打点数。于是为了获得一个函数 f 的运行时间，我们只要在调用 f 之前先调用
clock()，获得一个时钟打点数 C1；在 f 执行完成后再调用 clock()，获得另一个时钟打点数 C2；两次获得的时钟打点数之差
(C2-C1) 就是 f 运行所消耗的时钟打点数，再除以常数 CLK_TCK，就得到了以秒为单位的运行时间。这里不妨简单假设常数 CLK_TCK 为 100。现给定被测函数前后两次获得的时钟打点数，请你给出被测函数运行的时间。 输入格式：
输入在一行中顺序给出 2 个整数 C1 和 C2。注意两次获得的时钟打点数肯定不相同，即 C1 < C2，并且取值在 [0,107]。
输出格式：在一行中输出被测函数运行的时间。运行时间必须按照 hh:mm:ss（即2位的 时:分:秒）格式输出；不足 1 秒的时间四舍五入到秒。
输入样例：123 4577973
输出样例：
12:42:59
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long a,b;
long long h,m,s;
double sum;
cin>>a>>b;
sum = (b-a)*1.0/100;
h = sum/3600;
sum -= h*3600;
m = sum/60;
sum -= m*60;
s = (int)(sum+0.5);
printf("%02d:",h);
printf("%02d:",m);
printf("%02d",s);
}
1027 打印沙漏 (20 分)
本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印
所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。
给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。 输入格式:
输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。 输出格式:
首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。 输入样例:
19 *
输出样例:
***** 2
#include<cstdio>
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int n;
char c;
int i,line=0;
cin>>n>>c;
line=(int)sqrt(2*n+2)-1;
line=(line-1)/2;
for(i=line;i>=1;i--)
{
for(int k=line-i;k>=1;k--)
cout<<" ";
for(int j=i*2+1;j>=1;j--){
cout<<c;}
cout<<endl;
}
for(i=0;i<line;i++){
cout<<" ";}
cout<<c<<endl;
for(i=1;i<=line;i++)
{
for(int k=line-i;k>=1;k--)
cout<<" ";
for(int j=i*2+1;j>=1;j--){
cout<<c;}
cout<<endl;
}
cout<<(n-(2*line*(line+2)+1));
return 0;
}
1028 人口普查 (20 分)
某城镇进行人口普查，得到了全体居民的生日。现请你写个程序，找出镇上最年长和最年轻的人。
这里确保每个输入的日期都是合法的，但不一定是合理的——假设已知镇上没有超过 200 岁的老人，而今天是 2014 年 9 月 6
日，所以超过 200 岁的生日和未出生的生日都是不合理的，应该被过滤掉。 输入格式：输入在第一行给出正整数 N，取值在(0,105]；随后 N 行，每行给出 1 个人的姓名（由不超过 5
个英文字母组成的字符串）、以及按 yyyy/mm/dd（即年/月/日）格式给出的生日。题目保证最年长和最年轻的人没有并列。 输出格式：在一行中顺序输出有效生日的个数、最年长人和最年轻人的姓名，其间以空格分隔。 输入样例：
5 John 2001/05/12 Tom 1814/09/06 Ann 2121/01/30 James 1814/09/05 Steve
1967/11/20输出样例：
3 Tom John
#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
struct people
{
char name[6];
int y;
int m;
int d;
}a,max,min;
max.y=2014;max.m=9;max.d=7;
min.y=1814;max.m=9;max.d=5;
int n,cnt=0;
scanf("%d",&n);
for(int i = 0;i<n;i++){
scanf("%s %d/%d/%d",&a.name,&a.y,&a.m,&a.d);
cnt++;
if(a.y>2014||(a.y==2014&&a.m>9)||(a.y==2014&&a.m==9&&a.d>6)||a.y<1814||(a.y==1814&&a.m<9)||(a.y==1814&&a.m==9&&a.d<6)){
cnt--;
continue;
}//不合格的出生年月
if(a.y<max.y||(a.y==max.y&&a.m<max.m)||(a.y==max.y&&a.m==max.m&&a.d<max.d)){
max=a;
}
if(a.y>min.y||(a.y==min.y&&a.m>min.m)||(a.y==min.y&&a.m==min.m&&a.d>min.d)){
min=a;
}
}
printf("%d",cnt);
if(cnt!=0){
printf(" %s %s",max.name,min.name);
}
return 0;
}
1029 旧键盘 (20 分)
旧键盘上坏了几个键，于是在敲一段文字的时候，对应的字符就不会出现。现在给出应该输入的一段文字、以及实际被输入的文字，请你列出肯定坏掉的那些键。
输入格式：输入在 2 行中分别给出应该输入的文字、以及实际被输入的文字。每段文字是不超过 80 个字符的串，由字母 A-Z（包括大、小写）、数字
0-9、以及下划线 _（代表空格）组成。题目保证 2 个字符串均非空。 输出格式：按照发现顺序，在一行中输出坏掉的键。其中英文字母只输出大写，每个坏键只输出一次。题目保证至少有 1 个坏键。 输入样例：
7_This_is_a_test
_hs_s_a_es输出样例：
7TI
#include<iostream>
#include<string>
#include<cctype>
using namespace std;
int main()
{
string s1, s2,ans;
cin >> s1 >> s2;
for (int i = 0; i < s1.length(); i++) {
if (s2.find(s1[i]) == string::npos && ans.find(toupper(s1[i])) == string::npos)
ans += toupper(s1[i]);
}
cout << ans;
return 0;
}
1030 完美数列 (25 分)
给定一个正整数数列，和正整数 p，设这个数列中的最大值是 M，最小值是 m，如果 M≤mp，则称这个数列是完美数列。
现在给定参数 p 和一些正整数，请你从中选择尽可能多的数构成一个完美数列。 输入格式：
输入第一行给出两个正整数 N 和 p，其中 N（≤105）是输入的正整数的个数，p（≤109）是给定的参数。第二行给出 N
个正整数，每个数不超过 109。 输出格式：在一行中输出最多可以选择多少个数可以用它们组成一个完美数列。 输入样例：
10 8 2 3 20 4 5 1 6 7 8 9
输出样例：
8
#include <bits/stdc++.h>
using namespace std;
long long int a[100000 + 10];
int N, P;
long long int* efcz(int x) { // 位置
int minst = 0;
int maxst = x-1;
if (maxst < minst) // 1 可以删除 永远不会发生越界访问 我上了三个保险 这个是 保险2
return &a[minst];
while (maxst>minst) { // 2 这个判断条件是多余的 可以等价于 while(1) 何况我对一个元素还是上了保险 1 控制越界
int st = (maxst + minst) / 2;
if (minst == st) {
break;
}
else if (a[st] * P >= a[x]) {
maxst = st;
}
else {
minst = st;
}
}
if(a[minst]*P>=a[x]) // 保险 3
return &a[minst];
return &a[maxst];
}
void solve() {
scanf("%d%d", &N, &P);
for (int i = 0; i<N; i++)
scanf("%lld", &a[i]);
sort(a, a + N);
int cnt = 1;
for (int i = N - 1; i > 0; i--) { // i>0是保险 1
long long int* s = efcz(i);
if (s != &a[i - 1]) { // 3 测试系统忽略的错误
cnt = cnt<&a[i] - s + 1? &a[i] - s + 1 :cnt;
}
}
printf("%d\n", cnt);
}
int main() {
solve();
return 0;
}
1031 查验身份证 (15 分)
一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：
首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：
Z：0 1 2 3 4 5 6 7 8 9 10 M：1 0 X 9 8 7 6 5 4 3 2
现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。 输入格式：
输入第一行给出正整数N（≤100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。 输出格式：
按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出All
passed。 输入样例1：4 320124198808240056 12010X198901011234 110108196711301866
37070419881216001X输出样例1：
12010X198901011234 110108196711301866 37070419881216001X
输入样例2：
2 320124198808240056 110108196711301862
输出样例2：
All passed
#include<iostream>
#include<string>
using namespace std;
int main()
{
char z_m[11]={'1','0','X','9','8','7','6','5','4','3','2'};
int weight[17]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
bool passM=true;
int n;
cin>>n;
while(n--)
{
string str;
cin>>str;
bool allNUm=true;
int total=0;
for(int i=0;i<17&&allNUm;i++)
{
if(str[i]>='0'&&str[i]<='9')
total+=(str[i]-'0')*weight[i];
else allNUm=false;
}
total%=11;
if(str[17]!=z_m[total]||!allNUm)
{
passM=false;
cout<<str<<endl;
}
}
if(passM)cout<<"All passed"<<endl;
system("pause");
return 0;
}
1032 挖掘机技术哪家强 (20 分)
为了用事实说明挖掘机技术到底哪家强，PAT 组织了一场挖掘机技能大赛。现请你根据比赛结果统计出技术最强的那个学校。 输入格式：
输入在第 1 行给出不超过 105 的正整数 N，即参赛人数。随后 N
行，每行给出一位参赛者的信息和成绩，包括其所代表的学校的编号（从 1 开始连续编号）、及其比赛成绩（百分制），中间以空格分隔。 输出格式：在一行中给出总得分最高的学校的编号、及其总分，中间以空格分隔。题目保证答案唯一，没有并列。 输入样例：
6 3 65 2 80 1 100 2 70 3 40 3 0
输出样例：
2 150
#include<cstdio>
const int maxn=100010;
int school[maxn]={0};
int main()
{
int n,schid,score;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d %d",&schid,&score);
school[schid]+=score;
}
int k=1,MAX=-1;
for(int i=1;i<=n;i++)
{
if(school[i]>MAX)
{
MAX=school[i];
k=i;
}
}
printf("%d %d\n",k,MAX);
return 0;
}
1033 旧键盘打字 (20 分)
旧键盘上坏了几个键，于是在敲一段文字的时候，对应的字符就不会出现。现在给出应该输入的一段文字、以及坏掉的那些键，打出的结果文字会是怎样？
输入格式：输入在 2 行中分别给出坏掉的那些键、以及应该输入的文字。其中对应英文字母的坏键以大写给出；每段文字是不超过 105
个字符的串。可用的字符包括字母 [a-z, A-Z]、数字 0-9、以及下划线 _（代表空格）、,、.、-、+（代表上档键）。题目保证第 2
行输入的文字串非空。注意：如果上档键坏掉了，那么大写的英文字母无法被打出。 输出格式：
在一行中输出能够被打出的结果文字。如果没有一个字符能被打出，则输出空行。 输入样例：
7+IE. 7_This_is_a_test.
输出样例：
_hs_s_a_tst
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s1,s2;
int flag = 0 ;
int sum = 0;
getline(cin,s1);
getline(cin,s2);
int len = s2.length();
if(s1.find('+') != string::npos) //判断是否能打出大写字母
flag = 1;
for(int i = 0; i < len ; i++)
{
if(s2[i] >= 'a' && s2[i] <= 'z')
{
if(s1.find(s2[i] - 32) == string::npos)
{
cout<<s2[i];
sum = 1;
}
}
else if(s1.find(s2[i]) == string::npos)
{
if(s2[i] >= 'A' && s2[i] <= 'Z' && flag == 1)
continue;
else
{
cout<<s2[i];
sum = 1;
}
}
}
if(sum == 0)
cout<<endl;
return 0;
}
1034 有理数四则运算 (20 分)
本题要求编写程序，计算 2 个有理数的和、差、积、商。 输入格式：
输入在一行中按照 a1/b1 a2/b2
的格式给出两个分数形式的有理数，其中分子和分母全是整型范围内的整数，负号只可能出现在分子前，分母不为 0。 输出格式：分别在 4 行中按照 有理数1 运算符 有理数2 = 结果 的格式顺序输出 2
个有理数的和、差、积、商。注意输出的每个有理数必须是该有理数的最简形式 k a/b，其中 k 是整数部分，a/b
是最简分数部分；若为负数，则须加括号；若除法分母为 0，则输出 Inf。题目保证正确的输出中没有超过整型范围的整数。 输入样例 1：2/3 -4/2
输出样例 1：
2/3 + (-2) = (-1 1/3) 2/3 - (-2) = 2 2/3 2/3 * (-2) = (-1 1/3) 2/3 /
(-2) = (-1/3)输入样例 2：
5/3 0/6
输出样例 2：
1 2/3 + 0 = 1 2/3 1 2/3 - 0 = 1 2/3 1 2/3 * 0 = 0 1 2/3 / 0 = Inf
#include <iostream>
#include <cmath>
using namespace std;
//辗转相除法
int gcd(long long a, long long b){
return b == 0 ? a : gcd(b, a % b);
}
void print(long long a, long long b){
long long c = 0; //带分数前面的整数部分，默认是0
if(a > 0){ //正数
if(b == 1){ //形如3/1
printf("%lld", a);
}
else if(a > b){ //形如5/3
c = a / b;
a -= b * c;
printf("%lld %lld/%lld", c, a, b);
}
else{ //真分数 形如3/5
printf("%lld/%lld", a, b);
}
}
else if(a == 0){ //形如0/3
printf("%c", '0');
}
else{ //负数
if(b == 1){ //形如-3/1
printf("(%lld)", a);
}
else if(-1 * a > b){ //形如-5/3
c = a / b;
a = (-1 * a) % b;
printf("(%lld %lld/%lld)", c, a, b);
}
else{ //真分数
printf("(%lld/%lld)", a, b);
}
}
}
void add(long long a1, long long b1, long long a2, long long b2){
print(a1, b1);
printf(" + ");
print(a2, b2);
printf(" = ");
long long a3 = a1 * b2 + a2 * b1;
long long b3 = b1 * b2;
//化简到最简形式，非带分数形式
long long gcd3 = abs(gcd(a3, b3));
a3 /= gcd3;
b3 /= gcd3;
print(a3, b3);
printf("\n");
}
void subtract(long long a1, long long b1, long long a2, long long b2){
print(a1, b1);
printf(" - ");
print(a2, b2);
printf(" = ");
long long a3 = a1 * b2 - a2 * b1;
long long b3 = b1 * b2;
//化简到最简形式，非带分数形式
long long gcd3 = abs(gcd(a3, b3));
a3 /= gcd3;
b3 /= gcd3;
print(a3, b3);
printf("\n");
}
void multiply(long long a1, long long b1, long long a2, long long b2){
print(a1, b1);
printf(" * ");
print(a2, b2);
printf(" = ");
long long a3 = a1 * a2;
long long b3 = b1 * b2;
//化简到最简形式，非带分数形式
long long gcd3 = abs(gcd(a3, b3));
a3 /= gcd3;
b3 /= gcd3;
print(a3, b3);
printf("\n");
}
void divide(long long a1, long long b1, long long a2, long long b2){
print(a1, b1);
printf(" / ");
print(a2, b2);
printf(" = ");
if(a2 == 0){
printf("Inf");
}
else if(a2 < 0){
long long a3 = -1 * a1 * b2;
long long b3 = -1 * b1 * a2;
//化简到最简形式，非带分数形式
long long gcd3 = abs(gcd(a3, b3));
a3 /= gcd3;
b3 /= gcd3;
print(a3, b3);
}
else{
long long a3 = a1 * b2;
long long b3 = b1 * a2;
//化简到最简形式，非带分数形式
long long gcd3 = abs(gcd(a3, b3));
a3 /= gcd3;
b3 /= gcd3;
print(a3, b3);
}
printf("\n");
}
int main(){
long long a1, b1, a2, b2;
long long c1 = 0, c2 = 0;
scanf("%lld/%lld %lld/%lld", &a1, &b1, &a2, &b2);
//先化简到最简形式，非带分数形式
long long gcd1 = abs(gcd(a1, b1));
a1 /= gcd1;
b1 /= gcd1;
long long gcd2 = abs(gcd(a2, b2));
a2 /= gcd2;
b2 /= gcd2;
//统一用最简形式参与运算
add(a1, b1, a2, b2);
subtract(a1, b1, a2, b2);
multiply(a1, b1, a2, b2);
divide(a1, b1, a2, b2);
return 0;
}
1035 插入与归并 (25 分)
根据维基百科的定义：
插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。
归并排序进行如下迭代操作：首先将原始序列看成 N 个只包含 1 个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下 1
个有序的序列。现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？ 输入格式：
输入在第一行给出正整数 N (≤100)；随后一行给出原始序列的 N
个整数；最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。 输出格式：首先在第 1 行中输出Insertion Sort表示插入排序、或Merge Sort表示归并排序；然后在第 2
行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔，且行首尾不得有多余空格。 输入样例 1：10 3 1 2 8 7 5 9 4 6 0 1 2 3 7 8 5 9 4 6 0
输出样例 1：
Insertion Sort 1 2 3 5 7 8 9 4 6 0
输入样例 2：
10 3 1 2 8 7 5 9 4 0 6 1 3 2 8 5 7 4 9 0 6
输出样例 2：
Merge Sort 1 2 3 8 4 5 7 9 0 6
#include<stdio.h>
#include<algorithm>
using namespace std;
int min(int a,int b)
{
return a>b?b:a;
}
int main()
{
int n,i,j,temp,k,cou;
int num[110],a[110],b[110];
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d",&a[i]);
for(i=0;i<n;i++)
scanf("%d",&b[i]);
for(i=0;i<n;i++)
num[i]=a[i];
for(i=1;i<n;i++)
{
temp=num[i];
for(j=i;j>=1&&temp<num[j-1];j--)
num[j]=num[j-1];
num[j]=temp;
for(cou=0;num[cou]==b[cou]&&cou<=n;cou++);
if(n<=cou)
{
printf("Insertion Sort\n");
i++;
temp=num[i];
for(j=i;j>=1&&temp<num[j-1];j--)
num[j]=num[j-1];
num[j]=temp;
for(k=0;k<n;k++)
{
if(k)
printf(" ");
printf("%d",num[k]);
}
return 0;
}
}
printf("Merge Sort\n");
for(i=0;i<n;i++)
num[i]=a[i];
for(j=2;j/2<n;j*=2)
{
for(i=0;i<n;i+=j)
sort(num+i,num+min(i+j,n));
for(cou=0;num[cou]==b[cou]&&cou<=n;cou++);
if(n<=cou)
{
j*=2;
for(i=0;i<n;i+=j)
sort(num+i,num+min(i+j,n));
for(k=0;k<n;k++)
{
if(k)
printf(" ");
printf("%d",num[k]);
}
}
}
return 0;
}
1036 跟奥巴马一起编程 (15 分)
美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014
年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！ 输入格式：输入在一行中给出正方形边长 N（3≤N≤20）和组成正方形边的某种字符 C，间隔一个空格。 输出格式：
输出由给定字符 C 画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的
50%（四舍五入取整）。 输入样例：10 a
输出样例：
aaaaaaaaaa a a a a a a aaaaaaaaaa
#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
int n,t;
char c;
scanf("%d %c",&n,&c);
if(n%2==0)
t=n/2;
else t=n/2+1;
for(int j=0;j<n;j++)
{
printf("%c",c);
}
printf("\n");
for(int i=1;i<t-1;i++)
{
printf("%c",c);
for(int j=1;j<n-1;j++)
{
printf(" ");
}
printf("%c",c);
printf("\n");
}
for(int j=0;j<n;j++)
{
printf("%c",c);
}
printf("\n");
return 0;
}
1037 在霍格沃茨找零钱 (20 分)
如果你是哈利·波特迷，你会知道魔法世界有它自己的货币系统 ——
就如海格告诉哈利的：“十七个银西可(Sickle)兑一个加隆(Galleon)，二十九个纳特(Knut)兑一个西可，很容易。”现在，给定哈利应付的价钱
P 和他实付的钱 A，你的任务是写一个程序来计算他应该被找的零钱。 输入格式：输入在 1 行中分别给出 P 和 A，格式为 Galleon.Sickle.Knut，其间用 1 个空格分隔。这里 Galleon 是
[0, 107] 区间内的整数，Sickle 是 [0, 17) 区间内的整数，Knut 是 [0, 29) 区间内的整数。
输出格式：在一行中用与输入同样的格式输出哈利应该被找的零钱。如果他没带够钱，那么输出的应该是负数。 输入样例 1：
10.16.27 14.1.28
输出样例 1：
3.2.1
输入样例 2：
14.1.28 10.16.27
输出样例 2：
-3.2.1
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
int main()
{
ll galleon1,sickle1,knut1;
ll galleon2,sickle2,knut2;
scanf("%lld.%lld.%lld %lld.%lld.%lld",&galleon1,&sickle1,&knut1,&galleon2,&sickle2,&knut2);
ll cha = galleon2*17*29+sickle2*29+knut2-galleon1*29*17-sickle1*29-knut1;
if(cha==0)
printf("0.0.0");
else if(cha>0)
{
int a=cha%29;
cha=cha/29;
int b=cha%17;
int c=cha/17;
printf("%d.%d.%d\n",c,b,a);
}
else
{
cha=-cha;
int a=cha%29;
cha=cha/29;
int b=cha%17;
int c=cha/17;
printf("-%d.%d.%d\n",c,b,a);
}
return 0;
}
1038 统计同成绩学生 (20 分)
本题要求读入 N 名学生的成绩，将获得某一给定分数的学生人数输出。 输入格式：
输入在第 1 行给出不超过 105 的正整数 N，即学生总人数。随后一行给出 N
名学生的百分制整数成绩，中间以空格分隔。最后一行给出要查询的分数个数 K（不超过 N 的正整数），随后是 K 个分数，中间以空格分隔。
输出格式：在一行中按查询顺序给出得分等于指定分数的学生人数，中间以空格分隔，但行末不得有多余空格。 输入样例：
10 60 75 90 55 75 99 82 90 75 50 3 75 90 88
输出样例：
3 2 0
#include<stdio.h>
int main(){
int a,b,n,q;
int array[101]={0};
scanf("%d",&a);
for(int i=0;i<a;i++){
scanf("%d",&b);
array[b]++;
}
scanf("%d",&n);
do{
scanf("%d",&q);
if(n!=1){
printf("%d ",array[q]);
}else{
printf("%d\n",array[q]);
}
n=n-1;
}while(n!=0);
}
1039 到底买不买 (20 分)
小红想买些珠子做一串自己喜欢的珠串。卖珠子的摊主有很多串五颜六色的珠串，但是不肯把任何一串拆散了卖。于是小红要你帮忙判断一下，某串珠子里是否包含了全部自己想要的珠子？如果是，那么告诉她有多少多余的珠子；如果不是，那么告诉她缺了多少珠子。
为方便起见，我们用[0-9]、[a-z]、[A-Z]范围内的字符来表示颜色。例如在图1中，第3串是小红想做的珠串；那么第1串可以买，因为包含了全部她想要的珠子，还多了8颗不需要的珠子；第2串不能买，因为没有黑色珠子，并且少了一颗红色的珠子。
figbuy.jpg
图 1 输入格式：
每个输入包含 1 个测试用例。每个测试用例分别在 2 行中先后给出摊主的珠串和小红想做的珠串，两串都不超过 1000 个珠子。 输出格式：
如果可以买，则在一行中输出 Yes 以及有多少多余的珠子；如果不可以买，则在一行中输出 No 以及缺了多少珠子。其间以 1 个空格分隔。
输入样例 1：ppRYYGrrYBR2258 YrR8RrY
输出样例 1：
Yes 8
输入样例 2：
ppRYYGrrYB225 YrR8RrY
输出样例 2：
No 2
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s1,s2;
int a[1001]={0};
getline(cin,s1);
getline(cin,s2);
for(int i=0;i<s1.size();i++){
a[s1[i]]++;
}
int tag=1,cnt=0;
for(int i=0;i<s2.size();i++){
if(a[s2[i]]!=0){
a[s2[i]]--;
}
else{
tag=0;
cnt++;
}
}
if(tag){
int tmp=s1.size()-s2.size();
printf("Yes %d",tmp);
}else{
printf("No %d",cnt);
}
return 0;
}
1040 有几个PAT (25 分)
字符串 APPAPT 中包含了两个单词 PAT，其中第一个 PAT 是第 2 位§，第 4 位(A)，第 6 位(T)；第二个 PAT
是第 3 位§，第 4 位(A)，第 6 位(T)。现给定字符串，问一共可以形成多少个 PAT？ 输入格式：
输入只有一行，包含一个字符串，长度不超过105，只包含 P、A、T 三种字母。 输出格式：
在一行中输出给定字符串中包含多少个 PAT。由于结果可能比较大，只输出对 1000000007 取余数的结果。 输入样例：
APPAPT
输出样例：
2
#include <cstdio>
#include <cstring>
const int max = 100010;
const int maxmax = 1000000007;
int main()
{
char n[max];
scanf("%s", n);
int sump[max], sumt = 0, sum = 0;
int len = strlen(n);
for (int i = 0; i < len; i++)
{
if (i>0) sump[i] = sump[i - 1];
if (n[i] == 'P'){
sump[i]++;
}
}
for (int i = len-1; i >= 0; i--)
{
if (n[i] == 'T') sumt++;
else if (n[i] == 'A') sum = (sum + sumt*sump[i]) % maxmax;
}
printf("%d\n", sum);
return 0;
}
1041 考试座位号 (15 分)
每个 PAT
考生在参加考试时都会被分配两个座位号，一个是试机座位，一个是考试座位。正常情况下，考生在入场时先得到试机座位号码，入座进入试机状态后，系统会显示该考生的考试座位号码，考试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的试机座位号码求助于你，从后台查出他们的考试座位号码。
输入格式：输入第一行给出一个正整数 N（≤1000），随后 N 行，每行给出一个考生的信息：准考证号 试机座位号 考试座位号。其中准考证号由 16
位数字组成，座位从 1 到 N 编号。输入保证每个人的准考证号都不同，并且任何时候都不会把两个人分配到同一个座位上。考生信息之后，给出一个正整数 M（≤N），随后一行中给出 M 个待查询的试机座位号码，以空格分隔。 输出格式：
对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空格分隔。 输入样例：
4 3310120150912233 2 4 3310120150912119 4 1 3310120150912126 1 3
3310120150912002 3 2 2 3 4输出样例：
3310120150912002 2 3310120150912119 1
#include<iostream>
#include<utility>
#include<string>
using namespace std;
int main()
{
pair<string,int>stu[1005];
int n;
string id;
int test,exam;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>id>>test>>exam;
stu[test]={id,exam};
}
int m;
cin>>m;
int chktest;
while(m--)
{
cin>>chktest;
cout<<stu[chktest].first<<" "<<stu[chktest].second<<endl;
}
return 0;
}
1042 字符统计 (20 分)
请编写程序，找出一段给定文字中出现最频繁的那个英文字母。 输入格式：
输入在一行中给出一个长度不超过 1000 的字符串。字符串由 ASCII 码表中任意可见字符及空格组成，至少包含 1
个英文字母，以回车结束（回车不算在内）。 输出格式：在一行中输出出现频率最高的那个英文字母及其出现次数，其间以空格分隔。如果有并列，则输出按字母序最小的那个字母。统计时不区分大小写，输出小写字母。
输入样例：This is a simple TEST. There ARE numbers and other symbols
1&2&3…输出样例：
e 7
#include<iostream>
#include<string>
#include<cctype>
using namespace std;
int m[26] = { 0 };
int main() {
string s;
getline(cin, s);
for (int i = 0; i < s.size(); i++)
if (isalpha(s[i]))
m[tolower(s[i]) - 'a']++;
int cur = 0;
for (int i = 0; i < 26; i++)
if (m[i] > m[cur])
cur = i;
cout << char('a' + cur) << ' ' << m[cur] << endl;
return 0;
}
1043 输出PATest (20 分)
给定一个长度不超过 104 的、仅由英文字母构成的字符串。请将字符重新调整顺序，按 PATestPATest…
这样的顺序输出，并忽略其它字符。当然，六种字符的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按 PATest
的顺序打印，直到所有字符都被输出。 输入格式：输入在一行中给出一个长度不超过 104 的、仅由英文字母构成的非空字符串。 输出格式：
在一行中按题目要求输出排序后的字符串。题目保证输出非空。 输入样例：
redlesPayBestPATTopTeePHPereatitAPPT
输出样例：
PATestPATestPTetPTePePee
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main()
{
int P = 0,A = 0,T = 0,e = 0,s = 0,t = 0;
string str;
int i;
cin>>str;
for(i = 0; i < str.length(); i++)
{
if(str[i] == 'P')
P++;
else if(str[i] == 'A')
A++;
else if(str[i] == 'T')
T++;
else if(str[i] == 'e')
e++;
else if(str[i] == 's')
s++;
else if(str[i] == 't')
t++;
}
while(1)
{
if(P)
{
cout<<"P";
P--;
}
if(A)
{
cout<<"A";
A--;
}
if(T)
{
cout<<"T";
T--;
}
if(e)
{
cout<<"e";
e--;
}
if(s)
{
cout<<"s";
s--;
}
if(t)
{
cout<<"t";
t--;
}
if(P== 0 && A == 0 && T == 0 && e == 0 && s ==0 && t == 0)
{
cout<<endl;
break;
}
}
return 0;
}
1044 火星数字 (20 分)
火星人是以 13 进制计数的：
地球人的 0 被火星人称为 tret。 地球人数字 1 到 12 的火星文分别为：jan, feb, mar, apr, may, jun, jly, aug, sep, oct, nov, dec。 火星人将进位以后的 12 个高位数字分别称为：tam, hel, maa, huh, tou, kes, hei, elo, syy, lok, mer, jou。例如地球人的数字 29 翻译成火星文就是 hel mar；而火星文 elo nov 对应地球数字
115。为了方便交流，请你编写程序实现地球和火星数字之间的互译。 输入格式：输入第一行给出一个正整数 N（<100），随后 N 行，每行给出一个 [0, 169) 区间内的数字 —— 或者是地球文，或者是火星文。
输出格式：对应输入的每一行，在一行中输出翻译后的另一种语言的数字。 输入样例：
4 29 5 elo nov tam
输出样例：
hel mar may 115 13
#include<iostream>
#include<string>
#include<cstdio>
#include<cctype>
using namespace std;
string a[13] = {"tret", "jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct",
"nov", "dec"};
string b[13] = {"", "tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy",
"lok", "mer", "jou"};
void trans1(string s){
int len = s.length();
int num = 0;
for(int i=0;i<len;i++){
num = num*10+(s[i]-'0');
}
cout<<b[num/13];
if((num%13)&&(num/13)){
cout<<" "<<a[num%13];
}else if(num%13){
cout<<a[num%13];
}else if(num==0){
cout<<a[num%13];
}
}
void trans2(string s){
int len = s.length();
int num = 0;
if(len==4){
printf("0");
return ;
}else if(len==3){
for(int i=1;i<=12;i++){
if(s==a[i]){
printf("%d",i);
return ;
}
if(s==b[i]){
printf("%d",i*13);
return ;
}
}
}else{
string temp1 = s.substr(0,3);
string temp2 = s.substr(4,3);
for(int i=1;i<=12;i++){
if(temp1==b[i]){
num+=i*13;
}
if(temp2==a[i]){
num+=i;
}
}
printf("%d",num);
}
return ;
}
int main()
{
int n;
scanf("%d",&n);
getchar();
for(int i=0;i<n;i++){
string s;
getline(cin,s);
if(isdigit(s[0])){
trans1(s);
}else{
trans2(s);
}
printf("\n");
}
return 0;
}
1045 快速排序 (25 分)
著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元，通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。
给定划分后的 N 个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元？例如给定 N = 5 N = 5 N=5, 排列是1、3、2、4、5。则：
1 的左边没有元素，右边的元素都比它大，所以它可能是主元； 尽管 3 的左边元素都比它小，但其右边的 2 比它小，所以它不能是主元； 尽管 2 的右边元素都比它大，但其左边的 3 比它大，所以它不能是主元； 类似原因，4 和 5 都可能是主元。因此，有 3 个元素可能是主元。 输入格式：
输入在第 1 行中给出一个正整数 N（≤105）； 第 2 行是空格分隔的 N 个不同的正整数，每个数不超过 109。
输出格式：在第 1 行中输出有可能是主元的元素个数；在第 2 行中按递增顺序输出这些元素，其间以 1 个空格分隔，行首尾不得有多余空格。 输入样例：
5 1 3 2 4 5
输出样例：
3 1 4 5
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 100010;
const int INF = 1000000001;
int n, seq[maxn], leftMax[maxn], rightMin[maxn];
int ans[maxn], cnt = 0;
int main(){
cin>>n;
for(int i = 0; i < n; i++){
cin>>seq[i];
}
leftMax[0] = 0;
for(int i = 1; i < n; i++){
leftMax[i] = max(leftMax[i - 1], seq[i - 1]);
}
rightMin[n - 1] = INF;
for(int i = n - 2; i >= 0; i--){
rightMin[i] = min(rightMin[i + 1], seq[i + 1]);
}
for(int i = 0; i < n; i++){
int l = leftMax[i], r = rightMin[i];
if(seq[i] > l && seq[i] < r){
ans[cnt++] = seq[i];
}
}
cout<<cnt<<endl;
for(int i = 0; i < cnt; i++){
if(i == 0) cout<<ans[i];
else cout<<" "<<ans[i];
}
cout<<endl;
return 0;
}
1046 划拳 (15 分)
划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就赢了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。
下面给出甲、乙两人的划拳记录，请你统计他们最后分别喝了多少杯酒。 输入格式：
输入第一行先给出一个正整数 N（≤100），随后 N 行，每行给出一轮划拳的记录，格式为：
甲喊 甲划 乙喊 乙划
其中喊是喊出的数字，划是划出的数字，均为不超过 100 的正整数（两只手一起划）。 输出格式：
在一行中先后输出甲、乙两人喝酒的杯数，其间以一个空格分隔。 输入样例：
5 8 10 9 12 5 10 5 10 3 8 5 12 12 18 1 13 4 16 12 15
输出样例：
1 2
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
int main()
{
int kou1,kou2,hua1,hua2;
int N,jiahe=0,yihe=0;
cin>>N;
int t;
while(N--)
{
cin>>kou1>>hua1>>kou2>>hua2;
t=kou1+kou2;
if(hua1==t&&hua2!=t) {yihe++;}
else if(hua2==t&&hua1!=t) {jiahe++;}
}
printf("%d %d",jiahe,yihe);
getchar();
return 0;
}
1047 编程团体赛 (20 分)
编程团体赛的规则为：每个参赛队由若干队员组成；所有队员独立比赛；参赛队的成绩为所有队员的成绩和；成绩最高的队获胜。
现给定所有队员的比赛成绩，请你编写程序找出冠军队。 输入格式：
输入第一行给出一个正整数 N（≤104），即所有参赛队员总数。随后 N 行，每行给出一位队员的成绩，格式为：队伍编号-队员编号
成绩，其中队伍编号为 1 到 1000 的正整数，队员编号为 1 到 10 的正整数，成绩为 0 到 100 的整数。 输出格式：在一行中输出冠军队的编号和总成绩，其间以一个空格分隔。注意：题目保证冠军队是唯一的。 输入样例：
6 3-10 99 11-5 87 102-1 0 102-3 100 11-9 89 3-2 61
输出样例：
11 176
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1001;
int main()
{
int N;
cin>>N;
int duiwuid,duiyuanid,score;
int t[maxn];
int maxscore=0;
fill(t,t+maxn,0);
int finalid=0;
while(N--)
{
scanf("%d-%d %d",&duiwuid,&duiyuanid,&score);
t[duiwuid]=t[duiwuid]+score;
if(t[duiwuid]>maxscore) {maxscore=t[duiwuid];finalid=duiwuid;}
}
cout<<finalid<<" "<<maxscore<<endl;
getchar();
return 0;
}
1048 数字加密 (20 分)
本题要求实现一种数字加密方法。首先固定一个加密用正整数 A，对任一正整数 B，将其每 1 位数字与 A
的对应位置上的数字进行以下运算：对奇数位，对应位的数字相加后对 13 取余——这里用 J 代表 10、Q 代表 11、K 代表
12；对偶数位，用 B 的数字减去 A 的数字，若结果为负数，则再加 10。这里令个位为第 1 位。 输入格式：输入在一行中依次给出 A 和 B，均为不超过 100 位的正整数，其间以空格分隔。 输出格式：
在一行中输出加密后的结果。 输入样例：
1234567 368782971
输出样例：
3695Q8118
#include <cstdio>
#include <cstring>
void fan(char s[]) //反转字符串函数
{
int len = strlen(s);
for (int j = 0; j < len/2; j++)
{
int temp=s[j];
s[j] = s[len - 1 - j];
s[len - 1 - j] = temp;
}
}
int main()
{
char a[110], b[110],c[110]={0};
scanf("%s %s", a, b);
fan(a);
fan(b);
int lena = strlen(a);
int lenb = strlen(b);
int len = lena > lenb ? lena : lenb;
for (int i = 0; i < len; i++)
{
int numa = i < lena ? a[i] - '0' : 0;
int numb = i < lenb ? b[i] - '0' : 0;
if (i % 2 == 1)
{
int x = numb - numa;
if (x>=0)
{
c[i] = x+'0';
}
else
{
c[i] = x + 10+'0';
}
}
else
{
int y = (numa + numb) % 13;
if (y == 10) c[i] = 'J';
else if (y == 11) c[i] = 'Q';
else if (y == 12) c[i] = 'K';
else c[i] = y+'0';
}
}
fan(c);
puts(c);
return 0;
}
1049 数列的片段和 (20 分)
给定一个正数数列，我们可以从中截取任意的连续的几个数，称为片段。例如，给定数列 { 0.1, 0.2, 0.3, 0.4 }，我们有
(0.1) (0.1, 0.2) (0.1, 0.2, 0.3) (0.1, 0.2, 0.3, 0.4) (0.2) (0.2, 0.3)
(0.2, 0.3, 0.4) (0.3) (0.3, 0.4) (0.4) 这 10 个片段。给定正整数数列，求出全部片段包含的所有的数之和。如本例中 10 个片段总和是 0.1 + 0.3 + 0.6 + 1.0 + 0.2 +
0.5 + 0.9 + 0.3 + 0.7 + 0.4 = 5.0。 输入格式：输入第一行给出一个不超过 105 的正整数 N，表示数列中数的个数，第二行给出 N 个不超过 1.0
的正数，是数列中的数，其间以空格分隔。 输出格式：在一行中输出该序列所有片段包含的数之和，精确到小数点后 2 位。 输入样例：
4
0.1 0.2 0.3 0.4输出样例：
5.00
#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
double a[100001],sum=0.0;
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
sum=sum+a[i]*i*(n-i+1);
}
printf("%.2f",sum);
return 0;
}
1050 螺旋矩阵 (25 分)
本题要求将给定的 N 个正整数按非递增的顺序，填入“螺旋矩阵”。所谓“螺旋矩阵”，是指从左上角第 1
个格子开始，按顺时针螺旋方向填充。要求矩阵的规模为 m 行 n 列，满足条件：m×n 等于 N；m≥n；且 m−n 取所有可能值中的最小值。
输入格式：输入在第 1 行中给出一个正整数 N，第 2 行给出 N 个待填充的正整数。所有数字不超过 104，相邻数字以空格分隔。 输出格式：
输出螺旋矩阵。每行 n 个数字，共 m 行。相邻数字以 1 个空格分隔，行末不得有多余空格。 输入样例：
12 37 76 20 98 76 42 53 95 60 81 58 93
输出样例：
98 95 93 42 37 81 53 20 76 58 60 76
#include <cstdio>
#include <algorithm>
using namespace std;
int cmp(int a, int b){
return a > b;
}
int main()
{
int N = 0, a[10010];
scanf("%d", &N);
for (int i = 0; i < N; i++){
scanf("%d", &a[i]);
}
sort(a, a + N,cmp);
int m = 0, n = 0, min=10000000, x = 0, y = 0;
for (int i = 1; i <= N; i++){
x = i;
y = N / x;
if (x * y == N && x - y < min&&x >= y){
m = x, n = y;
min = x - y;
}
}
int m1 = 0, n1 = 0, arr = 0, c[10000][200], m2 = m, n2 = n; //二维数组行数一定要为10010，不然在提交时会提示段错误，太大也会提示段错误
while (arr < N)
{
for (int i = n1; i < n&&arr<N; i++)
{
c[m1][i] = a[arr];
arr++;
}
m1++;
for (int i = m1; i < m&&arr<N; i++)
{
c[i][n-1] = a[arr];
arr++;
}
n--;
for (int i = n - 1; i >= n1&&arr<N; i--)
{
c[m-1][i] = a[arr];
arr++;
}
m--;
for (int i = m - 1; i >= m1&&arr<N; i--)
{
c[i][n1] = a[arr];
arr++;
}
n1++;
}
for (int i = 0; i < m2; i++)
{
for (int j = 0; j < n2; j++)
{
printf("%d", c[i][j]);
if (j != n2 - 1) printf(" ");
}
printf("\n");
}
}
1051 复数乘法 (15 分)
复数可以写成 (A+Bi) 的常规形式，其中 A 是实部，B 是虚部，i 是虚数单位，满足 i2=−1；也可以写成极坐标下的指数形式
(R×e(Pi))，其中 R 是复数模，P 是辐角，i 是虚数单位，其等价于三角形式 (R(cos§+isin§)。现给定两个复数的 R 和 P，要求输出两数乘积的常规形式。 输入格式：
输入在一行中依次给出两个复数的 R1, P1, R2, P2，数字间以空格分隔。 输出格式：
在一行中按照 A+Bi 的格式输出两数乘积的常规形式，实部和虚部均保留 2 位小数。注意：如果 B 是负数，则应该写成 A-|B|i
的形式。 输入样例：2.3 3.5 5.2 0.4
输出样例：
-8.68-8.23i
#include <bits/stdc++.h>
using namespace std;
int main(){
double r1, p1, r2, p2, r, p;
cin>>r1>>p1>>r2>>p2;
r = r1 * r2 * cos(p1 + p2);
p = r1 * r2 * sin(p1 + p2);
if (r > -0.005&&r < 0)
r = 0;
if (p >= 0)
printf("%.2f+%.2fi\n", r, p);
else if (-0.005 < p && p < 0)
printf("%.2f+0.00i\n", r);
else
printf("%.2f%.2fi\n", r, p);
return 0;
}
1052 卖个萌 (20 分)
萌萌哒表情符号通常由“手”、“眼”、“口”三个主要部分组成。简单起见，我们假设一个表情符号是按下列格式输出的：
左手[右手]
现给出可选用的符号集合，请你按用户的要求输出表情。 输入格式：
输入首先在前三行顺序对应给出手、眼、口的可选符号集。每个符号括在一对方括号 []内。题目保证每个集合都至少有一个符号，并不超过 10
个符号；每个符号包含 1 到 4 个非空字符。之后一行给出一个正整数 K，为用户请求的个数。随后 K
行，每行给出一个用户的符号选择，顺序为左手、左眼、口、右眼、右手——这里只给出符号在相应集合中的序号（从 1 开始），数字间以空格分隔。
输出格式：对每个用户请求，在一行中输出生成的表情。若用户选择的序号不存在，则输出 Are you kidding me? @/@。 输入样例：
[╮][╭][o][][/] [<][>] [╯][╰][^][-][=][>][<][@][⊙] [Д][▽][_][ε][^]
… 4 1 1 2 2 2 6 8 1 5 5 3 3 4 3 3 2 10 3 9 3输出样例：
╮(╯▽╰)╭ <(@Д=)/~ o(ε)o Are you kidding me? @/@
#include<iostream>
#include<vector>
#include<string>
using namespace std;
int main()
{
vector<string> face[3]; //存放手的可选符号集face[0],存放眼的可选符号集face[1],存放口的可选符号集face[2].
string str; //读入每一行的字符
for(int i=0;i<3;i++){
getline(cin,str); //因为可能有空格在字符串之间，因此使用getline
for(int j=0;j<str.length();){
if(str[j]=='['){ //如果是左方括号
string sign; //存放一个符号的当前非空字符
while(str[++j]!=']'&&j<str.length()){ //只要没有找右方括号，且没有访问完字符串
sign+=str[j]; //将这些非空字符组成一个字符串，最终形成一个符号
}
face[i].push_back(sign); //将这个符号放入相应的符号集中
}
else j++; //如果不是左方括号，那么看下一个
}
}
int k;
cin>>k; //读入用户的请求个数
for(int i=0;i<k;i++){
int lh,le,m,re,rh; //分别是左手（left hand）lh，左眼le，口m，右眼re，右手rl。
cin>>lh>>le>>m>>re>>rh;
if(lh>=1&&lh<=face[0].size()&&le>=1&&le<=face[1].size()&&m>=1&&m<=face[2].size()&&re>=1&&re<=face[1].size()&&rh>=1&&rh<=face[0].size()){
//注意这一串的判断比较长，用户输入的序号（从一开始）一定要在范围内呀。不然运行会出现段错误的。
cout<<face[0][lh-1]<<'('<<face[1][le-1]<<face[2][m-1]<<face[1][re-1]<<')'<<face[0][rh-1]<<endl;
//按照格式输出表情即可
}
else{ //如果用户输入的学号非法，那么输出字符串
cout<<"Are you kidding me? @\\/@"<<endl;
}
}
}
1053 住房空置率 (20 分)
在不打扰居民的前提下，统计住房空置率的一种方法是根据每户用电量的连续变化规律进行判断。判断方法如下：
在观察期内，若存在超过一半的日子用电量低于某给定的阈值 e，则该住房为“可能空置”； 若观察期超过某给定阈值 D 天，且满足上一个条件，则该住房为“空置”。现给定某居民区的住户用电量数据，请你统计“可能空置”的比率和“空置”比率，即以上两种状态的住房占居民区住房总套数的百分比。 输入格式：
输入第一行给出正整数 N（≤1000），为居民区住房总套数；正实数 e，即低电量阈值；正整数 D，即观察期阈值。随后 N
行，每行按以下格式给出一套住房的用电量数据：K E1 E2 … EK
其中 K 为观察的天数，Ei 为第 i 天的用电量。 输出格式：
在一行中输出“可能空置”的比率和“空置”比率的百分比值，其间以一个空格分隔，保留小数点后 1 位。 输入样例：
5 0.5 10 6 0.3 0.4 0.5 0.2 0.8 0.6 10 0.0 0.1 0.2 0.3 0.0 0.8 0.6 0.7
0.0 0.5 5 0.4 0.3 0.5 0.1 0.7 11 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 11 2 2 2 1 1 0.1 1 0.1 0.1 0.1 0.1输出样例：
40.0% 20.0%
（样例解释：第2、3户为“可能空置”，第4户为“空置”，其他户不是空置。）
#include <cstdio>
int main()
{
int d, c, n;
float e, b[1010], x = 0, y = 0;
scanf("%d %f %d", &n, &e, &d);
for (int i = 0; i < n; i++){
int a = 0;
scanf("%d", &c);
int m = c / 2;
for (int j = 0; j < c; j++){
scanf("%f", &b[i]);
if (b[i] < e) a++;
}
if (a > m && c > d) x++;
else if (a > m ) y++;
}
printf("%.1f%% %.1f%%", y / n * 100.0, x / n * 100.0);
return 0;
}
1054 求平均值 (20 分)
本题的基本要求非常简单：给定 N 个实数，计算它们的平均值。但复杂的是有些输入数据可能是非法的。一个“合法”的输入是
[−1000,1000] 区间内的实数，并且最多精确到小数点后 2 位。当你计算平均值的时候，不能把那些非法的数据算在内。 输入格式：输入第一行给出正整数 N（≤100）。随后一行给出 N 个实数，数字间以一个空格分隔。 输出格式：
对每个非法输入，在一行中输出 ERROR: X is not a legal number，其中 X 是输入。最后在一行中输出结果：The
average of K numbers is Y，其中 K 是合法输入的个数，Y 是它们的平均值，精确到小数点后 2
位。如果平均值无法计算，则用 Undefined 替换 Y。如果 K 为 1，则输出 The average of 1 number is
Y。 输入样例 1：7 5 -3.2 aaa 9999 2.3.4 7.123 2.35
输出样例 1：
ERROR: aaa is not a legal number ERROR: 9999 is not a legal number
ERROR: 2.3.4 is not a legal number ERROR: 7.123 is not a legal number
The average of 3 numbers is 1.38输入样例 2：
2 aaa -9999
输出样例 2：
ERROR: aaa is not a legal number ERROR: -9999 is not a legal number
The average of 0 numbers is Undefined
#include<iostream>
#include<ctype.h>
#include<string>
using namespace std;
double val;//如果正确的话，记录字符串代表的值
bool isLegal(string s)
{
int pos=s.length();//记录小数点的位置
bool flag=false;//记录是否有负号
for(int i=0;i<s.length();i++)
{
if(s[i]=='.')
{
if(pos==s.length())
pos=i;
else
return false;//说明已经有小数点了
}
else if(s[i]=='-'&&i==0)
flag=true;
else if(!isdigit(s[i]))//不是小数点也不是数字
return false;
}
if(pos!=s.length()&&pos<s.length()-3) return false;//最多精确到小数点后 2 位
//计算它的值
val=0;//置为0
int i=flag?1:0;
for(;i<pos;i++)
val=val*10+s[i]-'0';
double tmp=0;//小数部分
for(int i=s.length()-1;i>pos;i--)
tmp=tmp*0.1+s[i]-'0';
tmp*=0.1;//最后需要乘以0.1
val+=tmp;
val*=flag?-1:1;//考虑负号
return (-1000.0<=val&&val<=1000.0)?true:false;
}
int main()
{
int n;
string s;
cin>>n;
int num=0;
double sum=0;
for(int i=1;i<=n;i++)
{
cin>>s;
if(isLegal(s))//合法
{
num++;
sum+=val;
}
else
cout<<"ERROR: "<<s<<" is not a legal number"<<endl;
}
if(num==0)
printf("The average of 0 numbers is Undefined\n");
else if(num==1)
printf("The average of 1 number is %.2lf\n",sum);
else
printf("The average of %d numbers is %.2lf\n",num,sum/num);
return 0;
}
1055 集体照 (25 分)
拍集体照时队形很重要，这里对给定的 N 个人 K 排的队形设计排队规则如下：
每排人数为 N/K（向下取整），多出来的人全部站在最后一排； 后排所有人的个子都不比前排任何人矮； 每排中最高者站中间（中间位置为 m/2+1，其中 m 为该排人数，除法向下取整）； 每排其他人以中间人为轴，按身高非增序，先右后左交替入队站在中间人的两侧（例如5人身高为190、188、186、175、170，则队形为175、188、190、186、170。这里假设你面对拍照者，所以你的左边是中间人的右边）； 若多人身高相同，则按名字的字典序升序排列。这里保证无重名。现给定一组拍照人，请编写程序输出他们的队形。 输入格式：
每个输入包含 1 个测试用例。每个测试用例第 1 行给出两个正整数 N（≤104，总人数）和 K（≤10，总排数）。随后 N
行，每行给出一个人的名字（不包含空格、长度不超过 8 个英文字母）和身高（[30, 300] 区间内的整数）。 输出格式：输出拍照的队形。即K排人名，其间以空格分隔，行末不得有多余空格。注意：假设你面对拍照者，后排的人输出在上方，前排输出在下方。 输入样例：
10 3 Tom 188 Mike 170 Eva 168 Tim 160 Joe 190 Ann 168 Bob 175 Nick 186
Amy 160 John 159输出样例：
Bob Tom Joe Nick Ann Mike Eva Tim Amy John
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
struct node {
string name;
int height;
};
int cmp(struct node a, struct node b) {
return a.height != b.height ? a.height > b.height: a.name < b.name;
}
int main()
{
int n, k, m;
cin >> n >> k;
vector<node> stu(n);
for (int i = 0; i < n; i++) { //输入姓名 体重
cin >> stu[i].name;
cin >> stu[i].height;
}
sort(stu.begin(), stu.end(), cmp);
int t = 0, row = k;
while (row) {
if (row == k)
m = n - n / k * (k - 1);
else
m = n / k;
vector<string> ans(m);
ans[m / 2] = stu[t].name;
// 左边一列
int j = m / 2 - 1;
for (int i = t + 1; i < t + m; i = i + 2)
ans[j--] = stu[i].name;
// 右边一列
j = m / 2 + 1;
for (int i = t + 2; i < t + m; i = i + 2)
ans[j++] = stu[i].name;
// 输出当前排
cout << ans[0];
for (int i = 1; i < m; i++)
cout << " " << ans[i];
cout << endl;
t = t + m;
row--;
}
return 0;
}
1056 组合数的和 (15 分)
给定 N 个非 0 的个位数字，用其中任意 2 个数字都可以组合成 1 个 2 位的数字。要求所有可能组合出来的 2 位数字的和。例如给定
2、5、8，则可以组合出：25、28、52、58、82、85，它们的和为330。 输入格式：输入在一行中先给出 N（1 < N < 10），随后给出 N 个不同的非 0 个位数字。数字间以空格分隔。 输出格式：
输出所有可能组合出来的2位数字的和。 输入样例：
3 2 8 5
输出样例：
330
#include<stdio.h>
#define MAX 10
int num[MAX];
int count[100] = {0};
int sum = 0;
int main()
{
int n, i, j;
scanf("%d", &n);
for(i = 0; i < n; i++) {
scanf("%d",&num[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i != j)
count[num[i] * 10 + num[j]]++;
}
}
for (i = 0; i < 100; i++) {
if (count[i] == 1) {
sum += i;
}
}
printf("%d\n", sum);
return 0;
}
1057 数零壹 (20 分)
给定一串长度不超过 105 的字符串，本题要求你将其中所有英文字母的序号（字母 a-z 对应序号 1-26，不分大小写）相加，得到整数
N，然后再分析一下 N 的二进制表示中有多少 0、多少 1。例如给定字符串 PAT
(Basic)，其字母序号之和为：16+1+20+2+1+19+9+3=71，而 71 的二进制是 1000111，即有 3 个 0、4 个
1。 输入格式：输入在一行中给出长度不超过 105、以回车结束的字符串。 输出格式：
在一行中先后输出 0 的个数和 1 的个数，其间以空格分隔。 输入样例：
PAT (Basic)
输出样例：
3 4
#include<iostream>
#include<cctype>
#include<cstring>
using namespace std;
int main(){
string s;
getline(cin,s);
int n = 0;
for(int i=0;i<s.length();i++){
if(isalpha(s[i])){
s[i] = toupper(s[i]);
n += (s[i]-'A'+1);
}
}
int cnt0 = 0,cnt1 = 0;
while(n!=0){
if(n%2==0){
cnt0++;
}else{
cnt1++;
}
n = n/2;
}
printf("%d %d",cnt0,cnt1);
return 0;
}
1058 选择题 (20 分)
批改多选题是比较麻烦的事情，本题就请你写个程序帮助老师批改多选题，并且指出哪道题错的人最多。 输入格式：
输入在第一行给出两个正整数 N（≤ 1000）和 M（≤ 100），分别是学生人数和多选题的个数。随后 M
行，每行顺次给出一道题的满分值（不超过 5 的正整数）、选项个数（不少于 2 且不超过 5
的正整数）、正确选项个数（不超过选项个数的正整数）、所有正确选项。注意每题的选项从小写英文字母 a 开始顺次排列。各项间以 1
个空格分隔。最后 N 行，每行给出一个学生的答题情况，其每题答案格式为 (选中的选项个数 选项1
……)，按题目顺序给出。注意：题目保证学生的答题情况是合法的，即不存在选中的选项数超过实际选项数的情况。 输出格式：按照输入的顺序给出每个学生的得分，每个分数占一行。注意判题时只有选择全部正确才能得到该题的分数。最后一行输出错得最多的题目的错误次数和编号（题目按照输入的顺序从
1 开始编号）。如果有并列，则按编号递增顺序输出。数字间用空格分隔，行首尾不得有多余空格。如果所有题目都没有人错，则在最后一行输出 Too
simple。 输入样例：3 4 3 4 2 a c 2 5 1 b 5 3 2 b c 1 5 4 a b d e (2 a c) (2 b d) (2 a c)
(3 a b e) (2 a c) (1 b) (2 a b) (4 a b d e) (2 b d) (1 e) (2 b c) (4 a
b c d)输出样例：
3 6 5 2 2 3 4
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<set>
using namespace std;
int main(){
int n,m,temp,k;
scanf("%d %d",&n,&m);
vector<set<char>> right(m);
vector<int> sum(m),wrongs(m);
for(int i=0;i<m;i++){
scanf("%d %d %d",&sum[i],&temp,&k);
for(int j=0;j<k;j++){
char c;
scanf(" %c",&c);
right[i].insert(c);
}
}
for(int i=0;i<n;i++){
int score = 0;
getchar();
for(int j=0;j<m;j++){
if(j!=0){
scanf(" ");
}
scanf("(%d",&k);
set<char> st;
char d;
for(int p=0;p<k;p++){
scanf(" %c",&d);
st.insert(d);
}
scanf(")");
if(st==right[j]){
score+=sum[j];
}else{
wrongs[j]++;
}
}
printf("%d\n",score);
}
int maxwrong=0;
for(int i=0;i<m;i++){
if(wrongs[i]>maxwrong){
maxwrong=wrongs[i];
}
}
if(maxwrong==0){
printf("Too simple");
}else{
printf("%d",maxwrong);
for(int i=0;i<m;i++){
if(wrongs[i]==maxwrong){
printf(" %d",i+1);
}
}
}
return 0;
}
1059 C语言竞赛 (20 分)
C 语言竞赛是浙江大学计算机学院主持的一个欢乐的竞赛。既然竞赛主旨是为了好玩，颁奖规则也就制定得很滑稽：
0、冠军将赢得一份“神秘大奖”（比如很巨大的一本学生研究论文集……）。 1、排名为素数的学生将赢得最好的奖品 —— 小黄人玩偶！ 2、其他人将得到巧克力。给定比赛的最终排名以及一系列参赛者的 ID，你要给出这些参赛者应该获得的奖品。 输入格式：
输入第一行给出一个正整数 N（≤104），是参赛者人数。随后 N 行给出最终排名，每行按排名顺序给出一位参赛者的 ID（4
位数字组成）。接下来给出一个正整数 K 以及 K 个需要查询的 ID。 输出格式：对每个要查询的 ID，在一行中输出 ID: 奖品，其中奖品或者是 Mystery Award（神秘大奖）、或者是
Minion（小黄人）、或者是 Chocolate（巧克力）。如果所查 ID 根本不在排名里，打印 Are you
kidding?（耍我呢？）。如果该 ID 已经查过了（即奖品已经领过了），打印 ID: Checked（不能多吃多占）。 输入样例：6 1111 6666 8888 1234 5555 0001 6 8888 0001 1111 2222 8888 2222
输出样例：
8888: Minion 0001: Chocolate 1111: Mystery Award 2222: Are you
kidding? 8888: Checked 2222: Are you kidding?
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
using namespace std;
bool isPrime(int n){
int flag=1;
for(int i=2;i<=(int)sqrt(n);i++){
if(n%i==0){
flag=0;
break;
}
}
return flag;
}
int main()
{
int n,k;
scanf("%d",&n);
int ary[n];
for(int i=0;i<n;i++){
scanf("%d",&ary[i]);
}
int status[n]={0};
scanf("%d",&k);
while(k--){
int temp;
int tempFlag=0;
int nFlag;
scanf("%d",&temp);
for(int i=0;i<n;i++){
if(temp==ary[i]){
tempFlag=1;
nFlag=i;
break;
}
}
if(tempFlag){
if(status[nFlag]==0){
status[nFlag]=1;
if(nFlag==0){
printf("%04d: Mystery Award\n",temp);
}else if((nFlag>=3&&isPrime(nFlag+1))||nFlag==2||nFlag==1){
printf("%04d: Minion\n",temp);
}else{
printf("%04d: Chocolate\n",temp);
}
}else{
printf("%04d: Checked\n",temp);
}
}else{
printf("%04d: Are you kidding?\n",temp);
}
}
return 0;
}
1060 爱丁顿数 (25 分)
英国天文学家爱丁顿很喜欢骑车。据说他为了炫耀自己的骑车功力，还定义了一个“爱丁顿数” E ，即满足有 E 天骑车超过 E 英里的最大整数
E。据说爱丁顿自己的 E 等于87。现给定某人 N 天的骑车距离，请你算出对应的爱丁顿数 E（≤N）。 输入格式：
输入第一行给出一个正整数 N (≤105)，即连续骑车的天数；第二行给出 N 个非负整数，代表每天的骑车距离。 输出格式：
在一行中给出 N 天的爱丁顿数。 输入样例：
10 6 7 6 9 3 10 8 2 7 8
输出样例：
6
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int a[1000001];
bool cmp(int a,int b){
return a>b;
}
int main(){
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
}
sort(a+1,a+n+1,cmp);
int ans = 0;
int p = 1;
while(ans<=n&&a[p]>p){
ans++;
p++;
}
printf("%d",ans);
return 0;
}
1061 判断题 (15 分)
判断题的评判很简单，本题就要求你写个简单的程序帮助老师判题并统计学生们判断题的得分。 输入格式：
输入在第一行给出两个不超过 100 的正整数 N 和 M，分别是学生人数和判断题数量。第二行给出 M 个不超过 5
的正整数，是每道题的满分值。第三行给出每道题对应的正确答案，0 代表“非”，1 代表“是”。随后 N
行，每行给出一个学生的解答。数字间均以空格分隔。 输出格式：按照输入的顺序输出每个学生的得分，每个分数占一行。 输入样例：
3 6 2 1 3 3 4 5 0 0 1 0 1 1 0 1 1 0 0 1 1 0 1 0 1 0 1 1 0 0 1 1
输出样例：
13 11 12
#include<cstdio>
#include<iostream>
using namespace std;
int main(){
int N,M;
int score[100] = {0};
int IsSure[100] = {0};
int result[100] = {0};
int sum = 0;
scanf("%d%d",&N,&M);
for(int i = 0;i < M;i++)
scanf("%d",&score[i]);
for(int i = 0;i < M;i++)
scanf("%d",&IsSure[i]);
for(int i = 0;i < N;i++){
for(int j = 0;j < M ;j++){
scanf("%d",&result[j]);
if(result[j] == IsSure[j]){
sum+=score[j];
}
}
printf("%d\n",sum);
sum = 0;
}
return 0;
}
1062 最简分数 (20 分)
一个分数一般写成两个整数相除的形式：N/M，其中 M 不为0。最简分数是指分子和分母没有公约数的分数表示形式。
现给定两个不相等的正分数 N1/M1 和 N2/M2，要求你按从小到大的顺序列出它们之间分母为 K 的最简分数。
输入格式：输入在一行中按 N/M 的格式给出两个正分数，随后是一个正整数分母 K，其间以空格分隔。题目保证给出的所有整数都不超过 1000。
输出格式：在一行中按 N/M 的格式列出两个给定分数之间分母为 K 的所有最简分数，按从小到大的顺序，其间以 1
个空格分隔。行首尾不得有多余空格。题目保证至少有 1 个输出。 输入样例：7/18 13/20 12
输出样例：
5/12 7/12
#include<iostream>
#include<vector>
#include<cstdio>
using namespace std;
int gcd(int a,int b){
return b==0?a:gcd(b,a%b);
}
int main()
{
vector<int> ans;
int n1,m1,n2,m2,k;
scanf("%d/%d %d/%d %d",&n1,&m1,&n2,&m2,&k);
if(n1*m2>n2*m1){
int tmpn,tmpm;
tmpn = n1;
tmpm = m1;
n1 = n2;
m1 = m2;
n2 = tmpn;
m2 = tmpm;
}
for(int i=1;i<k;i++){
if(i*m1>k*n1&&i*m2<k*n2&&gcd(k,i)==1){
ans.push_back(i);
}
}
bool flag = false;
for(int i=0;i<ans.size();i++){
if(flag){
printf(" ");
}
flag = true;
printf("%d/%d",ans[i],k);
}
return 0;
}
1063 计算谱半径 (20 分)
在数学中，矩阵的“谱半径”是指其特征值的模集合的上确界。换言之，对于给定的 n 个复数空间的特征值 {
a1+b1i,⋯,an+bni }，它们的模为实部与虚部的平方和的开方，而“谱半径”就是最大模。现在给定一些复数空间的特征值，请你计算并输出这些特征值的谱半径。 输入格式：
输入第一行给出正整数 N（≤ 10 000）是输入的特征值的个数。随后 N 行，每行给出 1
个特征值的实部和虚部，其间以空格分隔。注意：题目保证实部和虚部均为绝对值不超过 1000 的整数。 输出格式：在一行中输出谱半径，四舍五入保留小数点后 2 位。 输入样例：
5 0 1 2 0
-1 0 3 3 0 -3输出样例：
4.24
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
int main() {
int n;
scanf("%d",&n);
double s[n];
for(int i=0; i<n; ++i) {
int a,b;
scanf("%d %d",&a,&b);
s[i]=sqrt(pow(a,2)+pow(b,2));
}
sort(s,s+n);
printf("%.2lf\n",s[n-1]);
return 0;
}
1064 朋友数 (20 分)
如果两个整数各位数字的和是一样的，则被称为是“朋友数”，而那个公共的和就是它们的“朋友证号”。例如 123 和 51 就是朋友数，因为
1+2+3 = 5+1 = 6，而 6 就是它们的朋友证号。给定一些整数，要求你统计一下它们中有多少个不同的朋友证号。 输入格式：输入第一行给出正整数 N。随后一行给出 N 个正整数，数字间以空格分隔。题目保证所有数字小于 104。 输出格式：
首先第一行输出给定数字中不同的朋友证号的个数；随后一行按递增顺序输出这些朋友证号，数字间隔一个空格，且行末不得有多余空格。 输入样例：
8 123 899 51 998 27 33 36 12
输出样例：
4 3 6 9 26
#include<iostream>
#include<set>
#include<cstdio>
using namespace std;
int cal(int num){
int res = 0;
while(num){
int t = num%10;
res += t;
num = num/10;
}
return res;
}
int main()
{
int n,x;
set<int> result;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&x);
result.insert(cal(x));
}
set<int>::iterator it;
printf("%d\n",result.size());
for(it=result.begin();it!=result.end();it++){
if(it==result.begin()){
printf("%d",*it);
}else{
printf(" %d",*it);
}
}
return 0;
}
1065 单身狗 (25 分)
“单身狗”是中文对于单身人士的一种爱称。本题请你从上万人的大型派对中找出落单的客人，以便给予特殊关爱。 输入格式：
输入第一行给出一个正整数 N（≤ 50 000），是已知夫妻/伴侣的对数；随后 N 行，每行给出一对夫妻/伴侣——为方便起见，每人对应一个
ID 号，为 5 位数字（从 00000 到 99999），ID 间以空格分隔；之后给出一个正整数 M（≤ 10
000），为参加派对的总人数；随后一行给出这 M 位客人的 ID，以空格分隔。题目保证无人重婚或脚踩两条船。 输出格式：首先第一行输出落单客人的总人数；随后第二行按 ID 递增顺序列出落单的客人。ID 间用 1 个空格分隔，行的首尾不得有多余空格。 输入样例：
3 11111 22222 33333 44444 55555 66666 7 55555 44444 10000 88888 22222
11111 23333输出样例：
5 10000 23333 44444 55555 88888
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int n, m;
cin >> n;
int lover[100000] = { -1 };
int id1, id2;
for (int i = 0; i < n; i++) { // 将id1数字保存id2，反之
cin >> id1 >> id2;
lover[id1] = id2;
lover[id2] = id1;
}
cin >> m;
set<int> sigMan;
vector<int> vec;
for (int i = 0; i < m; i++) { //输入参加的人
cin >> id1;
if (lover[id1] == -1) //参加的人不在情侣范围内，直接放入set中
sigMan.insert(id1);
else
vec.push_back(id1); //是情侣，先放入vector中
}
for (int i = 0; i < vec.size(); i++) { //遍历vector，找到对应情侣
auto result = find(vec.begin(), vec.end(), lover[vec[i]]);
if (result == end(vec)) //如果情侣只有一个参加，放入set中
sigMan.insert(vec[i]);
}
cout << sigMan.size() << endl;
for (auto b = sigMan.begin(); b != sigMan.end(); b++) {
if (b != sigMan.begin())
cout << " ";
printf("%05d", *b); // 一开始使用 cout<< *b; 一个测试点不过
}
return 0;
}
1066 图像过滤 (15 分)
图像过滤是把图像中不重要的像素都染成背景色，使得重要部分被凸显出来。现给定一幅黑白图像，要求你将灰度值位于某指定区间内的所有像素颜色都用一种指定的颜色替换。
输入格式：输入在第一行给出一幅图像的分辨率，即两个正整数 M 和 N（0<M,N≤500），另外是待过滤的灰度值区间端点 A 和
B（0≤A<B≤255）、以及指定的替换灰度值。随后 M 行，每行给出 N 个像素点的灰度值，其间以空格分隔。所有灰度值都在 [0,
255] 区间内。 输出格式：输出按要求过滤后的图像。即输出 M 行，每行 N 个像素灰度值，每个灰度值占 3 位（例如黑色要显示为
000），其间以一个空格分隔。行首尾不得有多余空格。 输入样例：3 5 100 150 0 3 189 254 101 119 150 233 151 99 100 88 123 149 0 255
输出样例：
003 189 254 000 000 000 233 151 099 000 088 000 000 000 255
#include<cstdio>
#include<iostream>
using namespace std;
int main(){
int N , M;//N行M列
int A , B;//灰度值区间
int R;//替换值
int num[505][505];//存储灰度值
scanf("%d%d%d%d%d",&N,&M,&A,&B,&R);
for(int i = 0;i < N;i++){
for(int j = 0;j < M;j++){
scanf("%d",&num[i][j]);
if(num[i][j] <= B&&num[i][j] >= A)
num[i][j] = R;
printf("%03d",num[i][j]);
if(j!= M-1)
printf(" ");
}
printf("\n");
}
return 0;
}
1067 试密码 (20 分)
当你试图登录某个系统却忘了密码时，系统一般只会允许你尝试有限多次，当超出允许次数时，账号就会被锁死。本题就请你实现这个小功能。 输入格式：
输入在第一行给出一个密码（长度不超过 20 的、不包含空格、Tab、回车的非空字符串）和一个正整数 N（≤
10），分别是正确的密码和系统允许尝试的次数。随后每行给出一个以回车结束的非空字符串，是用户尝试输入的密码。输入保证至少有一次尝试。当读到一行只有单个字符时，输入结束，并且这一行不是用户的输入。 输出格式：
对用户的每个输入，如果是正确的密码且尝试次数不超过 N，则在一行中输出 Welcome in，并结束程序；如果是错误的，则在一行中按格式输出
Wrong password: 用户输入的错误密码；当错误尝试达到 N 次时，再输出一行 Account locked，并结束程序。
输入样例 1：Correct%pw 3 correct%pw Correct@PW whatisthepassword! Correct%pw
输出样例 1：
Wrong password: correct%pw Wrong password: Correct@PW Wrong password:
whatisthepassword! Account locked输入样例 2：
cool@gplt 3 coolman@gplt coollady@gplt cool@gplt try again
输出样例 2：
Wrong password: coolman@gplt Wrong password: coollady@gplt Welcome in
#include <iostream>
using namespace std;
int main() {
string s,str;
int N,sum=0,i;
cin>>s>>N;
getchar();
while(getline(cin,str)){
if(str=="#") exit(0);
for(i=0; i<s.size() && sum<N ; i++) {
if(s[i] != str[i] || s.size() !=str.size()) {
cout<<"Wrong password: "<<str<<endl;
sum++;
break;
}
}if(sum>=N) {
cout<<"Account locked";
exit(0);
}
if(i==s.size()) {
cout<<"Welcome in"<<endl;
exit(0);
}
}
return 0;
}
1068 万绿丛中一点红 (20 分)
对于计算机而言，颜色不过是像素点对应的一个 24 位的数值。现给定一幅分辨率为 M×N
的画，要求你找出万绿丛中的一点红，即有独一无二颜色的那个像素点，并且该点的颜色与其周围 8 个相邻像素的颜色差充分大。 输入格式：输入第一行给出三个正整数，分别是 M 和 N（≤ 1000），即图像的分辨率；以及 TOL，是所求像素点与相邻点的颜色差阈值，色差超过
TOL 的点才被考虑。随后 N 行，每行给出 M 个像素的颜色值，范围在 [0,224) 内。所有同行数字间用空格或 TAB 分开。
输出格式：在一行中按照 (x, y): color 的格式输出所求像素点的位置以及颜色值，其中位置 x 和 y
分别是该像素在图像矩阵中的列、行编号（从 1 开始编号）。如果这样的点不唯一，则输出 Not Unique；如果这样的点不存在，则输出
Not Exist。 输入样例 1：8 6 200 0 0 0 0 0 0 0 0 65280 65280
65280 16711479 65280 65280 65280 65280 16711479 65280
65280 65280 16711680 65280 65280 65280 65280 65280
65280 65280 65280 65280 165280 165280 65280 65280
16777015 65280 65280 165280 65480 165280 16777215 16777215
16777215 16777215 16777215 16777215 16777215 16777215输出样例 1：
(5, 3): 16711680
输入样例 2：
4 5 2 0 0 0 0 0 0 3 0 0 0 0 0 0 5 0 0 0 0 0 0
输出样例 2：
Not Unique
输入样例 3：
3 3 5 1 2 3 3 4 5 5 6 7
输出样例 3：
Not Exist
#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
using namespace std;
int graph[1005][1005] = {0};
int main()
{
map<int,int> vis;
int m,n,tol,x=-1,y=-1,cnt=0;
scanf("%d%d%d",&m,&n,&tol);
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
scanf("%d",&graph[i][j]);
vis[graph[i][j]]++;
}
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(vis[graph[i][j]]==1){
if (i - 1 >= 0 && j - 1 >= 0)//左上
{
if (abs(graph[i][j] - graph[i - 1][j - 1]) <= tol)
continue;
}
if (i - 1 >= 0) //上
{
if (abs(graph[i][j] - graph[i - 1][j]) <= tol)
continue;
}
if (i - 1 >= 0 && j + 1 < m) //右上
{
if (abs(graph[i][j] - graph[i - 1][j + 1]) <= tol)
continue;
}
if (j + 1 < m) //右
{
if (abs(graph[i][j] - graph[i][j + 1]) <= tol)
continue;
}
if (i + 1 < n && j + 1 < m)//右下
{
if (abs(graph[i][j] - graph[i + 1][j + 1]) <= tol)
continue;
}
if (i + 1 < n) //下
{
if (abs(graph[i][j] - graph[i + 1][j]) <= tol)
continue;
}
if (i + 1 < n && j - 1 >= 0)//左下
{
if (abs(graph[i][j] - graph[i + 1][j - 1]) <= tol)
continue;
}
if (j - 1 >= 0) //左
{
if (abs(graph[i][j] - graph[i][j - 1]) <= tol)
continue;
}
x = i;
y = j;
++cnt;
}
}
}
if(cnt==0){
printf("Not Exist\n");
}else if(cnt==1){
printf("(%d, %d): %d",y+1,x+1,graph[x][y]);
}else{
printf("Not Unique\n");
}
return 0;
}
1069 微博转发抽奖 (20 分)
小明 PAT 考了满分，高兴之余决定发起微博转发抽奖活动，从转发的网友中按顺序每隔 N 个人就发出一个红包。请你编写程序帮助他确定中奖名单。
输入格式：输入第一行给出三个正整数 M（≤ 1000）、N 和 S，分别是转发的总量、小明决定的中奖间隔、以及第一位中奖者的序号（编号从 1
开始）。随后 M 行，顺序给出转发微博的网友的昵称（不超过 20 个字符、不包含空格回车的非空字符串）。注意：可能有人转发多次，但不能中奖多次。所以如果处于当前中奖位置的网友已经中过奖，则跳过他顺次取下一位。 输出格式：
按照输入的顺序输出中奖名单，每个昵称占一行。如果没有人中奖，则输出 Keep going…。 输入样例 1：
9 3 2 Imgonnawin! PickMe PickMeMeMeee LookHere Imgonnawin!
TryAgainAgain TryAgainAgain Imgonnawin! TryAgainAgain输出样例 1：
PickMe Imgonnawin! TryAgainAgain
输入样例 2：
2 3 5 Imgonnawin! PickMe
输出样例 2：
Keep going…
#include <iostream>
#include <string>
using namespace std;
const int MaxM = 1005;
string names[MaxM];
bool isP[MaxM];
int ids[MaxM] = {0};
int len_ids = 0;
int main()
{
int M, N, S;
cin >> M >> N >> S;
for(int i=1; i<=M; i++)
{
cin >> names[i];
isP[i] = false;
}
for(int i=S; i<=M; i+=N)
{
while(isP[i])
{
i++;
}
isP[i] = true;
for(int j=0; j<M; j++)
{
if(names[j] == names[i])
{
isP[j] = true;
}
}
ids[len_ids] = i;
len_ids++;
}
for(int i=0; i<len_ids; i++)
{
cout<<names[ids[i]]<<endl;
}
if(len_ids==0)
{
cout<<"Keep going...";
}
return 0;
}
1070 结绳 (25 分)
给定一段一段的绳子，你需要把它们串成一条绳。每次串连的时候，是把两段绳子对折，再如下图所示套接在一起。这样得到的绳子又被当成是另一段绳子，可以再次对折去跟另一段绳子串连。每次串连后，原来两段绳子的长度就会减半。
rope.jpg
给定 N 段绳子的长度，你需要找出它们能串成的绳子的最大长度。 输入格式：
每个输入包含 1 个测试用例。每个测试用例第 1 行给出正整数 N (2≤N≤104)；第 2 行给出 N
个正整数，即原始绳段的长度，数字间以空格分隔。所有整数都不超过104。 输出格式：在一行中输出能够串成的绳子的最大长度。结果向下取整，即取为不超过最大长度的最近整数。 输入样例：
8 10 15 12 3 4 13 1 15
输出样例：
14
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int N;
double sum=0;
cin>>N;
vector<int > v(N);
for(int i=0; i<N; i++) cin>>v[i];
sort(v.begin(),v.end());
sum+=v[0];
for(int i=0; i<v.size()-1; i++) sum=sum/2.0+v[i+1]/2.0;
printf("%d",(int)sum);
return 0;
}
1071 小赌怡情 (15 分)
常言道“小赌怡情”。这是一个很简单的小游戏：首先由计算机给出第一个整数；然后玩家下注赌第二个整数将会比第一个数大还是小；玩家下注 t
个筹码后，计算机给出第二个数。若玩家猜对了，则系统奖励玩家 t 个筹码；否则扣除玩家 t 个筹码。注意：玩家下注的筹码数不能超过自己帐户上拥有的筹码数。当玩家输光了全部筹码后，游戏就结束。 输入格式：
输入在第一行给出 2 个正整数 T 和 K（≤ 100），分别是系统在初始状态下赠送给玩家的筹码数、以及需要处理的游戏次数。随后 K
行，每行对应一次游戏，顺序给出 4 个数字：n1 b t n2
其中 n1 和 n2 是计算机先后给出的两个[0, 9]内的整数，保证两个数字不相等。b 为 0 表示玩家赌小，为 1 表示玩家赌大。t
表示玩家下注的筹码数，保证在整型范围内。 输出格式：对每一次游戏，根据下列情况对应输出（其中 t 是玩家下注量，x 是玩家当前持有的筹码量）：
玩家赢，输出 Win t! Total = x.； 玩家输，输出 Lose t. Total = x.； 玩家下注超过持有的筹码量，输出 Not enough tokens. Total = x.； 玩家输光后，输出 Game Over. 并结束程序。输入样例 1：
100 4 8 0 100 2 3 1 50 1 5 1 200 6 7 0 200 8
输出样例 1：
Win 100! Total = 200. Lose 50. Total = 150. Not enough tokens.
Total = 150. Not enough tokens. Total = 150.输入样例 2：
100 4 8 0 100 2 3 1 200 1 5 1 200 6 7 0 200 8
输出样例 2：
Win 100! Total = 200. Lose 200. Total = 0. Game Over.
#include<stdio.h>
#include<string.h>
using namespace std;
typedef long long ll;
int main()
{
int T,k;
scanf("%d %d",&T,&k);
int n1,b,t,n2;
while(k--){
scanf("%d %d %d %d",&n1,&b,&t,&n2);
if(t>T&&T!=0){
printf("Not enough tokens. Total = %d.\n",T);
}
else{
if((b==0&&n2<n1)||(b==1&&n2>n1)){
T+=t;
printf("Win %d! Total = %d.\n",t,T);
}
else{
T-=t;
printf("Lose %d. Total = %d.\n",t,T);
}
if(T==0){
printf("Game Over.\n");
break;
}
}
}
return 0;
}
1072 开学寄语 (20 分)
下图是上海某校的新学期开学寄语：天将降大任于斯人也，必先删其微博，卸其 QQ，封其电脑，夺其手机，收其 ipad，断其
wifi，使其百无聊赖，然后，净面、理发、整衣，然后思过、读书、锻炼、明智、开悟、精进。而后必成大器也！jiyu.JPG
本题要求你写个程序帮助这所学校的老师检查所有学生的物品，以助其成大器。 输入格式：
输入第一行给出两个正整数 N（≤ 1000）和 M（≤ 6），分别是学生人数和需要被查缴的物品种类数。第二行给出 M
个需要被查缴的物品编号，其中编号为 4 位数字。随后 N 行，每行给出一位学生的姓名缩写（由 1-4 个大写英文字母组成）、个人物品数量
K（0 ≤ K ≤ 10）、以及 K 个物品的编号。 输出格式：顺次检查每个学生携带的物品，如果有需要被查缴的物品存在，则按以下格式输出该生的信息和其需要被查缴的物品的信息（注意行末不得有多余空格）：
姓名缩写: 物品编号1 物品编号2 ……
最后一行输出存在问题的学生的总人数和被查缴物品的总数。 输入样例：
4 2 2333 6666 CYLL 3 1234 2345 3456 U 4 9966 6666 8888 6666 GG 2 2333
7777 JJ 3 0012 6666 2333输出样例：
U: 6666 6666 GG: 2333 JJ: 6666 2333 3 5
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,m,bianhao,cnt,number,count1=0,count2=0;
map<int,int> q;
string name;
vector<int> p;
cin>>n>>m;
while(m--){
cin>>bianhao;
q[bianhao]=1;
}
while(n--){
int tag=0;
cin>>name>>cnt;
while(cnt--){
cin>>number;
if(q[number]==1){
tag=1;
count1++;
p.push_back(number);
}
}
if(tag){
int x=p.size();
count2++;
cout<<name<<":";
for(int i =0;i<p.size();i++){
printf(" %04d",p[i]);
}
printf("\n");
p.clear();
}
}
cout<<count2<<" "<<count1;
return 0;
}
1073 多选题常见计分法 (20 分)
批改多选题是比较麻烦的事情，有很多不同的计分方法。有一种最常见的计分方法是：如果考生选择了部分正确选项，并且没有选择任何错误选项，则得到
50% 分数；如果考生选择了任何一个错误的选项，则不能得分。本题就请你写个程序帮助老师批改多选题，并且指出哪道题的哪个选项错的人最多。
输入格式：输入在第一行给出两个正整数 N（≤1000）和 M（≤100），分别是学生人数和多选题的个数。随后 M
行，每行顺次给出一道题的满分值（不超过 5 的正整数）、选项个数（不少于 2 且不超过 5
的正整数）、正确选项个数（不超过选项个数的正整数）、所有正确选项。注意每题的选项从小写英文字母 a 开始顺次排列。各项间以 1
个空格分隔。最后 N 行，每行给出一个学生的答题情况，其每题答案格式为 (选中的选项个数 选项1
……)，按题目顺序给出。注意：题目保证学生的答题情况是合法的，即不存在选中的选项数超过实际选项数的情况。 输出格式：按照输入的顺序给出每个学生的得分，每个分数占一行，输出小数点后 1 位。最后输出错得最多的题目选项的信息，格式为：错误次数
题目编号（题目按照输入的顺序从1开始编号）-选项号。如果有并列，则每行一个选项，按题目编号递增顺序输出；再并列则按选项号递增顺序输出。行首尾不得有多余空格。如果所有题目都没有人错，则在最后一行输出
Too simple。 输入样例 1：3 4 3 4 2 a c 2 5 1 b 5 3 2 b c 1 5 4 a b d e (2 a c) (3 b d e) (2 a
c) (3 a b e) (2 a c) (1 b) (2 a b) (4 a b d e) (2 b d) (1 e) (1 c) (4
a b c d)输出样例 1：
3.5
6.0
2.5 2 2-e 2 3-a 2 3-b输入样例 2：
2 2 3 4 2 a c 2 5 1 b (2 a c) (1 b) (2 a c) (1 b)
输出样例 2：
5.0
5.0 Too simple
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int main() {
int n, m, optnum, truenum, temp, maxcnt = 0;
int hash[] = {1, 2, 4, 8, 16}, opt[1010][110] = {0};
char c;
scanf("%d %d", &n, &m);
vector<int> fullscore(m), trueopt(m);
vector<vector<int>> cnt(m, vector<int>(5));
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &fullscore[i], &optnum, &truenum);
for (int j = 0; j < truenum; j++) {
scanf(" %c", &c);
trueopt[i] += hash[c-'a'];
}
}
for (int i = 0; i < n; i++) {
double grade = 0;
for (int j = 0; j < m; j++) {
getchar();
scanf("(%d", &temp);
for (int k = 0; k < temp; k++) {
scanf(" %c)", &c);
opt[i][j] += hash[c-'a'];
}
int el = opt[i][j] ^ trueopt[j];
if (el) {
if ((opt[i][j] | trueopt[j]) == trueopt[j]) {
grade += fullscore[j] * 1.0 / 2;
}
if (el) {
for (int k = 0; k < 5; k++)
if (el & hash[k]) cnt[j][k]++;
}
} else {
grade += fullscore[j];
}
}
printf("%.1f\n", grade);
}
for (int i = 0; i < m; i++)
for (int j = 0; j < 5; j++)
maxcnt = maxcnt > cnt[i][j] ? maxcnt : cnt[i][j];
if (maxcnt == 0) {
printf("Too simple\n");
} else {
for (int i = 0; i < m; i++) {
for (int j = 0; j < cnt[i].size(); j++) {
if (maxcnt == cnt[i][j])
printf("%d %d-%c\n", maxcnt, i+1, 'a'+j);
}
}
}
return 0;
}
1074 宇宙无敌加法器 (20 分)
地球人习惯使用十进制数，并且默认一个数字的每一位都是十进制的。而在 PAT
星人开挂的世界里，每个数字的每一位都是不同进制的，这种神奇的数字称为“PAT数”。每个 PAT
星人都必须熟记各位数字的进制表，例如“……0527”就表示最低位是 7 进制数、第 2 位是 2 进制数、第 3 位是 5 进制数、第 4
位是 10 进制数，等等。每一位的进制 d 或者是 0（表示十进制）、或者是 [2，9]
区间内的整数。理论上这个进制表应该包含无穷多位数字，但从实际应用出发，PAT 星人通常只需要记住前 20 位就够用了，以后各位默认为 10
进制。在这样的数字系统中，即使是简单的加法运算也变得不简单。例如对应进制表“0527”，该如何计算“6203 +
415”呢？我们得首先计算最低位：3 + 5 = 8；因为最低位是 7 进制的，所以我们得到 1 和 1 个进位。第 2 位是：0 + 1
- 1（进位）= 2；因为此位是 2 进制的，所以我们得到 0 和 1 个进位。第 3 位是：2 + 4 + 1（进位）= 7；因为此位是 5 进制的，所以我们得到 2 和 1 个进位。第 4 位是：6 + 1（进位）= 7；因为此位是 10 进制的，所以我们就得到
7。最后我们得到：6203 + 415 = 7201。 输入格式：输入首先在第一行给出一个 N 位的进制表（0 < N ≤ 20），以回车结束。 随后两行，每行给出一个不超过 N 位的非负的 PAT 数。
输出格式：在一行中输出两个 PAT 数之和。 输入样例：
30527 06203 415
输出样例：
7201
#include <iostream>
#include <string>
using namespace std;
int main() {
string s, s1, s2, ans;
int carry = 0, flag = 0;
cin >> s >> s1 >> s2;
ans = s;
s1.insert(s1.begin(), s.length() - s1.length(), '0');
s2.insert(s2.begin(), s.length() - s2.length(), '0');
for (int i = s.length() - 1; i >= 0; i--) {
int mod = s[i] == '0' ? 10 : (s[i] - '0');
ans[i] = (s1[i] - '0' + s2[i] - '0' + carry) % mod + '0';
carry = (s1[i] - '0' + s2[i] - '0' + carry) / mod;
}
if (carry != 0) ans = '1' + ans;
for (int i = 0; i < ans.size(); i++) {
if (ans[i] != '0' || flag == 1) {
flag = 1;
cout << ans[i];
}
}
if (flag == 0) cout << 0;
return 0;
}
1075 链表元素分类 (25 分)
给定一个单链表，请编写程序将链表元素进行分类排列，使得所有负值元素都排在非负值元素的前面，而 [0, K] 区间内的元素都排在大于 K
的元素前面。但每一类内部元素的顺序是不能改变的。例如：给定链表为 18→7→-4→0→5→-6→10→11→-2，K 为 10，则输出应该为
-4→-6→-2→7→0→5→10→18→11。 输入格式：每个输入包含一个测试用例。每个测试用例第 1 行给出：第 1 个结点的地址；结点总个数，即正整数N (≤105)；以及正整数K
(≤103)。结点的地址是 5 位非负整数，NULL 地址用 −1 表示。接下来有 N 行，每行格式为：
Address Data Next
其中 Address 是结点地址；Data 是该结点保存的数据，为 [−105,105] 区间内的整数；Next
是下一结点的地址。题目保证给出的链表不为空。 输出格式：对每个测试用例，按链表从头到尾的顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。 输入样例：
00100 9 10 23333 10 27777 00000 0 99999 00100 18 12309 68237 -6 23333
33218 -4 00000 48652 -2 -1 99999 5 68237 27777 11 48652 12309 7 33218输出样例：
33218 -4 68237 68237 -6 48652 48652 -2 12309 12309 7 00000 00000 0
99999 99999 5 23333 23333 10 00100 00100 18 27777 27777 11 -1
#include<iostream>
#include<vector>
using namespace std;
struct node{
int data,next;
}list[100000];
vector<int> v[3];
int main()
{
int start,n,k,a;
scanf("%d%d%d",&start,&n,&k);
for(int i=0;i<n;i++){
scanf("%d",&a);
scanf("%d%d",&list[a].data,&list[a].next);
}
int p = start;
while(p!=-1){
int data = list[p].data;
if(data<0){
v[0].push_back(p);
}
else if(data>=0&&data<=k){
v[1].push_back(p);
}
else{
v[2].push_back(p);
}
p=list[p].next;
}
int flag = 0;
for(int i = 0;i < 3;i++){
for(int j = 0;j < v[i].size();j++){
if(flag==0){
printf("%05d %d ",v[i][j],list[v[i][j]].data);
flag = 1;
}else{
printf("%05d\n%05d %d ",v[i][j],v[i][j],list[v[i][j]].data);
}
}
}
printf("-1");
return 0;
}
1076 Wifi密码 (15 分)
下面是微博上流传的一张照片：“各位亲爱的同学们，鉴于大家有时需要使用 wifi，又怕耽误亲们的学习，现将 wifi
密码设置为下列数学题答案：A-1；B-2；C-3；D-4；请同学们自己作答，每两日一换。谢谢合作！！~”——
老师们为了促进学生学习也是拼了…… 本题就要求你写程序把一系列题目的答案按照卷子上给出的对应关系翻译成 wifi
的密码。这里简单假设每道选择题都有 4 个选项，有且只有 1 个正确答案。wifi.jpg 输入格式：
输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行按照 编号-答案 的格式给出一道题的 4 个选项，T 表示正确选项，F
表示错误选项。选项间用空格分隔。 输出格式：在一行中输出 wifi 密码。 输入样例：
8 A-T B-F C-F D-F C-T B-F A-F D-F A-F D-F C-F B-T B-T A-F C-F D-F B-F
D-T A-F C-F A-T C-F B-F D-F D-T B-F C-F A-F C-T A-F B-F D-F输出样例：
13224143
#include<iostream>
using namespace std;
int main()
{
int n;
scanf("%d",&n);
while(n--)
{
char c1,c2;
for(int i=1;i<=4;i++)
{
scanf(" %c-%c",&c1,&c2);
if(c2=='T')
{if(c1=='A') printf("1");
else if(c1=='B') printf("2");
else if(c1=='C') printf("3");
else if(c1=='D') printf("4");
}
}
}
return 0;
}
1077 互评成绩计算 (20 分)
在浙大的计算机专业课中，经常有互评分组报告这个环节。一个组上台介绍自己的工作，其他组在台下为其表现评分。最后这个组的互评成绩是这样计算的：所有其他组的评分中，去掉一个最高分和一个最低分，剩下的分数取平均分记为
G1；老师给这个组的评分记为 G2。该组得分为
(G1+G2)/2，最后结果四舍五入后保留整数分。本题就要求你写个程序帮助老师计算每个组的互评成绩。 输入格式：输入第一行给出两个正整数 N（> 3）和 M，分别是分组数和满分，均不超过 100。随后 N 行，每行给出该组得到的 N
个分数（均保证为整型范围内的整数），其中第 1 个是老师给出的评分，后面 N−1 个是其他组给的评分。合法的输入应该是 [0,M]
区间内的整数，若不在合法区间内，则该分数须被忽略。题目保证老师的评分都是合法的，并且每个组至少会有 3 个来自同学的合法评分。 输出格式：为每个组输出其最终得分。每个得分占一行。 输入样例：
6 50 42 49 49 35 38 41 36 51 50 28 -1 30 40 36 41 33 47 49 30 250 -25
27 45 31 48 0 0 50 50 1234 43 41 36 29 42 29输出样例：
42 33 41 31 37 39
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int g1, g2 = 0, temp, nMax = -1, nMin = m+1, cnt = -2;
cin >> g1;
for (int j = 0; j < n - 1; j++) {
cin >> temp;
if (0 <= temp && temp <= m) {
if (temp > nMax) nMax = temp;
if (temp < nMin) nMin = temp;
g2 += temp;
cnt++;
}
}
cout << int((((g2 - nMin - nMax) * 1.0 / cnt) + g1) / 2 + 0.5) << endl;
}
return 0;
}
1078 字符串压缩与解压 (20 分)
文本压缩有很多种方法，这里我们只考虑最简单的一种：把由相同字符组成的一个连续的片段用这个字符和片段中含有这个字符的个数来表示。例如
ccccc 就用 5c 来表示。如果字符没有重复，就原样输出。例如 aba 压缩后仍然是 aba。解压方法就是反过来，把形如 5c 这样的表示恢复为 ccccc。
本题需要你根据压缩或解压的要求，对给定字符串进行处理。这里我们简单地假设原始字符串是完全由英文字母和空格组成的非空字符串。 输入格式：
输入第一行给出一个字符，如果是 C 就表示下面的字符串需要被压缩；如果是 D
就表示下面的字符串需要被解压。第二行给出需要被压缩或解压的不超过 1000
个字符的字符串，以回车结尾。题目保证字符重复个数在整型范围内，且输出文件不超过 1MB。 输出格式：根据要求压缩或解压字符串，并在一行中输出结果。 输入样例 1：
C TTTTThhiiiis isssss a tesssst CAaaa as
输出样例 1：
5T2h4is i5s a3 te4st CA3a as
输入样例 2：
D 5T2h4is i5s a3 te4st CA3a as10Z
输出样例 2：
TTTTThhiiiis isssss a tesssst CAaaa asZZZZZZZZZZ
#include <iostream>
#include <string>
using namespace std;
int main() {
char c;
cin >> c;
getchar();
string s, num;
getline(cin, s);
int cnt = 1;
if (c == 'D') {
for (int i = 0; i < s.length(); i++) {
if (s[i] >= '0' && s[i] <= '9')
num += s[i];
else {
if (num.length() > 0)
cnt = stoi(num);
while (cnt--)
cout << s[i];
cnt = 1;
num = "";
}
}
}
else if (c == 'C') {
char pre = s[0];
for (int i = 1; i < s.length(); i++) {
if (s[i] == pre)
cnt++;
else {
if (cnt >= 2)
cout << cnt;
cout << pre;
cnt = 1;
pre = s[i];
}
}
if (cnt >= 2)
cout << cnt;
cout << pre;
}
return 0;
}
1079 延迟的回文数 (20 分)
给定一个 k+1 位的正整数 N，写成 ak⋯a1a0 的形式，其中对所有 i 有 0≤ai<10 且
ak>0。N 被称为一个回文数，当且仅当对所有 i 有 ai=ak−i。零也被定义为一个回文数。非回文数也可以通过一系列操作变出回文数。首先将该数字逆转，再将逆转数与该数相加，如果和还不是一个回文数，就重复这个逆转再相加的操作，直到一个回文数出现。如果一个非回文数可以变出回文数，就称这个数为延迟的回文数。（定义翻译自
https://en.wikipedia.org/wiki/Palindromic_number ）给定任意一个正整数，本题要求你找到其变出的那个回文数。 输入格式：
输入在一行中给出一个不超过1000位的正整数。 输出格式：
对给定的整数，一行一行输出其变出回文数的过程。每行格式如下
A + B = C
其中 A 是原始的数字，B 是 A 的逆转数，C 是它们的和。A 从输入的整数开始。重复操作直到 C 在 10
步以内变成回文数，这时在一行中输出 C is a palindromic number.；或者如果 10
步都没能得到回文数，最后就在一行中输出 Not found in 10 iterations.。 输入样例 1：97152
输出样例 1：
97152 + 25179 = 122331 122331 + 133221 = 255552 255552 is a
palindromic number.输入样例 2：
196
输出样例 2：
196 + 691 = 887 887 + 788 = 1675 1675 + 5761 = 7436 7436 + 6347 =
13783 13783 + 38731 = 52514 52514 + 41525 = 94039 94039 + 93049 =
187088 187088 + 880781 = 1067869 1067869 + 9687601 = 10755470 10755470
- 07455701 = 18211171 Not found in 10 iterations.
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
string Add(string A, string B); //字符串形式加和
bool isPalindromic(string C); //判断是否为回文数
int main() {
string A, B, C;
cin >> A;
if (isPalindromic(A)) { cout << A << " is a palindromic number."; return 0; } //开始即为回文数
int cnt = 10;
bool flag = false;
while (cnt--) { //仅限十步
B = A;
reverse(B.begin(), B.end()); //得到原始数的逆转数
C = Add(A, B);
cout << A << " + " << B << " = " << C << endl; //结果为回文数则结束
if (isPalindromic(C)) { cout << C << " is a palindromic number."; flag = true; break; }
A = C; //继续操作
}
if (flag == false) cout << "Not found in 10 iterations."; //十步内未找到回文数
return 0;
}
string Add(string A, string B) {
string C;
int i = A.size() - 1;
int Bas = 0, Adv = 0;
while (i >= 0) {
Bas = (A[i] - '0') + (B[i] - '0'); //当前位所得值
C += (Adv + Bas) % 10 + '0'; //当前位终值
Adv = (Adv + Bas) / 10; //进位值
--i;
}
if (Adv) C += (Adv + '0'); //若最后仍有进位值
reverse(C.begin(), C.end()); //逆转得到两数和
return C;
}
bool isPalindromic(string C) {
int Len = C.size(), i;
bool flag = true;
for (i = 0; i < Len / 2; i++) if (C[i] != C[Len - 1 - i]) flag = false;
return flag;
}
1080 MOOC期终成绩 (25 分)
对于在中国大学MOOC（http://www.icourse163.org/
）学习“数据结构”课程的学生，想要获得一张合格证书，必须首先获得不少于200分的在线编程作业分，然后总评获得不少于60分（满分100）。总评成绩的计算公式为
G=(Gmid−term×40%+Gfinal×60%)，如果 Gmid−term>Gfinal；否则总评 G 就是
Gfinal。这里 Gmid−term 和 Gfinal 分别为学生的期中和期末成绩。现在的问题是，每次考试都产生一张独立的成绩单。本题就请你编写程序，把不同的成绩单合为一张。 输入格式：
输入在第一行给出3个整数，分别是
P（做了在线编程作业的学生数）、M（参加了期中考试的学生数）、N（参加了期末考试的学生数）。每个数都不超过10000。接下来有三块输入。第一块包含 P 个在线编程成绩 Gp；第二块包含 M 个期中考试成绩 Gmid−term；第三块包含 N
个期末考试成绩 Gfinal。每个成绩占一行，格式为：学生学号
分数。其中学生学号为不超过20个字符的英文字母和数字；分数是非负整数（编程总分最高为900分，期中和期末的最高分为100分）。 输出格式：打印出获得合格证书的学生名单。每个学生占一行，格式为：
学生学号 Gp Gmid−term Gfinal G
如果有的成绩不存在（例如某人没参加期中考试），则在相应的位置输出“−1”。输出顺序为按照总评分数（四舍五入精确到整数）递减。若有并列，则按学号递增。题目保证学号没有重复，且至少存在1个合格的学生。
输入样例：6 6 7 01234 880 a1903 199 ydjh2 200 wehu8 300 dx86w 220 missing 400
ydhfu77 99 wehu8 55 ydjh2 98 dx86w 88 a1903 86 01234 39 ydhfu77 88
a1903 66 01234 58 wehu8 84 ydjh2 82 missing 99 dx86w 81输出样例：
missing 400 -1 99 99 ydjh2 200 98 82 88 dx86w 220 88 81 84 wehu8 300
55 84 84
#include<iostream>
#include<map>
#include<algorithm>
using namespace std;
struct test{
string name;
int gradep,gradem,gradef,grade;
test(){
gradem=gradef=grade=-1;
}
}a[30001];
bool cmp(test a,test b){
if(a.grade==b.grade) return a.name<b.name;
return a.grade>b.grade;
}
int main()
{
int p,m,n,no=0;
cin>>p>>m>>n;
string name;
int score;
map<string,int> q;
for(int i=0;i<p;i++){
cin>>name>>score;
if(score>=200&&score<=900){
if(!q[name]) q[name]=++no,a[no].name=name;
a[q[name]].gradep=score;
}
}
for(int i=0;i<m;i++){
cin>>name>>score;
if(q[name]&&score>=0&&score<=100){
a[q[name]].gradem=score;
}
}
for(int i=0;i<n;i++){
cin>>name>>score;
if(q[name]&&score>=0&&score<=100){
a[q[name]].gradef=score;
if(a[q[name]].gradem<=a[q[name]].gradef)
a[q[name]].grade=a[q[name]].gradef;
else a[q[name]].grade=(int)(a[q[name]].gradef*0.6+a[q[name]].gradem*0.4+0.5);
}
}
sort(a+1,a+no+1,cmp);
for(int i=1;i<=no;i++){
if(a[i].grade<60)break;
cout<<a[i].name<<" "<<a[i].gradep<<" "<<a[i].gradem<<" "<<a[i].gradef<<" "<<a[i].grade<<endl;
}
return 0;
}
1081 检查密码 (15 分)
本题要求你帮助某网站的用户注册模块写一个密码合法性检查的小功能。该网站要求用户设置的密码必须由不少于6个字符组成，并且只能有英文字母、数字和小数点
.，还必须既有字母也有数字。 输入格式：输入第一行给出一个正整数 N（≤ 100），随后 N 行，每行给出一个用户设置的密码，为不超过 80 个字符的非空字符串，以回车结束。
输出格式：对每个用户的密码，在一行中输出系统反馈信息，分以下5种：
如果密码合法，输出Your password is wan mei.； 如果密码太短，不论合法与否，都输出Your password is tai duan le.； 如果密码长度合法，但存在不合法字符，则输出Your password is tai luan le.； 如果密码长度合法，但只有字母没有数字，则输出Your password needs shu zi.； 如果密码长度合法，但只有数字没有字母，则输出Your password needs zi mu.。输入样例：
5 123s zheshi.wodepw
1234.5678 WanMei23333 pass*word.6输出样例：
Your password is tai duan le. Your password needs shu zi. Your
password needs zi mu. Your password is wan mei. Your password is tai
luan le.
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int main() {
int n;
cin >> n;
getchar();
for (int i = 0; i < n; i++) {
string s;
getline(cin, s);
if (s.length() < 6)
printf("Your password is tai duan le.\n");
else {
int c[3] = { 0 };
for (int j = 0; j < s.length(); j++) {
if (s[j] != '.' && !isalnum(s[j]))
c[0] = 1;
else if (isalpha(s[j]))
c[1]++;
else if (isdigit(s[j]))
c[2]++;
}
if (c[0] == 1)
printf("Your password is tai luan le.\n");
else if (c[1] == 0)
printf("Your password needs zi mu.\n");
else if (c[2] == 0)
printf("Your password needs shu zi.\n");
else
printf("Your password is wan mei.\n");
}
}
return 0;
}
1082 射击比赛 (20 分)
本题目给出的射击比赛的规则非常简单，谁打的弹洞距离靶心最近，谁就是冠军；谁差得最远，谁就是菜鸟。本题给出一系列弹洞的平面坐标(x,y)，请你编写程序找出冠军和菜鸟。我们假设靶心在原点(0,0)。
输入格式：输入在第一行中给出一个正整数 N（≤ 10 000）。随后 N 行，每行按下列格式给出：
ID x y
其中 ID 是运动员的编号（由 4 位数字组成）；x 和 y 是其打出的弹洞的平面坐标(x,y)，均为整数，且 0 ≤ |x|, |y| ≤
100。题目保证每个运动员的编号不重复，且每人只打 1 枪。 输出格式：输出冠军和菜鸟的编号，中间空 1 格。题目保证他们是唯一的。 输入样例：
3 0001 5 7 1020 -1 3 0233 0 -1
输出样例：
0233 0001
#include <iostream>
using namespace std;
int main() {
int n, nTop = 10001, nTopAdd = 0, nLow = -1, nLowAdd = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int id, x, y;
cin >> id >> x >> y;
int dis = x * x + y * y;
if (dis <= nTop) {
nTopAdd = id;
nTop = dis;
}
if (dis > nLow) {
nLowAdd = id;
nLow = dis;
}
}
printf("%04d %04d", nTopAdd, nLowAdd);
return 0;
}
1083 是否存在相等的差 (20 分)
给定 N 张卡片，正面分别写上 1、2、……、N，然后全部翻面，洗牌，在背面分别写上
1、2、……、N。将每张牌的正反两面数字相减（大减小），得到 N 个非负差值，其中是否存在相等的差？ 输入格式：输入第一行给出一个正整数 N（2 ≤ N ≤ 10 000），随后一行给出 1 到 N 的一个洗牌后的排列，第 i 个数表示正面写了 i
的那张卡片背面的数字。 输出格式：按照“差值 重复次数”的格式从大到小输出重复的差值及其重复的次数，每行输出一个结果。 输入样例：
8 3 5 8 6 2 1 4 7
输出样例：
5 2 3 3 2 2
#include<iostream>
using namespace std;
int main()
{
int i,j,n,k;
int a[10001],book[10001]={0};//注意book的容量不是10！
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=1;i<=n;i++)
{
int delta=a[i]>i?a[i]-i:i-a[i];
book[delta]++;
}
for(int i=10000;i>=0;i--)
if(book[i]>1)
cout<<i<<' '<<book[i]<<endl;
return 0;
}
1084 外观数列 (20 分)
外观数列是指具有以下特点的整数序列：
d, d1, d111, d113, d11231, d112213111, …
它从不等于 1 的数字 d 开始，序列的第 n+1 项是对第 n 项的描述。比如第 2 项表示第 1 项有 1 个 d，所以就是 d1；第
2 项是 1 个 d（对应 d1）和 1 个 1（对应 11），所以第 3 项就是 d111。又比如第 4 项是 d113，其描述就是 1
个 d，2 个 1，1 个 3，所以下一项就是 d11231。当然这个定义对 d = 1 也成立。本题要求你推算任意给定数字 d
的外观数列的第 N 项。 输入格式：输入第一行给出 [0,9] 范围内的一个整数 d、以及一个正整数 N（≤ 40），用空格分隔。 输出格式：
在一行中给出数字 d 的外观数列的第 N 项。 输入样例：
1 8
输出样例：
1123123111
#include<iostream>
using namespace std;
int main()
{
string a;
int n;
cin>>a>>n;
while(--n){
string ans;
char c=a[0];
int cnt=0;
for(int i=0;i<a.length();i++){
if(a[i]==c) cnt++;
else{
ans+=c;
ans+=cnt+'0';
c=a[i];
cnt=1;
}
}
if(cnt>0){
ans+=c;
ans+=cnt+'0';
}
a=ans;
}
cout<<a<<endl;
return 0;
}
1085 PAT单位排行 (25 分)
每次 PAT 考试结束后，考试中心都会发布一个考生单位排行榜。本题就请你实现这个功能。 输入格式：
输入第一行给出一个正整数 N（≤105），即考生人数。随后 N 行，每行按下列格式给出一个考生的信息：
准考证号 得分 学校
其中准考证号是由 6 个字符组成的字符串，其首字母表示考试的级别：B代表乙级，A代表甲级，T代表顶级；得分是 [0, 100]
区间内的整数；学校是由不超过 6 个英文字母组成的单位码（大小写无关）。注意：题目保证每个考生的准考证号是不同的。 输出格式：首先在一行中输出单位个数。随后按以下格式非降序输出单位的排行榜：
排名 学校 加权总分 考生人数
其中排名是该单位的排名（从 1 开始）；学校是全部按小写字母输出的单位码；加权总分定义为乙级总分/1.5 + 甲级总分 +
顶级总分*1.5的整数部分；考生人数是该属于单位的考生的总人数。学校首先按加权总分排行。如有并列，则应对应相同的排名，并按考生人数升序输出。如果仍然并列，则按单位码的字典序输出。 输入样例：
10 A57908 85 Au B57908 54 LanX A37487 60 au T28374 67 CMU T32486 24
hypu A66734 92 cmu B76378 71 AU A47780 45 lanx A72809 100 pku A03274
45 hypu输出样例：
5 1 cmu 192 2 1 au 192 3 3 pku 100 1 4 hypu 81 2 4 lanx 81 2
#include<stdio.h>
#include<string.h>
#include<bits/stdc++.h>
typedef struct{
char name[10];
double score;
int size;
}school;
typedef struct{
char name[10];
double score;
int score1;
int size;
}school1;
bool cmp1(school a,school b){
return strcmp(a.name,b.name)>0?true:false;
}
bool cmp(school1 a,school1 b){
if(a.score1 >b.score1)
return true;
else if(a.score1 == b.score1){
if(a.size <b.size)
return true;
else if(a.size == b.size)
return (strcmp(a.name,b.name)>0)?false:true;
else
return false;
}
else
return false;
}
school data[100001];
school1 data1[100001];
int main()
{
int N;
scanf("%d",&N);
char temp_id[10];
double score;
int len;
for(int i=0;i<N;i++){
scanf("%s %lf %s",temp_id,&score,(data+i)->name);
switch(temp_id[0]){
case 'A':
(data+i)->score=score;
break;
case 'T':
(data+i)->score=score*1.5;
break;
case 'B':
(data+i)->score=score/1.5;
}
len = strlen((data+i)->name);
for(int j=0;j<len;j++)
*((data+i)->name+j) = tolower(*((data+i)->name+j));
}
std::sort(data,data+N,cmp1);
strcpy(data1->name,data->name);
data1->score = data->score;
data1->size++;
int school_size=0;
for(int i=1;i<N;i++){
if(strcmp((data1+school_size)->name,(data+i)->name) == 0){
(data1+school_size)->score+=(data+i)->score;
(data1+school_size)->size++;
}
else{
school_size++;
strcpy((data1+school_size)->name,(data+i)->name);
(data1+school_size)->score = (data+i)->score;
(data1+school_size)->size++;
}
}
for(int i=0;i<school_size+1;i++)
(data1+i)->score1 = (int)(data1+i)->score;
std::sort(data1,data1+school_size+1,cmp);
printf("%d\n",school_size+1);
int k=1,now,sum=-100;
for(int i=0;i<school_size+1;i++){
now = data1[i].score1;
k = (now ==sum)?k:i+1;
printf("%d %s %d %d\n",k,data1[i].name,now,data1[i].size);
sum =now;
}
return 0;
}
1086 就不告诉你 (15 分)
做作业的时候，邻座的小盆友问你：“五乘以七等于多少？”你应该不失礼貌地围笑着告诉他：“五十三。”本题就要求你，对任何一对给定的正整数，倒着输出它们的乘积。
53.jpg 输入格式：
输入在第一行给出两个不超过 1000 的正整数 A 和 B，其间以空格分隔。 输出格式：
在一行中倒着输出 A 和 B 的乘积。 输入样例：
5 7
输出样例：
53
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
string sum = to_string(a*b);
reverse(sum.begin(), sum.end());
printf("%d", stoi(sum));
}
1087 有多少不同的值 (20 分)
当自然数 n 依次取 1、2、3、……、N 时，算式 ⌊n/2⌋+⌊n/3⌋+⌊n/5⌋ 有多少个不同的值？（注：⌊x⌋
为取整函数，表示不超过 x 的最大自然数，即 x 的整数部分。） 输入格式：输入给出一个正整数 N（2≤N≤104）。 输出格式：
在一行中输出题面中算式取到的不同值的个数。 输入样例：
2017
输出样例：
1480
#include <iostream>
#include <set>
using namespace std;
int main() {
int n;
cin >> n;
set<int> setNum;
for (int i = 1; i <= n; i++) {
int num = int(i / 2) + int(i / 3) + int(i / 5);
setNum.insert(num);
}
cout << setNum.size();
return 0;
}
1088 三人行 (20 分)
子曰：“三人行，必有我师焉。择其善者而从之，其不善者而改之。”
本题给定甲、乙、丙三个人的能力值关系为：甲的能力值确定是 2 位正整数；把甲的能力值的 2
个数字调换位置就是乙的能力值；甲乙两人能力差是丙的能力值的 X 倍；乙的能力值是丙的 Y
倍。请你指出谁比你强应“从之”，谁比你弱应“改之”。 输入格式：输入在一行中给出三个数，依次为：M（你自己的能力值）、X 和 Y。三个数字均为不超过 1000 的正整数。 输出格式：
在一行中首先输出甲的能力值，随后依次输出甲、乙、丙三人与你的关系：如果其比你强，输出 Cong；平等则输出 Ping；比你弱则输出
Gai。其间以 1 个空格分隔，行首尾不得有多余空格。注意：如果解不唯一，则以甲的最大解为准进行判断；如果解不存在，则输出 No Solution。 输入样例 1：
48 3 7
输出样例 1：
48 Ping Cong Gai
输入样例 2：
48 11 6
输出样例 2：
No Solution
#include <iostream>
#include <cmath>
using namespace std;
void printans(int n, double m) {
if (n == m)
printf(" Ping");
else
n > m ? printf(" Gai"): printf(" Cong");
}
int main() {
int m, x, y;
cin >> m >> x >> y;
for (int jia = 99; jia >= 10; jia--) {
int yi = (jia % 10) * 10 + jia / 10;
double bing = abs(jia - yi) * 1.0 / x; //一开始使用整型，一个测试点不过
if (bing * y == yi) {
cout<< jia;
printans(m, jia); printans(m, yi); printans(m, bing);
return 0;
}
}
cout << "No Solution";
return 0;
}
1089 狼人杀-简单版 (20 分)
以下文字摘自《灵机一动·好玩的数学》：“狼人杀”游戏分为狼人、好人两大阵营。在一局“狼人杀”游戏中，1 号玩家说：“2 号是狼人”，2
号玩家说：“3 号是好人”，3 号玩家说：“4 号是狼人”，4 号玩家说：“5 号是好人”，5 号玩家说：“4 号是好人”。已知这 5
名玩家中有 2 人扮演狼人角色，有 2 人说的不是实话，有狼人撒谎但并不是所有狼人都在撒谎。扮演狼人角色的是哪两号玩家？本题是这个问题的升级版：已知 N 名玩家中有 2 人扮演狼人角色，有 2
人说的不是实话，有狼人撒谎但并不是所有狼人都在撒谎。要求你找出扮演狼人角色的是哪几号玩家？ 输入格式：输入在第一行中给出一个正整数 N（5≤N≤100）。随后 N 行，第 i 行给出第 i
号玩家说的话（1≤i≤N），即一个玩家编号，用正号表示好人，负号表示狼人。 输出格式：如果有解，在一行中按递增顺序输出 2 个狼人的编号，其间以空格分隔，行首尾不得有多余空格。如果解不唯一，则输出最小序列解 ——
即对于两个序列 A=a[1],…,a[M] 和 B=b[1],…,b[M]，若存在 0≤k<M 使得 a[i]=b[i]
（i≤k），且 a[k+1]<b[k+1]，则称序列 A 小于序列 B。若无解则输出 No Solution。 输入样例 1：5
-2
+3
-4
+5
+4输出样例 1：
1 4
输入样例 2：
6
+6
+3
+1
-5
-2
+4输出样例 2（解不唯一）：
1 5
输入样例 3：
5
-2
-3
-4
-5
-1输出样例 3：
No Solution
#include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
// 拆分的思想是错误的 联合思想才是正确的
map<int, int>PX;
int N;
void input() {
scanf("%d", &N);
for (int i = 1, j = 0; i <= N; i++)
PX[i] = (scanf("%d", &j), j);
}
bool PDSH(int LIEP1,int lastP2) { // P1 说谎
map<int, int>TMP = PX;
TMP[LIEP1] *= -1; // 取反
// 虽然他说了谎 但他也是狼 对狼建立索引 set<>
set<int>LINK; LINK.insert(LIEP1); LINK.insert(lastP2);
if (TMP[lastP2] < 0) return false; // 如果另一只说真话的狼 说别人是狼 那么就不成立
if (TMP[LIEP1] < 0 && -TMP[LIEP1] != lastP2) return false; // 如果 改正说谎话的狼说除了另一只狼以外是 狼 则也不成立。
int HrLieCnt = 0;
//建立说谎验证索引 // 怎么判断 好人说了谎呢？ 1.好人说已知狼以外的
set<int> LP;
// 将狼的事实存入 事实箱子
LP.insert(TMP[LIEP1]);
LP.insert(TMP[lastP2]);
if (LP.count(LIEP1)) return false; // 检查事实箱子 是否出现 相反事实
if (LP.count(lastP2)) return false; // 检查事实箱子 是否出现 相反事实
LP.insert(-LIEP1);
LP.insert(-lastP2);
//DEL掉 临时狼
TMP.erase(LIEP1);
TMP.erase(lastP2);
for (map<int, int>::iterator it = TMP.begin(); it != TMP.end(); it++) {
if (LP.count(-(it->second))) { // 已经存在一个相反事实 则证明他说假话
HrLieCnt++; //已证 好人说谎
}
else { // 他说的无从证实真假
// 开始判断他说的话的真假
if (it->second < 0) {
if (LINK.count(abs(it->second))) { // 判断是否指向传入狼人
// 指向说明讲的是真话
LP.insert(it->second);
}
else {
HrLieCnt++; // 好人说谎
}
}
}
}
if (HrLieCnt != 1) return false;
return true;
}
int main() {
input();
bool flag = true;
for (int i = 1; i <= N; i++)
for (int j = i+1; j <= N; j++) {
if (PDSH(i, j) || PDSH(j,i)) {
printf("%d %d\n", i, j);
flag = false;
i = N + 10;
break;
}
}
if (flag)
printf("No Solution\n");
system("pause");
return 0;
}
1090 危险品装箱 (25 分)
集装箱运输货物时，我们必须特别小心，不能把不相容的货物装在一只箱子里。比如氧化剂绝对不能跟易燃液体同箱，否则很容易造成爆炸。
本题给定一张不相容物品的清单，需要你检查每一张集装箱货品清单，判断它们是否能装在同一只箱子里。 输入格式：
输入第一行给出两个正整数：N (≤104) 是成对的不相容物品的对数；M (≤100) 是集装箱货品清单的单数。
随后数据分两大块给出。第一块有 N 行，每行给出一对不相容的物品。第二块有 M 行，每行给出一箱货物的清单，格式如下：
K G[1] G[2] … G[K]
其中 K (≤1000) 是物品件数，G[i] 是物品的编号。简单起见，每件物品用一个 5 位数的编号代表。两个数字之间用空格分隔。
输出格式：对每箱货物清单，判断是否可以安全运输。如果没有不相容物品，则在一行中输出 Yes，否则输出 No。 输入样例：
6 3 20001 20002 20003 20004 20005 20006 20003 20001 20005 20004 20004
20006 4 00001 20004 00002 20003 5 98823 20002 20003 20006 10010 3
12345 67890 23333输出样例：
No Yes Yes
#include<stdio.h>
struct wu{
int wu1;
int wu2;
}W[20010];
int main(){
int N,M;
scanf("%d%d",&N,&M);
int c[100010]={0};
int e;
for(int i=0;i<N;i++){
int a,b;
scanf("%d%d",&a,&b);
c[a]++;
c[b]++;
W[i].wu1=a;
W[i].wu2=b;
}
for(int j=0;j<M;j++){
int K;
scanf("%d",&K);
int flag=0;
int b[100010]={0};
for(int i=0;i<K;i++){
int d;
scanf("%d",&d);
if(flag==1){
continue;
}
else if(b[d]==1){
flag=1;
continue;
}
else if(c[d]!=0){
e=c[d];
for(int i=0;i<N;i++){
if(d==W[i].wu1){
b[W[i].wu2]=1;
c[d]--;
}
else if(d==W[i].wu2){
b[W[i].wu1]=1;
c[d]--;
}
if(c[d]==0){
break;
}
}
c[d]=e;
}
}
if(flag==1){
printf("No\n");
}
else{
printf("Yes\n");
}
}
return 0;
}
1091 N-自守数 (15 分)
如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-自守数”。例如 3×922=25392，而
25392 的末尾两位正好是 92，所以 92 是一个 3-自守数。本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-自守数。 输入格式：
输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测的、不超过 1000 的正整数。 输出格式：
对每个需要检测的数字，如果它是 N-自守数就在一行中输出最小的 N 和 NK2 的值，以一个空格隔开；否则输出 No。注意题目保证
N<10。 输入样例：3 92 5 233
输出样例：
3 25392 1 25 No
#include <iostream>
#include <string>
using namespace std;
int main()
{
int n, num;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num;
bool flag = true;
for (int j = 1; j < 10; j++) {
string pro = to_string(j * num * num); // N K平方的值
string sNum = to_string(num); // num的字符型
string s = pro.substr(pro.length() - sNum.length(), sNum.length()); //得到后几位
if (s == sNum) {
cout << j << " " << pro << endl;
flag = false;
break;
}
}
if (flag)
cout << "No" << endl;
}
}
1092 最好吃的月饼 (20 分)
月饼是久负盛名的中国传统糕点之一，自唐朝以来，已经发展出几百品种。
mk.jpg
若想评比出一种“最好吃”的月饼，那势必在吃货界引发一场腥风血雨……
在这里我们用数字说话，给出全国各地各种月饼的销量，要求你从中找出销量冠军，认定为最好吃的月饼。 输入格式：输入首先给出两个正整数 N（≤1000）和 M（≤100），分别为月饼的种类数（于是默认月饼种类从 1 到 N 编号）和参与统计的城市数量。
接下来 M 行，每行给出 N 个非负整数（均不超过 1 百万），其中第 i 个整数为第 i 种月饼的销量（块）。数字间以空格分隔。
输出格式：在第一行中输出最大销量，第二行输出销量最大的月饼的种类编号。如果冠军不唯一，则按编号递增顺序输出并列冠军。数字间以 1
个空格分隔，行首尾不得有多余空格。 输入样例：5 3 1001 992 0 233 6 8 0 2018 0 2008 36 18 0 1024 4
输出样例：
2018 3 5
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m, num, max = 0;
cin >> n >> m;
vector<int> v(n);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> num;
v[j] += num;
if (v[j] > max)
max = v[j];
}
}
cout << max << endl;
bool flag = true;
for (int i = 0; i < n; i++) {
if (v[i] == max) {
printf("%s%d", flag ? "" : " ", i + 1);
flag = false;
}
}
return 0;
}
1093 字符串A+B (20 分)
给定两个字符串 A 和 B，本题要求你输出 A+B，即两个字符串的并集。要求先输出 A，再输出 B，但重复的字符必须被剔除。 输入格式：
输入在两行中分别给出 A 和 B，均为长度不超过 106的、由可见 ASCII 字符
(即码值为32~126)和空格组成的、由回车标识结束的非空字符串。 输出格式：在一行中输出题面要求的 A 和 B 的和。 输入样例：
This is a sample test to show you_How it works
输出样例：
This ampletowyu_Hrk
#include <iostream>
using namespace std;
int main() {
string s1, s2, s;
int hash[200] = {0};
getline(cin, s1);
getline(cin, s2);
s = s1 + s2;
for (int i = 0; i < s.size(); i++) {
if (hash[s[i]] == 0) cout << s[i];
hash[s[i]] = 1;
}
return 0;
}
1094 谷歌的招聘 (20 分)
2004 年 7 月，谷歌在硅谷的 101 号公路边竖立了一块巨大的广告牌（如下图）用于招聘。内容超级简单，就是一个以 .com
结尾的网址，而前面的网址是一个 10 位素数，这个素数是自然常数 e 中最早出现的 10
位连续数字。能找出这个素数的人，就可以通过访问谷歌的这个网站进入招聘流程的下一步。prime.jpg
自然常数 e 是一个著名的超越数，前面若干位写出来是这样的：e =
2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427427466391932003059921… 其中粗体标出的 10 位数就是答案。本题要求你编程解决一个更通用的问题：从任一给定的长度为 L 的数字中，找出最早出现的 K 位连续数字所组成的素数。 输入格式：
输入在第一行给出 2 个正整数，分别是 L（不超过 1000 的正整数，为数字长度）和 K（小于 10 的正整数）。接下来一行给出一个长度为
L 的正整数 N。 输出格式：在一行中输出 N 中最早出现的 K 位连续数字所组成的素数。如果这样的素数不存在，则输出
404。注意，原始数字中的前导零也计算在位数之内。例如在 200236 中找 4 位素数，0023 算是解；但第一位 2 不能被当成
0002 输出，因为在原始数字中不存在这个 2 的前导零。 输入样例 1：20 5 23654987725541023819
输出样例 1：
49877
输入样例 2：
10 3 2468024680
输出样例 2：
404
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
// 是否为素数
bool isPrime(int n) {
if (n <= 1) return false;
int sqr = int(sqrt(n * 1.0));
for (int i = 2; i <= sqr; i++)
if (n%i == 0) return false;
return true;
}
int main() {
int l, k;
cin >> l >> k;
getchar();
string s;
getline(cin, s);
for (int i = 0; i <= l - k; i++) {
string sNum = s.substr(i, k); //输出时 输出sNum
int nPrime = stoi(sNum);
if (isPrime(nPrime)) {
cout<< sNum;
return 0;
}
}
printf("404");
return 0;
}
1095 解码PAT准考证 (25 分)
PAT 准考证号由 4 部分组成：
第 1 位是级别，即 T 代表顶级；A 代表甲级；B 代表乙级； 第 2~4 位是考场编号，范围从 101 到 999； 第 5~10 位是考试日期，格式为年、月、日顺次各占 2 位； 最后 11~13 位是考生编号，范围从 000 到 999。现给定一系列考生的准考证号和他们的成绩，请你按照要求输出各种统计信息。 输入格式：
输入首先在一行中给出两个正整数 N（≤104）和 M（≤100），分别为考生人数和统计要求的个数。
接下来 N 行，每行给出一个考生的准考证号和其分数（在区间 [0,100] 内的整数），其间以空格分隔。
考生信息之后，再给出 M 行，每行给出一个统计要求，格式为：类型 指令，其中
类型 为 1 表示要求按分数非升序输出某个指定级别的考生的成绩，对应的 指令 则给出代表指定级别的字母； 类型 为 2 表示要求将某指定考场的考生人数和总分统计输出，对应的 指令 则给出指定考场的编号； 类型 为 3 表示要求将某指定日期的考生人数分考场统计输出，对应的 指令 则给出指定日期，格式与准考证上日期相同。输出格式：
对每项统计要求，首先在一行中输出 Case #: 要求，其中 # 是该项要求的编号，从 1 开始；要求
即复制输入给出的要求。随后输出相应的统计结果：类型 为 1 的指令，输出格式与输入的考生信息格式相同，即 准考证号 成绩。对于分数并列的考生，按其准考证号的字典序递增输出（题目保证无重复准考证号）； 类型 为 2 的指令，按 人数 总分 的格式输出； 类型 为 3 的指令，输出按人数非递增顺序，格式为 考场编号 总人数。若人数并列则按考场编号递增顺序输出。如果查询结果为空，则输出 NA。 输入样例：
8 4 B123180908127 99 B102180908003 86 A112180318002 98 T107150310127
62 A107180908108 100 T123180908010 78 B112160918035 88 A107180908021
98 1 A 2 107 3 180908 2 999输出样例：
Case 1: 1 A A107180908108 100 A107180908021 98 A112180318002 98 Case
2: 2 107 3 260 Case 3: 3 180908 107 2 123 2 102 1 Case 4: 2 999 NA
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;
typedef struct student {
string id;
int score;
int operator<(const student &p)
{
if (score != p.score)
return score > p.score;
else
return id < p.id;
}
}Student;
typedef struct room {
int roomno;
int stuno;
int operator<(const room &r)
{
if (stuno != r.stuno)
return stuno > r.stuno;
else
return roomno < r.roomno;
}
}Room;
int main()
{
int l, rno,command,score,date,datecount=1,index;
unsigned int i, j,n,m;
string id,s;
cin >> n >> m;
vector<Student> student[3];
map<char, int> levelindex = { {'T',0},{'A',1},{'B',2} };//每个等级在数组中的索引
map<int,int> rmcount;
map<int,int> rmtotalscore;
map<int, vector<Room>> groupbydate;
for (i = 0; i<n; ++i)
{
cin >> id >> score;
student[levelindex[id[0]]].push_back({ id,score });//根据当前考生的等级，将考生信息加入数组
rno = stoi(id.substr(1,3));//提取考场号
date = stoi(id.substr(4, 6));//提取日期
++rmcount[rno];//统计每个考场人数
rmtotalscore[rno] += score;//统计每个考场总分
for (j = 0; j < groupbydate[date].size() && groupbydate[date][j].roomno != rno; ++j);
if (j == groupbydate[date].size())
groupbydate[date].push_back({ rno,1 });
else
++groupbydate[date][j].stuno;
}
for (i = 0; i < 3; ++i)
sort(student[i].begin(), student[i].end());//对每个等级的学生排序
for (i = 0; i<m; ++i)
{
cin >> command >> s;
printf("Case %d: %d %s\n", i + 1, command, s.c_str());
if (command == 1)//指令1，按分数非升序输出某个指定级别的考生的成绩，对应的 指令 则给出代表指定级别的字母
{
index = levelindex[s[0]];
if (student[index].size() == 0)
printf("NA\n");
else
{
for (l = 0; l < student[index].size(); ++l)
printf("%s %d\n", student[index][l].id.c_str(), student[index][l].score);
}
}
else if (command == 2)//指令2，将某指定考场的考生人数和总分统计输出，对应的 指令 则给出指定考场的编号；
{
rno = stoi(s);
if (rmcount[rno] == 0)
cout << "NA" << endl;
else
printf("%d %d\n", rmcount[rno], rmtotalscore[rno]);
}
else if(command ==3)//指令3，将某指定日期的考生人数分考场统计输出，对应的 指令 则给出指定日期，格式与准考证上日期相同。
{
date = stoi(s);
if (groupbydate[date].size() == 0)
cout << "NA" << endl;
else
{
sort(groupbydate[date].begin(), groupbydate[date].end());
for (j = 0;j<groupbydate[date].size(); ++j)
printf("%d %d\n", groupbydate[date][j].roomno, groupbydate[date][j].stuno);
}
}
}
return 0;
}
*This article is not completely original, but can play the role of query. At the same time, due to the limited level of the author, I hope you excellent peer advice.*Note: this article is written for the reference appendix b students, cannot meet the requirements of class a and one of the top students
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
