PAT乙级的代码，加上注释之后直接汇总在一篇博客中，以供参考。
目录
PAT乙级
1
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,cnt=0;
cin>>n;
while(n!=1){
if(n%2==0) n/=2;
else n=(3*n+1)/2;
cnt++;
}
cout<<cnt;
return 0;
}
2
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
string num[]={"ling","yi","er","san","si",
"wu","liu","qi","ba","jiu"};
string str;
int ans=0;
cin>>str;
for(int i=0;i<str.size();i++)
ans+=str[i]-'0';
if(ans>=100)
cout<<num[ans/100]<<' '<<num[ans%100/10]<<' '<<num[ans%10];
else if(ans>=10)
cout<<num[ans/10]<<' '<<num[ans%10];
else
cout<<num[ans];
return 0;
}
3
#include<bits/stdc++.h>
using namespace std;
bool Check(string &str){ //判断函数
bool ret=true; //统一返回
int af,am,ab,Pindex,Tindex;
af=am=ab=0; //af、am、ab分别表示P之前 PT之间 T之后的a的个数
Pindex=Tindex=-1; //P和T的下标，初始化为-1，用于判定只出现一次
for(int i=0;i<str.length();i++){
switch(str[i]){
case 'P': if(Pindex==-1) Pindex=i; //如果是P判定是不是第一次出现，如果是保留下标
else ret=false; break;
case 'A': if(Pindex==-1&&Tindex==-1) af++;//如果PT都未出现，这个a出现再P之前
else if(Pindex!=-1&&Tindex==-1) am++;//如果P出现T未出现，这个a出现在P之后
else if(Pindex!=-1&&Tindex!=-1) ab++; break;//如果PT都已出现，这个a出现在T之后
case 'T': if(Tindex==-1) Tindex=i; //判断T是不是第一次出现，如果是保留下标
else ret=false; break;
default: ret=false; break; //如果有其他字符
}
}
if((af*am!=ab)||am==0) ret=false; //必须满足数量关系，由题目第三个条件可知，当中间增加一个A时，T后边线性增加一个P之前的字符串
if(Pindex>Tindex) ret=false; //保证PT出现的先后顺序
return ret;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
cin>>n; getchar();
for(int i=0;i<n;i++){
string str;
getline(cin,str);
if(Check(str)) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
}
4
#include<bits/stdc++.h>
using namespace std;
typedef struct Student{
string name,id;
int scores;
}STU;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
STU stu,max,min; //stu用于临时读取一个数据，max和min分别存放需要输出的内容
max.scores=-1;min.scores=105;
int n;
cin>>n;
for(int i=0;i<n;i++){
cin>>stu.name>>stu.id>>stu.scores;
if(stu.scores>max.scores) max=stu;
if(stu.scores<min.scores) min=stu;
}
cout<<max.name<<' '<<max.id<<endl;
cout<<min.name<<' '<<min.id<<endl;
return 0;
}
5
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int num[101]={0}; //用数组对100以内的每一个数字进行标记，初始化为0，其中0号位置用于存放数据个数
scanf("%d",&num[0]); //入读数据个数
for(int i=0;i<num[0];i++){ //循环读入
int temp;
scanf("%d",&temp);
if(num[temp]==0) num[temp]=1; //如果是第一次出现这个数，并且未被覆盖，赋值为1，如果被覆盖过即为2
while(temp!=1){ //3n+1猜想验证
if(temp%2==0) temp/=2;
else temp=(3*temp+1)/2;
if(temp<100) num[temp]=2; //验证过程中，如果这个数字在100以内，则修改标记为2表示被其他数覆盖
}
}
for(int flag=0,i=100;i>0;i--){ //flag用于控制格式，第一个不输出空格，后边的先输出空格再输出数字
if(num[i]==1) { //如果这个数的标记为1，表示出现在数组中，并且不被其他覆盖，从大到小输出
if(flag++) putchar(' ');
cout<<i;
}
}
return 0;
}
6
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,bcnt,scnt;
bcnt=scnt=0;
cin>>n;
bcnt=n/100; scnt=n%100/10; n=n%10; //分解百位 十位和个位的数字 并按照要求输出
for(int i=0;i<bcnt;i++) putchar('B');
for(int i=0;i<scnt;i++) putchar('S');
for(int i=1;i<=n;i++) putchar('0'+i);
return 0;
}
7
#include<bits/stdc++.h>
using namespace std;
#define MAXN 100005
bool P[MAXN]; //建立素数表
void getPrime(){
fill(P,P+MAXN,true);
P[0]=P[1]=false;
for(int i=2;i<MAXN;i++){
if(P[i])
for(int j=i+i;j<MAXN;j+=i)
P[j]=false;
}
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
getPrime();
int cnt=0,n;
cin>>n;
for(int i=0;i+2<=n;i++){ //遍历并计数
if(P[i]==true&&P[i+2]==true) //如果当前的数字和向后相隔两个间距的数字都是素数，进行计数
cnt++;
}
cout<<cnt;
return 0;
}
8
#include<bits/stdc++.h>
using namespace std;
//创建函数对数组某个区间内的元素进行逆置
void Reverse(int a[],int low,int high){
while(low<high){
int temp=a[low];
a[low]=a[high];
a[high]=temp;
low++;high--;
}
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,m;
cin>>n>>m; //n为数组大小，m为向右循环移动的元素个数
m%=n; //把m对n取余数，因为对数组整个长度进行循环移位，等同于不移动
int *a=(int *)malloc(sizeof(int)*n);
for(int i=0;i<n;i++)
cin>>a[i];
Reverse(a,0,n-1); //先整体逆置
Reverse(a,0,m-1); //对左边的m个进行逆置
Reverse(a,m,n-1); //对右边的剩余部分进行逆置
for(int i=0;i<n;i++){ //输出移位后的结果
if(i) putchar(' ');
cout<<a[i];
}
return 0;
}
9
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
vector<string> v;
string str;
while(cin>>str){ //读入每一个单词
v.push_back(str);
}
for(int i=v.size()-1;i>=0;i--){ //倒序输出
if(i!=v.size()-1) putchar(' ');
cout<<v[i];
}
return 0;
}
10
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int a, b, flag = 0; //a和b分别记录多项式的系数和指数，可能出现负指数
while (scanf("%d %d",&a,&b)!=EOF) { //读取测试文件直到末尾
if (b != 0) { //指数为0的即为常数项，常数项求导后为0
if (flag == 1) putchar(' '); //第一个对儿输出不需要多余的空格
printf("%d %d",a*b,b-1); //输出求导后的系数和指数
flag = 1; //修改标记，已经读入第一对儿数据
}
}
if (flag == 0) printf("0 0"); //如果没有读入过任何一个非常数项，则求导后的为0，按照格式输出
return 0;
}
11
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
long long a,b,c;
cin>>n;
for(int i=1;i<=n;i++){
cout<<"Case #"<<i<<": "; //输出头部字符
cin>>a>>b>>c;
if(a+b>c) printf("true\n"); //判断并输出
else printf("false\n");
}
return 0;
}
12
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int tag[6]={0}, answer[6]={0}; //tag用于记录每一种的个数，answer用于存放最终结果
cin>>answer[0];
for(int i=0;i<answer[0];i++){
int temp;
cin>>temp;
switch(temp%5){
case 0: if(temp%2==0){ //被5整除的情况
tag[1]++; answer[1]+=temp;
} break;
case 1: tag[2]++; //余数为1
if(tag[2]%2) answer[2]+=temp; //根据出现的次数确定系数正负
else answer[2]-=temp; break;
case 2: tag[3]++; answer[3]++; break; //余数为2
case 3: tag[4]++; answer[4]+=temp; break; //余数为3
case 4: if(temp>answer[5]){ //余数为4
tag[5]++; answer[5]=temp;
} break;
default: break;
}
}
for(int i=1;i<=5;i++){
if(i!=1) putchar(' '); //格式控制
if(tag[i]==0){ //如果不存在
putchar('N'); continue;
}
if(i==4) printf("%.1f",1.0*answer[i]/tag[4]); //第四个特殊处理
else printf("%d",answer[i]); //输出结果
}
return 0;
}
13
#include<bits/stdc++.h>
using namespace std;
#define MAXN 500000 //10000个素数，所以素数表要更大一些
bool Prime[MAXN];
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
fill(Prime,Prime+MAXN,true); //构建素数表
for(int i=2;i<MAXN;i++){
if(Prime[i])
for(int j=2*i;j<MAXN;j+=i)
Prime[j]=false;
}
int m,n,cnt=0,flag=0; //cnt用于统计第几个素数，flag用于控制格式
cin>>m>>n;
for(int i=2;cnt<n;i++){ //按照要求输出结果
if(Prime[i]){
cnt++;
if(cnt>m){
flag++;putchar(flag%10?' ':'\n');
}
if(cnt>=m) cout<<i;
}
}
return 0;
}
14
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
string str1,str2,str3,str4;
string WEEK[]={"","MON","TUE","WED","THU","FRI","SAT","SUN"};
cin>>str1>>str2>>str3>>str4;
int DAY=-1,H=-1,M=-1,i;
int len1=min(str1.size(),str2.size());
int len2=min(str3.size(),str3.size());
for(i=0;i<len1;i++){ //找到第一个代表日子的字符
if(str1[i]==str2[i]&&str1[i]>='A'&&str1[i]<='G'){ //第一个相同的代表A~G（一周七天）的字母
DAY=str1[i]-'A'+1; break;
}
}
for(i++;i<len1;i++){ //继而往后找到第二个表示小时的字符
if(str1[i]==str2[i]){ //0~9和A~N
if(str1[i]>='0'&&str1[i]<='9') {H=str1[i]-'0';break;}
if(str1[i]>='A'&&str1[i]<='N') {H=str1[i]-'A'+10;break;}
}
}
for(i=0;i<len2;i++){ //找到代表分钟数的字符
if(str3[i]==str4[i]&&isalpha(str3[i])) {M=i; break;}
}
cout<<WEEK[DAY]; //输出结果
printf(" %02d:%02d",H,M);
return 0;
}
15
#include<bits/stdc++.h>
using namespace std;
typedef struct node{
int id,D,C,sum,rank;
}STU;
bool cmp(const STU&a,const STU&b){
if(a.rank!=b.rank) return a.rank<b.rank; //先按照分类顺序排
else if(a.sum!=b.sum) return a.sum>b.sum; //同类型人 总分从高到低排
else if(a.D!=b.D) return a.D>b.D; //如果总分相同，按照德分从高到低排
else return a.id<b.id;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,L,H;
STU temp;
vector<STU> v;
cin>>n>>L>>H;
for(int i=0;i<n;i++){ //读入数据
cin>>temp.id>>temp.D>>temp.C;
if(temp.D<L||temp.C<L) continue; //如果有任何一个分数低于最低要求，视为废弃数据
if(temp.D>=H&&temp.C>=H) temp.rank=1; //如果德才都超过最高线，划定为第一类人
else if(temp.D>=H) temp.rank=2; //如果只有德过最高线，划定为第二类人
else if(temp.D>=temp.C) temp.rank=3; //如果都不过最高线，但是德分高于才分，划定为第三类人
else temp.rank=4; //剩余的为第四类人
temp.sum=temp.D+temp.C;
v.push_back(temp); //计算总分并加入排序
}
sort(v.begin(),v.end(),cmp); //排序后并按照要求输出
cout<<v.size()<<endl;
for(int i=0;i<v.size();i++)
printf("%08d %d %d\n",v[i].id,v[i].D,v[i].C);
return 0;
}
16
#include<bits/stdc++.h>
using namespace std;
int getnum(char *str,char ch){
char num[15];
int i=0;
while(*str!='\0'){ //将原有字符串中和给出字符相同的读取到num数组中
if(*str==ch)
num[i++]=ch;
str++;
}
num[i]='\0';
sscanf(num,"%d",&i); //将字符数组转化成数字并返回
return i;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
char s1[15],s2[15],ch1,ch2;
scanf("%s %c %s %c",s1,&ch1,s2,&ch2); //读取数据
printf("%d",getnum(s1,ch1)+getnum(s2,ch2)); //计算并打印结果
return 0;
}
17
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
char num[1005],*p=num; //num存放读入的第一个长数字，p工作指针，覆盖存放商
int b,temp=0; //b为除数，temp用于存放部分和
scanf("%s %d",num,&b);
for(int i=0;num[i];i++){//循环知道字符数组的结尾
temp=temp*10+num[i]-'0'; //计算部分和
num[i]='0'+temp/b; //覆盖保存商
temp%=b; //计算余数保留到下一次计算
} //余数的位数（包含第一位商0的情况）和被除数一定相同，故不用处理尾部
if(num[0]=='0'&&num[1]!='\0') p++; //如果第一位商是0并且整个结果商不是0（ 1 2的情况），从下一位非零数字开始输出
printf("%s %d",p,temp);
return 0;
}
//1号数据点 商为0
// 1 2
18
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int ans[2][4]={0},n; //记录比赛结果，0表示平，1表示锤子赢，2表示剪刀赢，3表示布赢
char jia,yi; //0号数组表示甲1号表示乙
scanf("%d\n",&n);
for(int i=0;i<n;i++){
scanf("%c %c\n",&jia,&yi);
switch(jia-yi){
case 'C'-'J':ans[0][1]++;break; //记录甲赢得情况
case 'J'-'B':ans[0][2]++;break;
case 'B'-'C':ans[0][3]++;break;
case 0: ans[0][0]++;break;//平局置用记录一次共用即可
case 'C'-'B':ans[1][3]++;break;//记录乙赢得情况
case 'J'-'C':ans[1][1]++;break;
case 'B'-'J':ans[1][2]++;break;
}
}
int temp=ans[0][1]+ans[0][2]+ans[0][3];//统计甲总次数并输出
printf("%d %d %d\n",temp,ans[0][0],n-temp-ans[0][0]);
temp=ans[1][1]+ans[1][2]+ans[1][3]; //统计乙总次数并输出
printf("%d %d %d\n",temp,ans[0][0],n-temp-ans[0][0]);
if(ans[0][3]>=ans[0][2]&&ans[0][3]>=ans[0][1]) jia='B';//如果B赢得最多
else if(ans[0][1]>=ans[0][2]) jia='C'; //如果J赢得最多
else jia='J';
if(ans[1][3]>=ans[1][2]&&ans[1][3]>=ans[1][1]) yi='B';
else if(ans[1][1]>=ans[1][2]) yi='C';
else yi='J';
printf("%c %c",jia,yi); //输出赢得最多得情况
return 0;
}
19
#include<bits/stdc++.h>
using namespace std;
bool cmp(char a,char b){ //把字符从大到小排序
return a>b;
}
void reverse(char *str){ //将数组逆置
swap(str[0],str[3]);
swap(str[1],str[2]);
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,tmp;
scanf("%d",&n);
char str[5];
while(1){
sprintf(str,"%04d",n); //将读入得数字格式化为4位字符串
sort(str,str+4,cmp); //从大到小排序
sscanf(str,"%d",&n); //获取第一个数
reverse(str); //逆置
sscanf(str,"%d",&tmp); //获取第二个数
printf("%04d - %04d = %04d\n",n,tmp,n-tmp);//输出一组结果
if(n-tmp==6174||n==tmp) break; //判断边界
n-=tmp; //处理n，准备进行下一轮
}
return 0;
}
20
#include<bits/stdc++.h>
using namespace std;
typedef struct moon{ //定义月饼结构体，数量可能为浮点类型
double num,total,price;
}MOON;
bool cmp(MOON &a,MOON &b){ //月饼按照单价从高到低排序
return a.price>b.price;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,D,cnt=0,i=0; //N为月饼种类，D为需求量，题目给出都为正整数
double sum=0.0; //总销售额，为浮点类型
scanf("%d %d",&N,&D);
MOON *p=(MOON*)malloc(sizeof(MOON)*N);
for(i=0;i<N;i++) //读取数据并计算单价
scanf("%lf",&p[i].num);
for(i=0;i<N;i++){
scanf("%lf",&p[i].total);
p[i].price=p[i].total/p[i].num;
}
sort(p,p+N,cmp); //排序
i=0;
while(i<N){ //按照单价从高到低遍历
if(cnt+p[i].num>=D){ //如果算上当前类型可以满足需求量，则统计并结束循环
sum+=p[i].price*(D-cnt);
break;
}
sum+=p[i].total; //如果算上当前类型仍然不足以满足市场需求，则全部计算在内
cnt+=p[i].num;
i++;
}
printf("%.2f",sum); //输出结果
return 0;
}
21
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int num[10]={0};
char ch;
while((ch=getchar())!='\n') //读取并统计
num[ch-'0']++;
for(int i=0;i<10;i++)
if(num[i])
printf("%d:%d\n",i,num[i]); //出现过得字符输出个数
return 0;
}
22
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int a,b,d; //根据题目，可知int不越界
vector<int> v;
scanf("%d %d %d",&a,&b,&d);
a+=b;
do{ //除留余数法进行进制转换
b=a%d;
v.push_back(b);
a/=d;
}while(a!=0);
for(int i=v.size()-1;i>=0;i--) //倒叙输出转换结果
printf("%d",v[i]);
return 0;
}
23
#include<bits/stdc++.h>
using namespace std;
void printchar(char ch,int n){
for(int i=0;i<n;i++)
putchar(ch);
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int num[10]={0},i;
for(i=0;i<10;i++)
scanf("%d",&num[i]);
i=1;
while(i<10){
if(num[i]!=0){ //把第一个不为0得数字作为第一个输出的字符
putchar('0'+i);
num[i]--;
break;
}
i++;
}
if(i==10) putchar('0'); //如果i在while中走到了10，说明全0（因为至少有一个个数非0），输出0
else
for(i=0;i<10;i++) //剩下的从小到达输出结果
printchar('0'+i,num[i]);
return 0;
}
24
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int tag=0,i=0,E; //tag表示正负，i用于读取字符，E表示指数
char str[10005]={0},ch; //数组要初始化，需要用'\0'作为边界，测试编译器有可能不会自动初始化
ch=getchar();
if(ch=='-') tag=1; //判断正负号
while(1){ //小数点和E不接收，E作为边界，用于后序接受指数
ch=getchar();
if(ch=='E') break;
if(ch!='.')
str[i++]=ch;
}
scanf("%d",&E);
if(tag==1) putchar('-'); //输出负号
if(E<0){
E=-E;
for(int i=0;i<E;i++){ //如果指数小于0，则需要提前输出E个0
if(i==0) printf("0."); //其中第一个要带小数点
else putchar('0');
}
printf("%s",str); //输出字符串中有效位
}
else{ //如果指数是正数
for(int i=0;str[i]!='\0'||i<E+1;i++){
if(i==E+1) putchar('.'); //由于指数为正，小数点后移，如果小数点出现在有效位的范围内（不在末位），则补充小数点
putchar(str[i]=='\0'?'0':str[i]); //有效位范围内输出小数点，否则补充0
}
}
return 0;
}
25
解法一
//使用数组处理的做法
#include<bits/stdc++.h>
using namespace std;
typedef struct node{
int id,data,next;
}NODE;
NODE LIST[100005];
vector<NODE> v;
void Reverse(vector<NODE> &v,int low,int high){ //对容器中low到high部分进行逆置
while(low<high){
swap(v[low],v[high]);
low++,high--;
}
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int Head,N,K;
scanf("%d %d %d",&Head,&N,&K); //读取数据
for(int i=0;i<N;i++){
int id;
scanf("%d",&id);
LIST[id].id=id;
scanf("%d %d",&LIST[id].data,&LIST[id].next);
}
while(Head!=-1){ //过滤数据，获取整个链表
v.push_back(LIST[Head]);
Head=LIST[Head].next;
}
N=v.size(); //统计链表长度
for(int i=0;i<N/K;i++)
Reverse(v,i*K,(i+1)*K-1); //每K个逆置，共逆置N/K次
for(int i=0;i<N-1;i++) //按照格式输出，最后一个特殊处理
printf("%05d %d %05d\n",v[i].id,v[i].data,v[i+1].id);
printf("%05d %d -1",v[N-1].id,v[N-1].data);
return 0;
}
解法二
//使用链表处理的做法
#include<bits/stdc++.h>
using namespace std;
typedef struct node{
int data,next;
}NODE;
NODE LIST[100005];
int KReverse(int Head,int N,int K){ //将链表每K个逆置的算法
int cnt=0,dealnum=N-N%K; //计数器和总共要处理的元素个数，dealnum
int NEWHEAD=100000; //利用一个空的头结点，方便操作
LIST[NEWHEAD].next=-1; //空的头结点初始化指针域
int p,tmphead,tmprear; //p为工作指针，tmphead为每k个的头结点指针，tmprear为每k个的尾结点指针
p=tmprear=Head,tmphead=NEWHEAD; //p初始化为第一个结点，tmprear初始化为第一个结点（逆置后的每k个的尾结点就是顺序的第一个），tmphead初始化为头结点
while(cnt<dealnum){ //处理节点
int temp=LIST[p].next; //防断链
LIST[p].next=LIST[tmphead].next; //头插代码
LIST[tmphead].next=p;
p=temp; cnt++; //勾链并计数
if(cnt%K==0){ //每k个更新一次
tmphead=tmprear; //tmphead更新为上一组的尾结点
tmprear=temp; //tmprea更新为下一组的第一个结点
}
}
if(cnt!=N) LIST[tmphead].next=tmprear; //如果还有剩余则勾链
return LIST[NEWHEAD].next; //返回新链表的头指针
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int Head,N,K,p;
scanf("%d %d %d",&Head,&N,&K); //读取数据
for(int i=0;i<N;i++){
int id;
scanf("%d",&id);
scanf("%d %d",&LIST[id].data,&LIST[id].next);
}
N=0; p=Head;
while(p!=-1){ //过滤数据，统计整个链表的元素个数
p=LIST[p].next;
N++;
}
if(N>=K) Head=KReverse(Head,N,K); //如果N>=k则需要逆置
while(LIST[Head].next!=-1){ //输出链表
printf("%05d %d %05d\n",Head,LIST[Head].data,LIST[Head].next);
Head=LIST[Head].next;
}
printf("%05d %d -1\n",Head,LIST[Head].data); //最后一个结点单独处理
return 0;
}
26
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int c1,c2;
scanf("%d%d",&c1,&c2);
c1=(int)(1.0*(c2-c1)/100+0.5); //计算秒数，+0.5再取整可以得到四舍五入的效果
printf("%02d:%02d:%02d",c1/3600,c1%3600/60,c1%60); //按照格式进行输出
return 0;
}
27
#include<bits/stdc++.h>
using namespace std;
void printchar(char ch,int n){ //打印n个ch字符的函数
for(int i=0;i<n;i++)
putchar(ch);
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
char ch;
scanf("%d %c",&n,&ch);
int cnt=(int)sqrt(1.0*(n+1)/2); //计算层数
for(int i=0;i<cnt;i++){ //先从多到少打印
printchar(' ',i);
printchar(ch,2*(cnt-i)-1);
putchar('\n');
}
for(int i=1;i<cnt;i++){ //再从少到多打印
printchar(' ',cnt-1-i);
printchar(ch,2*i+1);
putchar('\n');
}
printf("%d",n-2*cnt*cnt+1); //输出剩余个数
return 0;
}
28
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,cnt=0; //有效个数计数器
string maxname,minname; //存放要输出的名字
string maxdate="2014/09/06",mindate="1814/09/06"; //存放最大和最小生日，用于更新迭代
string lowdate="1814/09/06",highdate="2014/09/06"; //有效时间的上下限
cin>>n;
for(int i=0;i<n;i++){
string name,date;
cin>>name>>date;
if(date<lowdate||date>highdate) continue; //不合理日期跳过
if(date<maxdate){ //处理有效日期
maxdate=date;maxname=name;
}
if(date>mindate){
mindate=date;minname=name;
}
cnt++; //计数统计
}
if(cnt) //特判并输出
cout<<cnt<<' '<<maxname<<' '<<minname;
else cout<<cnt;
return 0;
}
//测试点3为有效日期为0的特判
29
#include<bits/stdc++.h>
using namespace std;
bool findch(char *str,char ch){ //再一串字符数组中寻找是否出现过ch字符（ch如果为字母，提前转为大写）
bool ret=false;
for(int i=0;str[i]!='\0'&&ret==false;i++){
if(str[i]>='a'&&str[i]<='z'){ //如果检查的字符串是字母，转化成大写进行匹配
if(str[i]==(ch+'a'-'A')) //只要匹配到相同的，返回True
ret=true;
}
else if(str[i]==ch) ret=true;
}
return ret; //如果出现过，返回真，否则返回假
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
char in[85],out[85];
map<char,bool> mp;
scanf("%s\n%s",in,out);
for(int i=0;in[i]!='\0';i++){
if(in[i]>='a'&&in[i]<='z') in[i]=in[i]-'a'+'A'; //转化为大写，进行查找
if(findch(out,in[i])==false&&mp[in[i]]==false){ //如果出现过且未输出过
putchar(in[i]); //打印并标记
mp[in[i]]=true;
}
}
return 0;
}
30
#include<bits/stdc++.h>
using namespace std;
bool cmp(int &a,int &b){
return a<b;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,p,i,j,*pt;
int result=0,temp=0; //result用于存放最终结果，temp存放临时结果，最后取最长
scanf("%d %d",&n,&p);
pt=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
scanf("%d",&pt[i]);
sort(pt,pt+n,cmp); //从小到大排序
for(i=0;i<n;i++){ //从第一个开始测试
for(j=i+result;j<n;j++){ //直接判断从已得到的长度开始，是否存在更长的完美数组
if(pt[j]<=(long long)pt[i]*p)
temp=j+1-i;
if(temp>result) result=temp;//如果存在最长的完美数组，继续往后测试是否存在更长，并更新result
else break; //如果不存在，此轮循环结束，i增加到下一个位置
}
}
printf("%d",result);
return 0;
}
31
#include<bits/stdc++.h>
using namespace std;
char z[11]={'1','0','X','9','8','7','6','5','4','3','2'};//校验位
int weight[]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2}; //权重
bool check(string &str){ //检查是否合理的函数
bool ret=true;
int i=0,sum=0;
for(i=0;i<17;i++){
if(str[i]>='0'&&str[i]<='9') //如果是数字累加计算
sum+=(str[i]-'0')*weight[i];
else{
ret=false;break; //如果前17位中出现非数字，则不合理
}
}
if(str[17]!=z[sum%11]) ret=false; //如果校验位出错，也认为不合理
return ret;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,cnt=0;
string str;
scanf("%d",&n);
for(int i=0;i<n;i++){
cin>>str;
if(check(str)==false){ //对每一个进行判定，如果不合理则输出
cnt++;
cout<<str<<endl;
}
}
if(cnt==0) cout<<"All passed";
return 0;
}
32
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,maxid,maxsore=-1; //记录做高学校的编号和分数，最高分数初始化为-1
map<int,int> mp; //用于统计不同学校的分数，第一参数为学校编号，第二个为分数
scanf("%d",&n);
for(int i=0;i<n;i++){
int id,score;
scanf("%d%d",&id,&score);
mp[id]+=score; //累加学校的分数
if(mp[id]>maxsore){ //如果有最高分出现，则更新参数
maxid=id; maxsore=mp[id];
}
}
printf("%d %d",maxid,maxsore); //输出结果
return 0;
}
33
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
char ch;
int cnt=0;
map<char,int> mp; //使用map标记是否是坏键，如果是，标记为1（不能标记为0，不然mp[]会默认添加一组键值，初始化为0）
while((ch=getchar())!='\n'){
if(ch>='A'&&ch<='Z') ch=ch-'A'+'a'; //转化为小写统计
mp[ch]=1;
}
while((ch=getchar())!='\n'){
if(ch>='A'&&ch<='Z') //大写需要特判，如果字符键和换挡键有任意一个损坏，则不可输出
if(mp[ch-'A'+'a']==1||mp['+']==1) continue;
if(mp[ch]==1) continue;
else{ //如果没坏则输出结果
putchar(ch);
cnt++;
}
}
if(cnt==0) putchar('\n'); //如果没有输出一个字符，打印空行
return 0;
}
34
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b){ //求公约数
return !b?a:gcd(b,a%b);
}
void Print_fen(ll a,ll b){ //打印分数
if(a*b==0){ //特判
printf("%s",b==0?"Inf":"0"); //如果分子是0，打印0，如果分母是0打印Inf
return;
}
bool fu=(a<0&&b>0)||(a>0&&b<0); //确定符号
a=abs(a);b=abs(b); //分子分母取绝对值
ll zheng=a/b; //如果是假分数，先计算整数部分
if(fu) printf("(-"); //如果是负数，打印括号和负号
if(zheng!=0)printf("%lld",zheng); //输出整数部分
if(a%b){ //如果有分数部分
if(zheng!=0) putchar(' '); //如果同时又整数部分和分数部分，打印空格
a%=b; //对a取余，由于通分采用辗转相除法求公约数，所以取余有助于减少循环次数
ll tmp=gcd(a,b); //计算分子分母的公约数
a/=tmp;b/=tmp; //约分并输出结果
printf("%lld/%lld",a,b); //打印结果
}
if(fu) putchar(')'); //如果是负数，补充括号
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
ll a,b,c,d;
scanf("%lld/%lld %lld/%lld",&a,&b,&c,&d); //读入两个分数的分子分母
//分别输出四种计算
Print_fen(a,b);printf(" + ");Print_fen(c,d);printf(" = ");Print_fen(a*d+b*c,b*d);putchar('\n');
Print_fen(a,b);printf(" - ");Print_fen(c,d);printf(" = ");Print_fen(a*d-b*c,b*d);putchar('\n');
Print_fen(a,b);printf(" * ");Print_fen(c,d);printf(" = ");Print_fen(a*c,b*d);putchar('\n');
Print_fen(a,b);printf(" / ");Print_fen(c,d);printf(" = ");Print_fen(a*d,b*c);putchar('\n');
return 0;
}
35
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int a[100],mid[100];
int n,i,j;
cin>>n;
for(i=0;i<n;i++) //读入初始序列
cin>>a[i];
for(i=0;i<n;i++) //读入中间序列
cin>>mid[i];
for(i=0;i<n-1;i++){ //找到中间序列中前部分已排序列的下一个元素 ，并用j记录下标
if(mid[i+1]<mid[i]){
j=i+1;break;
}
}
for(j;j<n;j++) //如果中间序列从j开始往后都与输入序列相同，则说明前面部分的有序序列是插入排序
if(a[j]!=mid[j]) break;
if(j==n){ //如果是插入排序，将j标记的元素插入到已排序列
cout<<"Insertion Sort"<<'\n'; //可以直接用sort从a开始到j标记的下一个元素进行排序，sort排序的参数左闭右开
sort(a,a+i+2);
}
else{ //如果不是插入排序就是归并排序，手动模拟，每一步排序过程，直到与中间序列匹配，再排一次并输出；
cout<<"Merge Sort"<<'\n';
int k=1,flag=1; //用k来表示归并每组的元素个数，初始为1，每次×2；flag标记是否匹配，如果匹配则不在归并排序
while(flag){
flag=0; //初始化标记
for(i=0;i<n;i++) //对中间序列进行匹配，如果不匹配，则将flag置为1，使排序继续进行一个轮次
if(a[i]!=mid[i]) { flag=1; break; }//※※※》注意》 把匹配放在前边以便于检查初始序列，而且，如果匹配得到，循环下部分还能继续一轮排序，最后可以输出
k=k*2; //分组内元素个数乘2
for(i=0;i<n/k;i++)//遍历数组，对每各组进行组归并，元素个数少，直接sort排序就行，
sort(a+i*k,a+(i+1)*k);
sort(a+n/k*k,a+n);//如果不能刚好分为整数组，会有最后一组不满足k个元素，单独对最后剩余的元素排序，n/k表示的分组个数
}
}
for(i=0;i<n;i++){ //最后输出中间序列继续一轮排序的结果
if(i) putchar(' ');
printf("%d",a[i]);
}
return 0;
}
36
#include<bits/stdc++.h>
using namespace std;
void Print_ch(char ch,int n){
for(int i=0;i<n;i++)
putchar(ch);
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int hang,lie;
char ch;
scanf("%d %c",&lie,&ch);
hang=lie%2==0?lie/2:(lie+2)/2; //如果是偶数直接除以2，如果是奇数，四舍五入取整
for(int i=0;i<hang;i++){
if(i==0||i==hang-1) //第一行和最后一行打满字符
Print_ch(ch,lie);
else{ //中间行只开头结尾打印
putchar(ch);
Print_ch(' ',lie-2);
putchar(ch);
}
putchar('\n');
}
return 0;
}
37
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
ll a,b,c,a1,b1,c1;
ll P,A;
scanf("%lld.%lld.%lld %lld.%lld.%lld",&a,&b,&c,&a1,&b1,&c1);
P=a*17*29+b*29+c; //读入并计算价格
A=a1*17*29+b1*29+c1;
if(A<P){ //判负
swap(A,P); putchar('-');
}
A-=P; //计算最后输出结果
printf("%lld.%lld.%lld",A/(17*29),A/29%17,A%29); //格式化输出
return 0;
}
38
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int cnt[101]={0}; //统计分数，百分制，数组开到101个即可
int n,score;
scanf("%d",&n); //读入n个成绩并计数
for(int i=0;i<n;i++){
scanf("%d",&score);
cnt[score]++;
}
scanf("%d",&n); //读取查询个数
for(int i=0;i<n;i++){ //查询输出，并控制格式
if(i) putchar(' ');
scanf("%d",&score);
printf("%d",cnt[score]);
}
return 0;
}
39
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
string str1,str2;
map<char,int> have,need; //统计已有的数量和需求的数量
int neednum=0,flag=1; //统计不足时候的需求量，flag表示是否可以购买
cin>>str1>>str2;
for(int i=0;i<str1.size();i++) //分别统计
have[str1[i]]++;
for(int i=0;i<str2.size();i++)
need[str2[i]]++;
for(auto it=need.begin();it!=need.end();it++){ //遍历需求
if(have[it->first]<it->second){
flag=0; neednum+=it->second-have[it->first];//如果某种颜色不足，修改标记，统计不足时候的需求量
}
}
if(flag) printf("Yes %d",str1.size()-str2.size()); //根据标记按照要求输出结果
else printf("No %d",neednum);
return 0;
}
40
#include<bits/stdc++.h>
#define NN 1000000007
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int Pcnt=0,Tcnt=0,n=0,cnt=0;
char str[100005]={0},ch;
while((ch=getchar())!='\n'){ //读入字符串，并统计T的个数
if(ch=='T') Tcnt++;
str[n++]=ch;
}
for(int i=0;i<n;i++){ //遍历字符串
switch(str[i]){
case 'P':Pcnt++;break; //统计每一个A左侧P的个数
case 'T':Tcnt--;break; //统计每一个A右侧T的个数
case 'A':cnt+=Pcnt*Tcnt; cnt%=NN;break; //根据排列组合，每一个A可以和左侧的P和右侧的T组合成一个PAT，因此计数相乘并统计累加，然后按照要求取余数
}
}
printf("%d",cnt); //输出结果
return 0;
}
41
#include<bits/stdc++.h>
using namespace std;
typedef struct student{ //学生信息结构体，准考证号和考试座位号
string id;
int num;
}STU;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
map<int,STU> mp; //建立机试座位号和学生信息的对应关系
int n,tmp;
STU temp;
scanf("%d",&n);
for(int i=0;i<n;i++){ //读入学生信息
cin>>temp.id>>tmp>>temp.num;
mp[tmp]=temp;
}
scanf("%d",&n);
for(int i=0;i<n;i++){ //按照查询输出学生信息
scanf("%d",&tmp);
cout<<mp[tmp].id<<' '<<mp[tmp].num<<endl;
}
return 0;
}
42
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int maxnum=-1,cnt[26]={0},id;
char ch;
while((ch=getchar())!='\n'){
if(isalpha(ch)==false) continue; //非字母不加入统计
if(ch>='A'&&ch<='Z') ch=ch-'A'+'a'; //转换为小写
id=ch-'a'; //映射到计数表的数组下标
cnt[id]++;
maxnum=cnt[id]>maxnum?cnt[id]:maxnum; //记录最大值
}
for(int i=0;i<26;i++) //从字母序小到大第一个出现次数最多的输出打印
if(cnt[i]==maxnum){
printf("%c %d",'a'+i,maxnum); break;
}
return 0;
}
43
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int cnt[6]={0},flag=1; //统计每种字符的个数
char ch,Table[]="PATest";
while((ch=getchar())!='\n'){
switch(ch){
case 'P':cnt[0]++;break;
case 'A':cnt[1]++;break;
case 'T':cnt[2]++;break;
case 'e':cnt[3]++;break;
case 's':cnt[4]++;break;
case 't':cnt[5]++;break;
}
}
while(flag){ //当标记为1时循环
flag=0; //初始化为0，如果还有字符剩余，修改标记为1
for(int i=0;i<6;i++){
if(cnt[i]>0){ //输出存在的字符
putchar(Table[i]);
if(cnt[i]--) flag=1; //如果字符剩余不为0，修改标记
}
}
}
return 0;
}
44
#include<bits/stdc++.h>
using namespace std;
string High[]={"","tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer", "jou"};
string Low[]={"tret","jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov", "dec"};
void MtoE(string &str){ //火星文转地球数字
int num=0;
if(str.size()<5){ //字符串小于五个的 小于13或者时13的整数倍（整数倍只有高位，没有低位的0）
for(int i=0;i<13;i++) //小于13的
if(Low[i]==str) { num=i; break; }
for(int i=0;i<13;i++) //只有高位的13的整倍数
if(High[i]==str) { num=i*13; break; }
}
else{ //字符串大于5个的，一定是有低位和高位
string high=str.substr(0,3); //取高位
string low=str.substr(4,str.size()-4); //取低位
for(int i=0;i<13;i++){ //计算结果
if(low==Low[i]) num+=i;
if(high==High[i]) num+=13*i;
}
}
printf("%d\n",num);
}
void EtoM(string &str){
int num;
sscanf(str.c_str(),"%d",&num); //字符串转为数字
if(num>=13){ //对于超过13的
cout<<High[num/13]; //输出高位
if(num%13){ putchar(' '); cout<<Low[num%13]<<endl; } //如果不是13整倍数，输出空格和低位
else putchar('\n'); //如果是整倍数，输出换行
}
else //小于13的直接输出
cout<<Low[num%13]<<endl;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
string temp;
scanf("%d\n",&n);
for(int i=0;i<n;i++){ //读入数据根据第一位判断字符是火星文，数字是地球数
getline(cin,temp);
if(isalpha(temp[0])) MtoE(temp);
else EtoM(temp);
}
return 0;
}
45
解法一
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,max=0;
cin>>n;
vector<int> a(n),b(n),out;
for(int i=0;i<n;i++){
cin>>a[i];
b[i]=a[i];
}
sort(b.begin(),b.end());
for(int i=0;i<n;i++){
if(a[i]==b[i]&&a[i]>max)
out.push_back(a[i]);
max=a[i]>max?a[i]:max;
}
cout<<out.size()<<endl;
for(int i=0;i<out.size();i++){
if(i) putchar(' ');
cout<<out[i];
}
putchar('\n'); //没有换行则会有格式错误
return 0;
}
解法二
//使用数组的方式存储，时间会节省一半
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,max=0,cnt=0;
scanf("%d",&n);
int* a=(int*)malloc(sizeof(int)*n); //a用于存储原始序列
int* b=(int*)malloc(sizeof(int)*n); //b用于存储排序后的序列
for(int i=0;i<n;i++){ //读取数据
scanf("%d",&a[i]);
b[i]=a[i];
}
sort(b,b+n); //对b进行排序
for(int i=0;i<n;i++){
if(a[i]==b[i]&&a[i]>max) //遍历原始序列，如果当前元素刚好在排好之后的位置上，且都大于左侧的值（题目中所有数据不相同，所以大于左侧，一定都小于右侧）
a[cnt++]=a[i]; //满足这样的主元要求，则进行保存，这里为了节省空间，直接把需要输出的结果覆盖更新保存在a中
max=a[i]>max?a[i]:max;
}
cout<<cnt<<endl; //输出结果
for(int i=0;i<cnt;i++){
if(i) putchar(' ');
cout<<a[i];
}
putchar('\n'); //没有换行则测试点2会有格式错误（很迷的测试点，所以建议将来所有的输出最后都多一个换行）
return 0;
}
46
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,jia,jia1,yi,yi1;
int jia_cnt=0,yi_cnt=0; //计数器
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d%d%d%d",&jia,&jia1,&yi,&yi1);
int temp=jia+yi;
if(jia1==temp&&yi1==temp) continue; //如果平局则继续下一轮
else if(jia1==temp) yi_cnt++; //如果甲赢了，乙喝酒
else if(yi1==temp) jia_cnt++; //如果乙赢了，甲喝酒
}
printf("%d %d",jia_cnt,yi_cnt); //输出结果
return 0;
}
47
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,maxid,maxscore=0;
int cnt[1001]={0}; //记录每一队得分数
scanf("%d\n",&n);
for(int i=0;i<n;i++){
int id,num,score;
scanf("%d-%d %d\n",&id,&num,&score); //读入分数
cnt[id]+=score; //统计累加
if(cnt[id]>maxscore){ //更新最高成绩和队伍编号
maxid=id; maxscore=cnt[id];
}
}
printf("%d %d",maxid,maxscore); //输出结果
return 0;
}
48
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
string strA,strB;
cin>>strA>>strB;
reverse(strA.begin(),strA.end()); //将两个字符串逆序
reverse(strB.begin(),strB.end());
int len=strB.size()-strA.size(); //对较短的字符串补充0（此题最终输出的位数为最长的字符串位数）
if(len>0) for(int i=0;i<len;i++) strA+='0';
else for(int i=0;i<-len;i++) strB+='0';
for(int i=0;i<strB.size();i++){
int tmp=0;
if((i+1)%2==1){ //奇数位处理
tmp=strA[i]-'0'+strB[i]-'0';
tmp%=13;
switch(tmp){
case 10:strB[i]='J';break;
case 11:strB[i]='Q';break;
case 12:strB[i]='K';break;
default:strB[i]='0'+tmp;break;
}
}
else{ //处理偶数位
tmp=strB[i]-strA[i];
if(tmp<0) tmp+=10;
strB[i]='0'+tmp;
}
}
reverse(strB.begin(),strB.end()); //结果逆置后输出最后结果
cout<<strB;
return 0;
}
49
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
long double sum=0.0;
long double temp;
int i,n;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%Lf",&temp); //将数列片段每组一行，统计发现每一个数字的个数规律，累加计算
sum+=temp*(n-(i-1))*i; //把temp写在前边，保证每一步的乘法都是long double运算 (更新了数据，测试点2的数值范围较大)
}
printf("%.2Lf",sum);
return 0;
}
//long double 的读入和输出都要LF才能打到要求的精度
50
#include<bits/stdc++.h>
using namespace std;
const int maxn=10010;
//坐标运动的四种模式，按照向下为x轴正向，向右为y轴正向建立坐标系
int dx[]={0,1,0,-1},dy[]={1,0,-1,0}; //0表示坐标向右移动，1表示坐标向下移动，2表示向左移动，3表示向上移动
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,a[maxn]={0};
int hang,lie; //需要输出的行数和列数
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
sort(a+1,a+1+n); //从小到大排序，然后从后往前开始遍历填充螺旋数组
lie=int(sqrt(1.0*n)); //行数和列数一定等于开方数或者分布在开方数的两侧，小的那个一是列，大的那个是行
for(int i=lie;i>=0;i--){ //计算行列数
if(n%i==0){
lie=i,hang=n/i;break;
}
}
//创建一个行数和列数都大一圈的数组空间用于填充数据，used数组用于标记某个位置是否已填充，作为坐标变换的判断边界之一
int num[hang+1][lie+1]={0},used[hang+1][lie+1]={0}; //****两个数组最好手动初始化一下，有时候编译器可能不会自动初始化，容易出错
int x=1,y=1,M=0; //坐标从（1，1）开始，第一步都是向右移动坐标，M代表移动模式
while(n){ //完成n个数据的填充
num[x][y]=a[n]; //填充当前坐标
used[x][y]=1; //更新标记
if(x+dx[M]<1||x+dx[M]>hang||y+dy[M]<1||y+dy[M]>lie||used[x+dx[M]][y+dy[M]])
M=(M+1)%4; //如果x到达最外层或者y到达最外层边界，或者填充碰到了已填充的外层，则变更坐标移动方式
x+=dx[M],y+=dy[M]; //产生下一组坐标
n--; //更新计数器
}
for(int i=1;i<=hang;i++){ //输出结果
for(int j=1;j<=lie;j++){
if(j!=1) putchar(' ');
printf("%d",num[i][j]);
}
putchar('\n');
}
return 0;
}
51
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
double r1,p1,r2,p2;
double a1,b1,a2,b2,a,b;
scanf("%lf %lf %lf %lf",&r1,&p1,&r2,&p2);
a1=r1*cos(p1);b1=r1*sin(p1); //转化成常规的负数表示方法
a2=r2*cos(p2);b2=r2*sin(p2);
a=a1*a2-b1*b2; b=a1*b2+a2*b1; //负数计算
if(a>-0.005&&a<0) a=0; //当a或者b大于-0.005的时候，比如-0.004由于四舍五入，变成-0.00，输出的仍然是负号，但是0应该输出＋，需要提前处理
if(b>-0.005&&b<0) b=0;
printf("%.2f%+.2fi",a,b); //+.2f 用于控制显示正负号，并且保留两位小数
return 0;
}
52
#include<bits/stdc++.h>
using namespace std;
const int NUM=5;
void getemoj(vector<string> &emoj){
char ch;
string str;
while(1){
ch=getchar();
if(ch=='\n') return; //读取到换行符，说明该类型的表情已经读取完毕
else if(ch=='[') str=""; //如果读到左括号，清空临时字符串，准备接受一个表情
else if(ch==']') emoj.push_back(str); //如果读到右括号，表明str中已经存储了一个表情，记录到数组中
else str+=ch; //读取的字符串累加（由于表情用括号包起来，所以多余的会被清空，这里可能直接掠过其他字符）
}
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
vector<string> emojs[3];
for(int i=0;i<3;i++) getemoj(emojs[i]); //获取表情
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){
int a,b,c,d,e;
scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);//读入数据，并判断数据的合法性
if(max(a,e)>emojs[0].size()||max(b,d)>emojs[1].size()||c>emojs[2].size()||min(a,e)<1||min(b,d)<1||c<1)
printf("Are you kidding me? @\\/@");
else //输出结果
cout<<emojs[0][a-1]<<'('<<emojs[1][b-1]<<emojs[2][c-1]<<emojs[1][d-1]<<')'<<emojs[0][e-1];
putchar('\n');
}
return 0;
}
53
#include<bits/stdc++.h>
using namespace std;
const double eps=1e-8;
#define low(a,b) ((a)-(b)<(-eps)) //浮点数比较，如果a-b的值小于某一个很小的负值，说明a在b的左侧
int N,D;
double E;
int IS_Empty(){
int ret=0,k,cnt=0; //cnt用于统计用电量低于阈值的天数
double e;
scanf("%d",&k);
for(int i=0;i<k;i++){
scanf("%lf",&e);
if(low(e,E)) cnt++; //满足条件的进行统计
}
if(cnt*2>k) ret=1; //如果满足可能空置返回1
if(k>D&&ret==1) ret=2; //如果满足空置条件返回2
return ret;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int cnt1=0,cnt2=0;
scanf("%d %lf %d",&N,&E,&D);
for(int i=0;i<N;i++){
int tag=IS_Empty();
if(tag==2) cnt2++; //根据返回值进行判定
else if(tag==1) cnt1++;
}
printf("%.1f%% %.1f%%",(100.0*cnt1)/N,(100.0*cnt2)/N); //输出结果，%的输出要注意语法
return 0;
}
54
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,cnt=0;
double temp,sum=0.0;
char a[50],b[50];
scanf("%d",&N);
for(int i=0;i<N;i++){
scanf("%s",a); //每次读取一个字符串到a
sscanf(a,"%lf",&temp); //a转化成数字
sprintf(b,"%.2f",temp); //数字转化成字符串，这里转化的字符串一定要保留成2位小数，才会是合法的字符
int tag=0,len=strlen(a); //a为原始字符串，所以比较以a长度为准，比如7.123小数位数超过要求
for(int i=0;i<len&&tag==0;i++) //比较a和b如果相同，说明这个字符串是合法格式的数字，否则不合要求，tag改为1
if(a[i]!=b[i]) tag=1;
if(tag||temp<-1000||temp>1000) //如果格式不合法，或者数据范围不合理，输出错误信息
printf("ERROR: %s is not a legal number\n",a);
else{
sum+=temp; //合法输入进行统计
cnt++;
}
}
if(cnt==1) //分类进行输出
printf("The average of 1 number is %.2f\n",sum);
else if(cnt!=0)
printf("The average of %d numbers is %.2f\n",cnt,sum/cnt);
else
printf("The average of 0 numbers is Undefined");
return 0;
}
55
#include<bits/stdc++.h>
using namespace std;
typedef struct student{
string name;
int high;
}STU;
bool cmp(STU &a,STU &b){
if(a.high!=b.high) return a.high>b.high;
else return a.name<b.name;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,K;
scanf("%d %d",&N,&K);
STU DATA[N];
for(int i=0;i<N;i++) //读入数据
cin>>DATA[i].name>>DATA[i].high;
sort(DATA,DATA+N,cmp); //按照身高从高到低排序，同身高按照名字字典序排列
vector< vector<string> > out(K); //输出的二维数组
int num=N/K; //计算每一排人数
for(int i=0;i<K;i++){ //初始化每一排数组大小
if(i==0) out[i].resize(N-(K-1)*num);//如果有剩余放在最后一排
else out[i].resize(num);
}
num=0;
for(int i=0;i<K;i++){
int cnt=out[i].size(); //获取每一排人数
int mid=cnt/2; //计算中间位置，题目中从1开始，如果这里用下标表示，则不用+1
out[i][mid]=DATA[num++].name; //放置中间位置
int l=mid,r=mid; //左右两侧的位置指针，初始化为中间位置
while(1){
l--,r++;
if(l>=0) out[i][l]=DATA[num++].name; //在合法范围内放置，先放置摄影师视角的左侧
if(r<cnt)out[i][r]=DATA[num++].name; //再放置摄影师视角的右侧
if(l<0) break; //显然左侧的人数大于等于右侧（以摄影师视角的左右侧），所以只判定左侧到达边界说明这一排站位结束
}
}
for(int i=0;i<K;i++){ //输出结果并控制格式
for(int j=0;j<out[i].size();j++){
if(j) putchar(' ');
cout<<out[i][j];
}
putchar('\n');
}
return 0;
}
56
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,num[10]={0},sum=0;
scanf("%d",&N);
for(int i=0;i<N;i++) //读入数据
scanf("%d",&num[i]);
for(int i=0;i<N;i++){
for(int j=i+1;j<N;j++){ //每两个数字进行组合
sum+=num[i]*10+num[j]; //ab 和 ba两个组合形式都进行累加
sum+=num[j]*10+num[i];
}
}
printf("%d",sum);
return 0;
}
57
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int num=0,cnt1=0,cnt0=0;
char ch;
while((ch=getchar())!='\n'){ //累加每一个字母的数值
if(ch>='a'&&ch<='z') num+=ch-'a'+1;
else if(ch>='A'&&ch<='Z') num+=ch-'A'+1;
}
if(num) //当有字符串存在时，进行进制转换
do{
if(num%2==0) cnt0++; //如果有一位是0
else cnt1++; //如果有一位是1
num/=2;
}while(num);
printf("%d %d",cnt0,cnt1); //输出统计出的0和1的个数
return 0;
}
58
#include<bits/stdc++.h>
using namespace std;
typedef struct question{ //问题结构体，采用一个五位整数记录正确答案，比如选a则是10000，ab为11000，ac为10100
int score,ans,cnt=0; //因为没有不合理答案，所以可以统一认为所有的都是五个选项，没有的那一位就是0，不妨碍判定
}QU;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,M,maxerror=0;
scanf("%d %d\n",&N,&M); //使用scanf的格式参数控制过滤多余的字符
vector<QU> v(M+1);
for(int i=1;i<=M;i++){
int score,num,right;
char ch;
scanf("%d %d %d",&score,&num,&right);
v[i].score=score,v[i].ans=0; //初始化并读入每一个题目的成绩和答案
while((ch=getchar())!='\n'){
switch(ch){ //ans累加每一个答案的权值，构成一个整数代表正确答案
case 'a':v[i].ans+=10000;break;
case 'b':v[i].ans+=1000;break;
case 'c':v[i].ans+=100;break;
case 'd':v[i].ans+=10;break;
case 'e':v[i].ans+=1;break;
}
}
}
for(int i=0;i<N;i++){
int sum=0,id=0,score=0; //用于比对答案的sum，题目标号计数器id，当前学生成绩累加score
char ch;
while((ch=getchar())!='\n'){ //对于每一组学生回答的答案，进行判定
switch(ch){ //先处理每一个答案位
case 'a':sum+=10000;break;
case 'b':sum+=1000;break;
case 'c':sum+=100;break;
case 'd':sum+=10;break;
case 'e':sum+=1;break;
case '(':sum=0;break; //遇到左括号说明到了一个新题目
case ')':{
id++; //如果遇到右括号，说明当前题目已经读取完毕，题号计数器累加
if(sum==v[id].ans) score+=v[id].score; //比对答案，累计分数
else{ v[id].cnt++; maxerror=max(maxerror,v[id].cnt);} //如果错误累计该题目的错误人数，并获取最大错误数量
}
}
}
printf("%d\n",score); //输出当前学生的得分
}
if(maxerror==0) printf("Too simple");//如果没有人错
else{
printf("%d",maxerror); //按照要求输出最后的结果
for(int i=1;i<=M;i++)
if(v[i].cnt==maxerror) printf(" %d",i);
}
return 0;
}
59
#include<bits/stdc++.h>
using namespace std;
#define MAXN 10010
bool Prime[MAXN];
int Rank[MAXN]={0}; //用于记录学生排名
void getPrime(){ //筛选法获取素数表
fill(Prime,Prime+MAXN,true);
Prime[0]=Prime[1]=false;
for(int i=2;i<MAXN;i++){
if(Prime[i]){
for(int j=i+i;j<sqrt(1.0*MAXN);j+=i)
Prime[j]=false;
}
}
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
getPrime();
int N,id;
scanf("%d",&N);
for(int i=1;i<=N;i++){ //读取id并记录排名，这里*10是为了保留出个位作为是否领奖的标记，初始为0，领取后置为1
scanf("%d",&id);
Rank[id]=10*i;
}
scanf("%d",&N);
for(int i=0;i<N;i++){
scanf("%d",&id);
printf("%04d: ",id);
if(Rank[id]==0) printf("Are you kidding?"); //如果不在列表中出现过
else{
int rank=Rank[id]/10,check=Rank[id]%10; //获取排名和发放标记
if(check==0){ //如果未发放过
Rank[id]++; //更新发放标记
if(rank==1) printf("Mystery Award"); //根据排名输出奖品类型
else if(Prime[rank]) printf("Minion");
else printf("Chocolate");
}
else printf("Checked"); //如果发放过，按要求输出
}
putchar('\n'); //结果换行
}
return 0;
}
60
#include<bits/stdc++.h>
using namespace std;
bool cmp(int a,int b){
return a>b;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
scanf("%d",&n);
int a[n];
for(int i=0;i<n;i++) scanf("%d",&a[i]); //读入数据
sort(a,a+n,cmp); //从大到小排序
int ans=0;
while(ans<n&&a[ans]>ans+1) ans++; //在满足下标的范围内，统计满足的天数，为保证ans下标有效性，ans<n判定放在前边
printf("%d",ans); //由于从大到小排列，所以ans下标总共有ans+1天，所以如果有ans+1天的骑行超过ans+1，就统计计数
return 0;
}
61
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,M;
scanf("%d %d",&N,&M);
int score[M],ans[M];
for(int i=0;i<M;i++) //读入分值
scanf("%d",&score[i]);
for(int i=0;i<M;i++) //读入正确答案
scanf("%d",&ans[i]);
for(int i=0;i<N;i++){
int sum=0;
for(int j=0;j<M;j++){ //比对每个学生答案
int temp;
scanf("%d",&temp);
if(temp==ans[j]) sum+=score[j]; //如果争取则累加得分
}
printf("%d\n",sum); //输出结果
}
return 0;
}
62
#include<bits/stdc++.h>
using namespace std;
int gcd(int a,int b){
return !b?a:gcd(b,a%b);
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int a,b,c,d,e,cnt=0;
scanf("%d/%d %d/%d %d",&a,&b,&c,&d,&e);
if(a*d>b*c){ //这里保证第一个分数数值小，第二个分数数值大
swap(a,c),swap(b,d);
}
for(int i=a*e/b+1;i*d<c*e;i++){ //i从最低的数开始，到最高的数结束
if(gcd(i,e)==1){ //满足最简分数的进行输出
if(cnt++) putchar(' '); //通过计数的方式处理格式
printf("%d/%d",i,e);
}
}
return 0;
}
63
#include<bits/stdc++.h>
using namespace std;
const double eps=1e-8;
#define more(a,b) ((a)-(b)>eps) //浮点数的比较，大于需要超过某个精度范围
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int a,b,N;
double temp,max=0.0;
scanf("%d",&N);
for(int i=0;i<N;i++){
scanf("%d %d",&a,&b);
temp=hypot(a,b); //返回值为double，返回两个参数平方和的开方
if(more(temp,max)) max=temp; //获取最大模
}
printf("%.2f",max);
return 0;
}
64
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int Table[37]={0}; //朋友证号最多为36，即数字为9999，所以打表开37个空间即可
char ch;
while((ch=getchar())!='\n') continue; //字符处理，所以不需要知道有多少个数字，直接过滤掉这些字符
int friendnum=0,cnt=0; //friendnum用于存放临时计算出的一个朋友证号，cnt用于计数不同的朋友证号个数
while((ch=getchar())!='\n'){ //到换行结束
if(ch==' '){ //如果遇到空格，说明已经处理过一个数字了
if(Table[friendnum]==0){ //如果第一次遇到这个朋友证号，计数并将标记置为一
cnt++;Table[friendnum]=1;
}
friendnum=0;continue; //凡是处理过一个数字，friendnum清0，用于下一个数字的计算
}
friendnum+=ch-'0'; //累加计算每一位的和
}
if(Table[friendnum]==0){ //处理最后一个数字
cnt++;Table[friendnum]=1;
}
printf("%d\n",cnt); //输出个数
for(int i=1,flag=0;flag<cnt;i++){ //遍历并输出符合的朋友证号
if(Table[i]==1){
if(flag++) putchar(' ');
printf("%d",i);
}
}
return 0;
}
65
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
map<string,string> mp; //记录夫妻关系
map<string,int> at; //记录是否在场
int n,m;
cin>>n;
for(int i=0;i<n;i++){ //读取夫妻关系
string a,b;
cin>>a>>b;
mp[a]=b;
mp[b]=a;
}
vector<string> v1; //记录到场人员
vector<string> v; //记录输出人员
cin>>m;
for(int i=0;i<m;i++){ //出场人员进行标记
string temp;
cin>>temp;
at[temp]=1;
v1.push_back(temp);
}
for(int i=0;i<m;i++){
string temp=v1[i];
if(mp[temp]=="") //如果没有夫妻关系，属于需要输出的人员
v.push_back(temp);
else if(at[mp[temp]]==0){//如果配偶没有到场，也属于需要输出的人员
v.push_back(temp);
}
}
if(v.size()==0){ //如果人数是0直接输出结果
putchar('0');return 0;
}
sort(v.begin(),v.end()); //如果有单身人士，按照id从小到大排序输出
cout<<v.size()<<'\n';
for(int i=0;i<v.size();i++){
if(i) putchar(' ');
cout<<v[i];
}
return 0;
}
66
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int m,n,a,b,tag;
scanf("%d%d%d%d%d",&m,&n,&a,&b,&tag); //读入行数，列数，替换区间，替换值
for(int i=0;i<m;i++){ //双循环读入
for(int j=0;j<n;j++){
int temp;
scanf("%d",&temp);
if(temp>=a&&temp<=b) temp=tag; //如果符合替换区间，直接替换
if(j) putchar(' ');
printf("%03d",temp); //按照格式进行输出
}
putchar('\n');
}
return 0;
}
67
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
string pasword,temp;
int n,cnt=0;
cin>>pasword>>n; //读入正确密码和允许的错误次数
char ch;
while((ch=getchar())!='\n') continue; //过滤多余字符
while(1){
getline(cin,temp); //读入一个密码输入
if(temp=="#") break; //如果读取结束
else if(temp==pasword){ //如果密码正确，输出欢迎语句并结束循环
printf("Welcome in");break;
}
else{ //如果不正确，输出错误密码，然后统计错误次数
cout<<"Wrong password: "<<temp<<endl;
cnt++; //如果错误次数达到上限，输出账户锁定，并结束循环
if(cnt==n){ printf("Account locked");break;}
}
}
return 0;
}
68
#include<bits/stdc++.h>
using namespace std;
#define diff(a,b) ((a-b)>0?(a-b):(b-a))
int Point[1005][1005]={0};
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int M,N,TOL,x,y,cnt=0;
map<int,int> mp;
scanf("%d %d %d",&M,&N,&TOL); //读取数据
for(int i=1;i<=N;i++){
for(int j=1;j<=M;j++){
scanf("%d",&Point[i][j]);
mp[Point[i][j]]++;
}
}
for(int i=1;i<=N;i++){
int flag=0;
for(int j=1;j<=M;j++){ //边和角落的点也需要判定，类似于扫雷游戏的判定规则，所以数组开大一些，下标从1开始保存
if(diff(Point[i][j],Point[i][j+1])>TOL //判定是否比周围的颜色相差超过阈值
&&diff(Point[i][j],Point[i][j-1])>TOL
&&diff(Point[i][j],Point[i+1][j+1])>TOL
&&diff(Point[i][j],Point[i+1][j])>TOL
&&diff(Point[i][j],Point[i+1][j-1])>TOL
&&diff(Point[i][j],Point[i-1][j+1])>TOL
&&diff(Point[i][j],Point[i-1][j])>TOL
&&diff(Point[i][j],Point[i-1][j-1])>TOL){
if(mp[Point[i][j]]==1){ //如果这样的点存在，且出现次数只有一次，累计并保存
cnt++;x=i,y=j;
if(cnt>1){flag=1;break;} //如果符合条件的点不止一个，终止循环判定
}
}
}
if(flag) break;
}
if(cnt==0) puts("Not Exist"); //根据结果进行输出
else if(cnt==1) printf("(%d, %d): %d\n",y,x,Point[x][y]);
else puts("Not Unique");
return 0;
}
69
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int M,N,S;
map<string,int> mp; //用于标记是否出现过
string str;
scanf("%d %d %d\n",&M,&N,&S); //读入各个参数
bool flag=false; //用于标记是否有中奖输出
for(int i=1;i<=M;i++){ //依次读入M个数据
cin>>str; //读入一个ID
if(mp[str]==1) {S=S+1;continue;} //用S记录需要输出的下一个中奖者的序号，如果已经领奖顺延到下一位
if(i==S){ //如果当前序号是中奖着则进行处理
mp[str]=1; //领奖标记
cout<<str<<endl; //输出名字
flag=true; //修改标记
S+=N; //再隔N个为下一个中奖者，更新S
}
}
if(flag==false) printf("Keep going...");//如果没有人中奖
return 0;
}
70
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
double sum;
scanf("%d",&n);
int a[n];
for(int i=0;i<n;i++) //读取n个元素，然后从小到大排序，因为长绳子尽可能少折叠，所以放在最后加入绳结
scanf("%d",&a[i]);
sort(a,a+n);
sum=a[0]; //sum初始化为第一段绳子
for(int i=1;i<n;i++)
sum=(sum+a[i])/2; //和后边的每段绳子进行链接
printf("%d",int(sum)); //通过强制转换截断，向下取整
return 0;
}
71
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int T,K;
scanf("%d %d",&T,&K);
for(int i=0;i<K;i++){
int n1,b,t,n2;
scanf("%d %d %d %d",&n1,&b,&t,&n2);
if(t>T) printf("Not enough tokens. Total = %d.\n",T); //如果下注超过拥有的筹码
else if((b==1&&n2>n1)||(b==0&&n1>n2)) //如果赢了，则增加筹码
printf("Win %d! Total = %d.\n",t,T+=t);
else{
printf("Lose %d. Total = %d.\n",t,T-=t); //如果输了就减少筹码
if(T==0) {printf("Game Over.");break;} //如果输完了就结束游戏
}
}
return 0;
}
//注意：
//题目输出格式上Total之前只有一个空格，但是输出样例有两个空格，以输出样例为准
72
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,M,Pcnt=0,Tcnt=0; //Pcnt用于记录人数，Tcnt用于记录物品个数
map<int,bool> notallow; //记录违禁物品编号
scanf("%d%d",&N,&M);
for(int i=0;i<M;i++){ //读入并标记违禁物品
int temp;
scanf("%d",&temp);
notallow[temp]=true;
}
for(int i=0;i<N;i++){ //依次对N个学生进行检查
string name;
int k,temp,flag=0; //flag标记为是否有违禁物品
cin>>name>>k;
for(int j=0;j<k;j++){
scanf("%d",&temp);
if(notallow[temp]==true){ //如果是违禁物品，则进行处理
if(flag==0) cout<<name<<":";//如果是第一个违禁物品，先输出人名
printf(" %04d",temp); //输出违禁物品编号
flag=1; Tcnt++; //修改标记，并累加
}
}
if(flag==1){putchar('\n'); Pcnt++;}//如果该学生有违禁物品则统计人数，并换行
}
printf("%d %d",Pcnt,Tcnt); //输出最后的统计人数
return 0;
}
73
#include<bits/stdc++.h>
using namespace std;
typedef struct{ //题目结构体，score表示分数，ans表示答案用模拟的二进制形式表示，rn表示正确的选项个数
int score,ans,rn,xs[6]; //xs用于存放错误选项的信息，0号储存本题中错误数量最大的个数
}QU;
int getans(); //读取答案
int cmp(QU *p,int i); //比较函数，比较答案，返回错误类型，1代表全对，2代表对一半，3代表错误
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,M,max=0;
char ch;
QU *p;
cin>>N>>M;
p=(QU*)malloc((M+1)*sizeof(QU)); //构造题目结构体数组
for(int i=1;i<=M;i++){ //读入题目，初始化题目结构体的内容
scanf("%d %*d %d",&p[i].score,&p[i].rn);//读入分数和正确选项个数，跳过选项数量，统一按5个选项处理
p[i].ans=getans(); //读取答案
for(int j=0;j<=5;j++){ //将题目每个选项的错误数量初始化为0
p[i].xs[j]=0;
}
}
for(int i=0;i<N;i++){ //读入N个学生答案
double sum=0;
char ch;
for(int j=1;j<=M;j++){
while((ch=getchar())!='(') //过滤吸收多余字符，直到左括号
continue;
switch(cmp(p,j)){ //比对答案
case 1:sum+=p[j].score;break;//如果全对，加上该题分值
case 2:sum+=(1.0*p[j].score)/2;max=(p[j].xs[0]>max?p[j].xs[0]:max);break;//如果对了一般，加一半分值，更新最大错误max
case 3:max=(p[j].xs[0]>max?p[j].xs[0]:max);break;//如果错误，更新max
default:break;
}
}
printf("%.1f\n",sum); //打印成绩
}
if(max==0) //没有人错
puts("Too simple");
else{
for(int i=1;i<=M;i++) //按顺序读取每一个题目
if(p[i].xs[0]==max){ //如果最大错误数量与max相同，则考虑打印
for(int j=1;j<=5;j++){ //比较每个选项的错误数量，按顺序输出与max相等的选项
if(p[i].xs[j]==max)
printf("%d %d-%c\n",max,i,'a'-1+j);
}
}
}
free(p); //释放动态内存空间
return 0;
}
int getans() //读取答案，模拟二进制数的表示方法
{
int ans=0;
char ch;
while((ch=getchar())!=')'){
if(ch=='\n') break;
switch(ch){
case 'a':ans+=10000;break;
case 'b':ans+=1000;break;
case 'c':ans+=100;break;
case 'd':ans+=10;break;
case 'e':ans+=1;break;
default:break;
}
}
return ans;
}
int cmp(QU *p,int i)
{
int ret=3; //ret返回值表示题目错误类型，默认为错题
int ans=getans(); //读取答案
char a[6],pa[6]; //定义两个字符串，把答案读入字符串进行比对
sprintf(a,"%05d",ans); //把答案以5位字符串的格式读入，不够的补零
sprintf(pa,"%05d",p[i].ans); //pa表示答案字符串
int cnt=0; //只统计正确选项的数量
for(int j=0;j<5;j++){ //依此比对答案
if(pa[j]==a[j]){ //如果相同
if(pa[j]=='1') cnt++; //如果答案是1，表示选中，cnt计数；如果是0，则表示该选项不存在或者不需要选
}
else{ //如果不相同则表示漏选或者多选 ，都认为此选项出错 ，统计在错误数量内
p[i].xs[j+1]++;
if(pa[j]=='0') cnt=10; //如果答案是0，表示错选，将cnt置为一个很大的值，以表示此题错误，漏选则cnt不做处理
}
}
for(int j=0;j<=5;j++){ //遍历选项错误数量，将错的最多的赋值给0号位置；
p[i].xs[0]=(p[i].xs[j]>p[i].xs[0]?p[i].xs[j]:p[i].xs[0]);
}
if(cnt==p[i].rn) ret=1; //如果选对的数量和正确答案的数量相同，表示全对
else if(cnt<p[i].rn) ret=2; //如果选对的数量小于正确答案的数量，表示对了一半
//否则，cnt是一个很大的值，表示此题错误
return ret;
}
74
#include<bits/stdc++.h>
using namespace std;
int get_arry(int a[]){ //把数字的每一位读入int数组
char ch;
int cnt=0;
while((ch=getchar())!='\n')
a[cnt++]=ch-'0';
return cnt;
}
void Reverse(int a[],int len){ //逆置函数
int i=0,j=len-1;
while(i<j){
swap(a[i],a[j]);
i++,j--;
}
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int Table[21]={0},a[21]={0},b[21]={0}; //每一位的权值Table，第一个数a，第二个数b
int cnt,lena,lenb,flag=0; //长度计数器和标记
cnt=get_arry(Table),lena=get_arry(a);lenb=get_arry(b); //读入每一个数字的每一位
Reverse(Table,cnt);Reverse(a,lena);Reverse(b,lenb); //将每一个数组逆置
for(cnt=0;cnt<lena||cnt<lenb||flag;cnt++){ //遍历数组，以最长的为结尾，flag用于存放位的临时和以及进位，如果最后还有进位flag不为0，则多一步处理
int tag=Table[cnt]==0?10:Table[cnt]; //获取当前位的权值，0代表权值是10，需要特判
flag=a[cnt]+b[cnt]+flag; //计算当前两位的和需要累加上一位的进位
a[cnt]=flag%tag; //计算累加后的位存放再a中
flag/=tag; //更新获取进位
}
flag=0; //标记，第一个非零的位开始输出
for(cnt--;cnt>=0;cnt--){ //cnt记录了最终结果的长度，倒序输出
if(a[cnt]!=0) flag=1; //如果出现了第一位不为0的数字，修改标记
if(flag==1)
putchar('0'+a[cnt]); //第一位不为0的出现后开始输出
}
if(flag==0) putchar('0'); //如果全为0，则flag标记为初始化的0，特别输出加法结果0
return 0;
}
75
解法一
#include<bits/stdc++.h>
using namespace std;
typedef struct{
int id,data,next;
}NODE;
NODE LinkList[100001]; //存放读入的数据结点
NODE out[100001]; //用辅助的数组空间存放最终的链表
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int head,n,k,cnt=0,i;
scanf("%d %d %d",&head,&n,&k); //读入参数
for(i=0;i<n;i++){
int temp;
scanf("%d",&temp);
LinkList[temp].id=temp;
scanf("%d %d",&LinkList[temp].data,&LinkList[temp].next);
}
for(i=head;i!=-1;i=LinkList[i].next){ //先存入小于0的结点
if(LinkList[i].data<0)
out[cnt++]=LinkList[i];
}
for(i=head;i!=-1;i=LinkList[i].next){ //再存放0~K的结点
if(LinkList[i].data>=0&&LinkList[i].data<=k)
out[cnt++]=LinkList[i];
}
for(i=head;i!=-1;i=LinkList[i].next){ //最后存放剩余结点
if(LinkList[i].data>k)
out[cnt++]=LinkList[i];
}
for(i=0;i<cnt-1;i++){ //格式化输出链表，next值便是数组中下一个元素的id，最后一个结点单独处理
printf("%05d %d %05d\n",out[i].id,out[i].data,out[i+1].id);
}
printf("%05d %d -1",out[i].id,out[i].data);
return 0;
}
解法二
#include<bits/stdc++.h>
using namespace std;
typedef struct{
int id,data,next;
}NODE;
NODE LinkList[100001]; //存放读入的数据结点
NODE out[100001]; //用辅助的数组空间存放最终的链表
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int head,n,k,cnt=0,i; //cnt从0开始,是负值存放位置的开始
int negcnt=0,Kcnt=0; //negcnt为负值结点个数，Kcnt为0~K结点个数
int Kindex,OtherIndex; //Kindex是0~K值最终在数组存放的数组下标起始位置，OtherIndex是大于K的元素下标起始位置
scanf("%d %d %d",&head,&n,&k); //读入参数
for(i=0;i<n;i++){
int temp;
scanf("%d",&temp);
LinkList[temp].id=temp;
scanf("%d %d",&LinkList[temp].data,&LinkList[temp].next);
}
for(i=head;i!=-1;i=LinkList[i].next){ //第一遍遍历链表，记录每种类型的个数
if(LinkList[i].data<0) negcnt++;
else if(LinkList[i].data>=0&&LinkList[i].data<=k) Kcnt++;
}
Kindex=negcnt; OtherIndex=negcnt+Kcnt; //计算每类元素存放的起始坐标
for(i=head;i!=-1;i=LinkList[i].next){
if(LinkList[i].data<0) //如果是负值，从cnt开始存放
out[cnt++]=LinkList[i];
else if (LinkList[i].data>=0&&LinkList[i].data<=k) out[Kindex++]=LinkList[i]; //如果是0~K值从Kindex位置开始存放
else out[OtherIndex++]=LinkList[i]; //大于K的从OtherIndex位置开始存放
} //显然最后OtherIndex刚好是最后一个元素的下一个位置下标，也刚好是链表长度
for(i=0;i<OtherIndex-1;i++){ //格式化输出链表，next值便是数组中下一个元素的id，最后一个结点单独处理
printf("%05d %d %05d\n",out[i].id,out[i].data,out[i+1].id);
}
printf("%05d %d -1",out[i].id,out[i].data);
return 0;
}
76
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){ //读取N组数据
for(int j=0;j<4;j++){ //每组四个选项
string str;
cin>>str; //读入字符串
if(str[2]=='T') //如果该答案是正确的，输出对应的序号
printf("%d",str[0]+1-'A');
}
}
return 0;
}
77
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N,M;
scanf("%d%d",&N,&M);
for(int i=0;i<N;i++){
int G2,cnt=0,maxs=0,mins=M; //cnt用于记录有效分数的个数，maxs和mins用于记录最大和最小成绩
double G1=0;
scanf("%d",&G2);
for(int j=0;j<N-1;j++){
int score;
scanf("%d",&score);
if(score<0||score>M) continue; //不合法成绩直接跳过不处理
G1+=score; //累加合法成绩
maxs=max(maxs,score); mins=min(mins,score); //记录最大和最小成绩
cnt++; //计数器自增
}
G1-=maxs,G1-=mins;G1=G1/(cnt-2); //G1减去最大最小分数，然后求平均数
printf("%d\n",int((G1+G2)/2+0.5)); //四舍五入后取整并输出，这里使用+0.5并强制转换的方式实现
}
return 0;
}
78
#include<bits/stdc++.h>
using namespace std;
void Cstr(){ //压缩算法
int cnt=1; //统计字符个数
char ch=getchar(); //先读入第一个字符，因为后序字符需要有一个前置字符进行比对
while(ch!='\n'){ //在读到换行之前都要处理
char temp=getchar(); //读取当前位的字符
if(temp==ch) cnt++; //如果和前置字符相同则进行统计相同字符个数
else{ //如果不同则进行输出
if(cnt>1) printf("%d%c",cnt,ch); //如果超过1个，则输出个数和字符
else putchar(ch); //否则输出一个字符即可
cnt=1;ch=temp; //更新计数器重新计数，更新ch为当前字符，用于准备下一次比对
}
}
}
void Dstr(){
char ch,num[15]; //ch用于存储字符，num用于存储整数
while((ch=getchar())!='\n'){ //在未读到换行时进行判定
if(isdigit(ch)){ //如果是数字，则需要读取一个完整的数字
int index=0; //存放数字的数组下标
while(isdigit(ch)){ //如果是数字则进行存储，否则刚好获取到字符个数，和需要输出的字符ch
num[index++]=ch;
ch=getchar();
}
num[index]='\0'; //添加字符结尾标记
sscanf(num,"%d",&index); //将字符数组转化为整型数字
for(int i=0;i<index;i++) putchar(ch); //输出相对应个数的字符
}
else putchar(ch); //如果只有一个字符（没有数字修饰）直接输出
}
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
char ch=getchar(); //读取解压模式
getchar(); //吸收换行符
if(ch=='C') Cstr(); //根据模式选择相应的解压缩算法
else Dstr();
return 0;
}
79
#include<bits/stdc++.h>
using namespace std;
char num[1001],revnum[1001];
bool IsRight(char str[]){ //判断字符串是不是回文数
int low=0,high=strlen(str)-1; //双指针，一个从前往后，一个从后往前，如果对称位置有不相等的就不是回文数
while(low<high){
if(str[low]!=str[high]) return false;
low++,high--;
}
return true;
}
void AddNum(){ //对原始数字进行加法操作
int len=strlen(num); //计算字符数组长度
int i=0,flag=0;
for(i=0;i<len;i++) revnum[i]=num[len-1-i]; //获取逆序后的字符串
revnum[i]='\0'; //注意字符串的结尾符号
printf("%s + %s = ",num,revnum); //输出加法算式
for(i=0;i<len;i++){ //大数加法
flag=num[i]-'0'+revnum[i]-'0'+flag;
num[i]=flag%10+'0';
flag/=10;
}
if(flag) num[i++]=flag+'0'; //如果还有进位，需要多出一位
num[i]='\0'; //字符串末尾处理
int low=0,high=i-1; //由于得到的字符串实际上是逆位的，所以逆转一下
while(low<high){ swap(num[low],num[high]); low++,high--; }
printf("%s\n",num); //输出计算过后的结果
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
scanf("%s",num);
if(IsRight(num)){ //特判给的第一个数字就是回文数
printf("%s is a palindromic number.",num); return 0;
}
int i=10;
while(i--){ //循环10次，
AddNum(); //加法处理
if(IsRight(num)){ //如果得到一个回文数，输出并结束循环
printf("%s is a palindromic number.",num);
break;
}
} //如果刚好第10步得到回文数，则i为0，如果10步都没得到，i最后为-1
if(i==-1) printf("Not found in 10 iterations.");//如果10步以内没有找到
return 0;
}
//测试点2 3 4是给出的数字便是回文数，所以直接特判输出即可
80
#include<bits/stdc++.h>
using namespace std;
typedef struct node{
string id;
int Gp=-1,Gmid=-1,Gfi=-1,G; //各项成绩初始化为-1
}STU;
bool cmp(STU &a,STU &b){
if(a.G!=b.G) return a.G>b.G;
else return a.id<b.id;
}
STU DATA[10005]; //编程成绩有效个数一定小于等于P，所以最多只有P个人
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int P,M,N,cnt=0,score;
string id;
map<string,int> mp;
scanf("%d %d %d",&P,&M,&N);
for(int i=0;i<P;i++){ //读取编程成绩
cin>>id>>score;
if(score<200) continue; //如果编程分数不及格，直接跳过
DATA[cnt].id=id; //记录学生成绩和学号
DATA[cnt].Gp=score;
mp[id]=cnt; cnt++; //cnt用于记录数组中下一个可存放位置的下标，mp用于存放学号对应的数组下标
}
for(int i=0;i<M;i++){ //读取期中成绩
cin>>id>>score;
if(mp.find(id)==mp.end()) continue; //如果没有编程成绩，直接跳过（这里用mp.find(）进行判定）
DATA[mp[id]].Gmid=score; //记录期中成绩
}
for(int i=0;i<N;i++){ //读取期末成绩
cin>>id>>score;
if(mp.find(id)==mp.end()) continue; //如果没有编程成绩，则跳过
int index=mp[id]; //获取在数组中的下标
DATA[index].Gfi=score; //记录期末成绩
if(score<DATA[index].Gmid) DATA[index].G=int(0.4*DATA[index].Gmid+0.6*score+0.5);
else DATA[index].G=score; //按照规则计算最终成绩，这里使用+0.5后强制转换的方式实现四舍五入到整数
}
sort(DATA,DATA+cnt,cmp); //按照要求排序
for(int i=0;i<cnt;i++){ //输出符合要求的学生
if(DATA[i].G<60) break;
cout<<DATA[i].id<<' '<<DATA[i].Gp<<' '<<DATA[i].Gmid<<' '<<DATA[i].Gfi<<' '<<DATA[i].G<<endl;
}
return 0;
}
81
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
scanf("%d\n",&n); //读取输入个数，这里需要带上\n用于吸收末尾的换行符
for(int i=0;i<n;i++){
string str="";
getline(cin,str); //读取整行字符
int len=str.size();
if(len<6) puts("Your password is tai duan le."); //如果密码过短
else{
bool alphcnt=0,numcnt=0,other=0; //如果长度符合要求，验证字母，数字和其他字符
for(int j=0;j<len;j++){
if(isdigit(str[j])) numcnt=1; //如果存在数字
else if(isalpha(str[j])) alphcnt=1; //如果存在字母
else if(str[j]!='.'){ //如果不是字母，不是数字，也不是. 则为其他字符，更新标记并直接退出循环
other=1; break;
}
}
if(other) puts("Your password is tai luan le."); //输出有其他字符
else if(numcnt==0) puts("Your password needs shu zi."); //缺少数字
else if(alphcnt==0) puts("Your password needs zi mu."); //缺少字母
else puts("Your password is wan mei."); //如果都没有上述问题，则认为是完美密码
}
}
return 0;
}
82
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int id,N,maxid,minid,max_s=0,min_s=20000; //记录最大和最小的id和成绩
scanf("%d",&N);
for(int i=0;i<N;i++){
int x,y;
scanf("%d%d%d",&id,&x,&y);
x=x*x+y*y; //计算当前坐标的平方和
if(x>max_s){ max_s=x; maxid=id; } //分别更新最大和最小值
if(x<min_s){ min_s=x; minid=id; }
}
printf("%04d %04d",minid,maxid); //距离越近，成绩越高，所以先输出min再输出max
return 0;
}
83
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
scanf("%d",&n);
map<int,int> mp;
for(int i=1;i<=n;i++){ //用mp统计每一个数的出现次数，
int temp;
scanf("%d",&temp);
mp[abs(i-temp)]++;
}
for(auto it=mp.rbegin();it!=mp.rend();it++)//从大到小输出重复出现的数字，出现次数大于1认为是重复
if(it->second>1)
printf("%d %d\n",it->first,it->second);
return 0;
}
84
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
string str;
int n,i,j;
cin>>str>>n; //读入第一个字符
for(int cnt=1;cnt<n;cnt++){ //循环n-1次即可，因为第一行就是给出的字符
string temp=""; //根据前一个字符串，temp用于构建新字符
for(i=0;i<str.size();i=j){ //遍历字符串
for(j=i;j<str.size()&&str[j]==str[i];j++);//如果j位置的字符串和i位置的相同，一直往后统计，直到结束或者遇到不相同的字符
temp+=str[i]+to_string(j-i); //先加上当前的字符，然后加上个数，然后用新位置j在外层循环更新i的值
}
str=temp; //更新字符串
}
cout<<str;
return 0;
}
85
#include<bits/stdc++.h>
using namespace std;
typedef struct node{
string id;
int AS=0,BS=0,TS=0,S=0,cnt=0;
}SCH;
bool cmp(SCH &a,SCH &b){ //排序规则
if(a.S!=b.S) return a.S>b.S; //加权分数按照从高到底排序
else if(a.cnt!=b.cnt) return a.cnt<b.cnt; //分数并列，按照人数从少到多排序
else return a.id<b.id; //人数依然并列按照学校名字字典序排列
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,cnt=0;
scanf("%d",&n);
SCH DATA[n];
unordered_map<string,int> mp; //记录学校在数组中的下标，使用无序map以节省时间
for(int i=0;i<n;i++){
string id,sch;
int score,index;
cin>>id>>score>>sch;
for(int k=0;k<sch.size();k++){ //把所有的学校名字都改为小写
if(sch[k]>='A'&&sch[k]<='Z') sch[k]=sch[k]-'A'+'a';
}
if(mp.find(sch)==mp.end()) {DATA[cnt].id=sch; mp[sch]=cnt++;} //如果出现一个心学校，则从数组中分配一个位置，并更新mp
index=mp[sch]; //获取学校存储下标
DATA[index].cnt++; //人数累加
switch(id[0]){ //根据考试难度累加分数
case 'A':DATA[index].AS+=score;break;
case 'B':DATA[index].BS+=score;break;
case 'T':DATA[index].TS+=score;break;
}
} //遍历以计算加权分数
for(int i=0;i<cnt;i++) DATA[i].S=int(1.0*DATA[i].BS/1.5+DATA[i].AS+1.5*DATA[i].TS);
sort(DATA,DATA+cnt,cmp); //按照规则排序
int rank=1;
cout<<cnt<<endl; //输出学校个数
for(int i=0;i<cnt;i++){
if(i==0) rank=1; //第一个人序号是1
else if(DATA[i].S!=DATA[i-1].S) rank=i+1;//如果和前一个人分数相同，序号相同，如果分数不同，排名为自己在数组中的序号（由于数组从0开始，排序从1开始，所以要+1）
cout<<rank<<' '<<DATA[i].id<<' '<<DATA[i].S<<' '<<DATA[i].cnt<<endl;
}
return 0;
}
86
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int a,b,temp,i,ans[7]={0};
scanf("%d %d",&a,&b);
temp=a*b;
for(i=0;temp;i++){ //把每一位存在数组中（逆序）
ans[i]=temp%10;
temp/=10;
}
for(temp=0;ans[temp]==0;temp++);//找到第一个非零数字开始输出
for(;temp<i;temp++)
printf("%d",ans[temp]);
return 0;
}
87
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n;
set<int> se;
scanf("%d",&n);
for(int i=1;i<=n;i++){ //根据要求计算数值，并用set存储去重
int temp=int(i/2)+int(i/3)+int(i/5);
se.insert(temp);
}
printf("%d",se.size());
return 0;
}
88
#include<bits/stdc++.h>
using namespace std;
void check(double x,double m){ //打印能力值关系
if(x>m) printf(" Cong");
else if(x==m) printf(" Ping");
else printf(" Gai");
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int M,x,y,flag=0;
int jia,yi;
double bing; //bing的能力值是除法计算出来的，所以，可能是浮点数
scanf("%d %d %d",&M,&x,&y); //读取数据
for(jia=99;jia>=10;jia--){ //甲能力值为两位数，而且解不唯一时以最大为准
yi=jia%10*10+jia/10;
int diff=abs(jia-yi);
if(diff*y==yi*x){ //计算满足条件的关系
bing=1.0*diff/x;
flag=1;break; //有解就把标记置为一
}
}
if(flag==0) printf("No Solution"); //无解的情况
else{
printf("%d",jia); //输出有解的情况
check(jia,M);check(yi,M);check(bing,M);
}
return 0;
}
89
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int N;
cin>>N;
vector<int> v(N+1);
for(int i=1;i<=N;i++) //用于存放每一个玩家说的数字
cin>>v[i];
for(int i=1;i<=N;i++){ //双重循环，这样可以得到题目所说的最小序列
for(int j=i+1;j<=N;j++){
vector<int> lie,a(N+1,1); //记录说谎者和假定的身份（1表示好人，-1表示狼人，初始化为1）
a[i]=a[j]=-1; //假定i和j都是狼人
for(int k=1;k<=N;k++){ //遍历每个人说的话
if(v[k]*a[abs(v[k])]<0) //v表示第k个玩家说的话，与相对应的描述的另一位玩家abs[v[k]]的身份进行比对，如果符号（身份）不同，乘积小于0，即说明此人说谎
lie.push_back(k); //保存说谎玩家的序号
}
if(lie.size()==2&&a[lie[0]]+a[lie[1]]==0){ //如果说谎玩家刚好有两个，而且一个狼人一个好人（题目要求只有两个狼人，有狼人说谎且不是所有狼人都说谎）
cout<<i<<' '<<j; //如果满足题目条件，说明当前的假设成立，也就是i和j都是狼人，输出即可
return 0;
}
}
}
cout<<"No Solution"; //如果没有满足条件的输出，则无解
return 0;
}
90
#include<bits/stdc++.h>
using namespace std;
unordered_map<string,string> mp; //记录反应物对应关系
bool check(){
int n;
cin>>n;
unordered_map<string,int> m; //记录某个物品是否出现过
vector<string> v(n);
for(int i=0;i<n;i++){ //读取每一种货物
cin>>v[i];
m[v[i]]=1;
}
for(int i=0;i<n;i++)
if(mp[v[i]]!=""){ //如果当前物品有反应物
for(int j=0;j<mp[v[i]].size();j+=5){
string temp=mp[v[i]].substr(j,5); //每次提取从j开始的五位进行核查
if(m[temp]==1) return false; //如果与之反应的物品也出现在清单里，则不能安全运输
}
}
return true;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,m;
string a,b;
cin>>n>>m;
for(int i=0;i<n;i++){ //采用衔接的方式构建一个类似于二维矩阵的map，
cin>>a>>b; //把每一个物品对应的反应物品string类变量直接加在value值的后边，构成一个长串
mp[a]+=b; //检查时每次取出5位进行对比核查
mp[b]+=a;
}
for(int i=0;i<m;i++) //判定m箱货物清单
puts(check()?"Yes":"No");
return 0;
}
91
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int m,n,k;
scanf("%d",&m);
for(int i=0;i<m;i++){ //读取数字
scanf("%d",&k);
int temp,check;
for(n=1;n<10;n++){
temp=check=n*k*k; //计算乘积
if(temp%10==k) break; //由于给出的数不超过1000，所有只有三位，直接判断取余判断即可
else if(temp%100==k) break;
else if(temp%1000==k) break;
}
if(n==10) printf("No\n"); //如果没有遇到对应的K则输出no
else printf("%d %d\n",n,temp);
}
return 0;
}
92
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int m,n,max=0;
scanf("%d %d",&n,&m); //读入参数
int cnt[n+1]={0}; //需要g++支持
for(int i=0;i<m;i++){
for(int j=1;j<=n;j++){
int num;
scanf("%d",&num);
cnt[j]+=num; //累加每种月饼的销量
max=cnt[j]>max?cnt[j]:max;
}
}
int flag=0; //用于格式控制
printf("%d\n",max);
for(int i=1;i<=n;i++){
if(cnt[i]==max){ //从小到大的序号遍历，输出销量等于最高销量的月饼序号
if(flag++) putchar(' ');
printf("%d",i);
}
}
return 0;
}
93
#include<bits/stdc++.h>
using namespace std;
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int Table[127]={0}; //用于记录是否已经出现过当前字符
int cnt=0; //用于统计出现回车的次数，用于结束循环
while(cnt<2){
char ch=getchar(); //读取字符
if(ch=='\n') { cnt++;continue; } //回车字符直接跳过
if(Table[ch]==0){ //如果没出现过，记录该字符并输出
Table[ch]++;
putchar(ch);
}
}
return 0;
}
//题目样例可知大小写不同
94
#include<bits/stdc++.h>
using namespace std;
bool IsPrime(int x){
if(x==0||x==1) return false;
for(int i=2;i<sqrt(1.0*x);i++)
if(x%i==0) return false;
return true;
}
int main(){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
string str;
int len,k;
scanf("%d %d\n",&len,&k);
cin>>str;
for(int i=0;i+k<=len;i++){ //注意循环边界
string num=str.substr(i,k); //去除当前位置开始向后的k个字符
if(IsPrime(stoi(num))){ //转化成数字并验证是不是素数，如果是则输出并返回
cout<<num; return 0;
}
}
cout<<"404"; //如果找不到符合条件的素数，则输出404
return 0;
}
95
#include<bits/stdc++.h>
using namespace std;
typedef struct{ //学生结构体
string id;
int score;
}ST;
bool cmp(ST a,ST b){ //排序规则
if(a.score!=b.score) return a.score>b.score;
else return a.id<b.id;
}
int main(void){
#ifdef ONLINE_JUDGE
#else
freopen("1.txt", "r", stdin);
#endif
int n,m,case_tp; //case_tp表示查验类型
string temp,day,room; //临时变量，时间，考场
cin>>n>>m;
vector<ST> v(n),ans; //v用于存储数据，ans用于存放答案
for(int i=0;i<n;i++)
cin>>v[i].id>>v[i].score; //读入原始数据
for(int i=1;i<=m;i++){ //进行查验
int cnt=0; //用于输出个数
cin>>case_tp>>temp; //读入查验类型和查验参数
cout<<"Case "<<i<<": "<<case_tp<<' '<<temp<<'\n';
ans.clear(); //初始化ans数组
if(case_tp==1){ //第一种类型
for(int j=0;j<n;j++) //找到同一个级别的考生放入输出的数组中
if(v[j].id[0]==temp[0]) ans.push_back(v[j]);
sort(ans.begin(),ans.end(),cmp); //按照要求排序并输出
for(int j=0;j<ans.size();j++){
cout<<ans[j].id<<' '<<ans[j].score<<'\n';
cnt++;
}
}
else if(case_tp==2){ //第二种类型
int sum=0,num=0; //用于统计总人数和总分分数
for(int j=0;j<n;j++){
room=v[j].id.substr(1,3); //遍历原始数据获取每个考生的考场号
if(room==temp){ //如果和查验的考场号相同，则累计人数和总分
num++;
sum+=v[j].score;
}
}
if(num) {printf("%d %d\n",num,sum);cnt++;} //当人数不为0时，输出并把标记cnt+1
}
else{
unordered_map<string,int> mp; //创建考场和人数的对应关系
for(int j=0;j<n;j++){ //遍历数据，获取考试日期和考场号
day=v[j].id.substr(4,6);
room=v[j].id.substr(1,3);
if(day==temp) //对应考场的人数统计+1
mp[room]++;
}
ST t; //这里发现如果把人数放在学生分数位置，考场号放在准考证号位置，两者排序规则相同，所以用于借用
for(auto it=mp.begin();it!=mp.end();it++){ //把考场号和人数组成结构体放入输出的数组中
t.id=it->first; t.score=it->second;
ans.push_back(t);
}
sort(ans.begin(),ans.end(),cmp); //按照要求排序后输出
for(int j=0;j<ans.size();j++){
cout<<ans[j].id<<' '<<ans[j].score<<'\n';
cnt++;
}
}
if(cnt==0) puts("NA"); //如果当前类型没有输出，则查询结果为空，输出NA
}
return 0;
}
