蓝桥杯省赛

幸运的大巴车

题目描述

国庆节到了，小可终于可以放假出去旅游了！

小可决定坐大巴车去北京看天安门广场，来到停车场后，小可发现这些车辆的车牌号全都是由55位数字组成的。小可认为回文数是“幸运”的数字，于是他想挑一辆车牌号幸运数字的大巴去旅游。

如果有多辆大巴的车牌号是幸运数字，他会挑数字最大的那一辆；如果没有大巴的车牌号是幸运数字，他就会挑车牌号最小的那辆车。

假设停车场共有n辆大巴，请你输出小可乘坐的大巴的车牌号是多少。

输入描述

输入共两行。

第一行包含一个整数：N，表示停车场内共有N辆大巴车。

第二行包含N整数a​i​​，表示每辆大巴的车牌号。

输出描述

输出一行，表示小可乘坐的大巴车的车牌号。

#include<iostream>
using namespace std;
int turn(int x){
    int sum=0;
    while(x!=0){
        sum=sum*10+x%10;
        x/=10;
    }
    return sum;
}
int main(){
    int a;
	bool flag=0;
    int n,maxx=0,minn=999999;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a;
        int d=a;
        if(turn(d)==a){
             flag=1;
             maxx=max(a,maxx);
        }
        minn=min(a,minn);
    }
   if(flag==0){
       cout<<minn;
   }
   else{
       cout<<maxx;
   
   }
    return 0;
}

文本字母量

题目描述

小可最近正在研究英语文本中的字母量，并想编写一个程序来自动计算给定文本中的最大字母量。他规定一个单词的字母量是指该单词中大写字母的数量，而一个文本的最大字母量是指该文本中所有单词字母量的最大值。

输入描述

第一行包含一个正整数 n ，表示文本长度。

第二行包含由空格分隔的单词组成的文本，文本仅由大小写字母组成。

输出描述

输出一个整数，表示文本的字母量。

#include<iostream>
using namespace std;
int main(){
   int n;
   string s;
   cin>>n;
   int maxx=0;
  while(cin>>s){
      int len=s.size();
      int sum=0;
      for(int i=0;i<len;i++){
          if(s[i]>='A'&&s[i]<='Z'){
          sum++; 
      }
      maxx=max(sum,maxx);
     }
      
     
  }
  cout<<maxx;
    return 0;
}

小可的A-B=C

题目描述

小可有n张卡片，每张卡片上都有一个数字，达达给小可出了一个问题，让小可找出任意两张，使得两张卡片上的数字差值等于达达给的数字C，有多少种组合方法

输入描述

第一行，两个整数 n，C

第二行，n个整数，作为要求处理的那串数。

其中 (1 ≤ C ≤ 2000 , 1 ≤ n ≤ 2*10^5)

输出描述

输出满足的个数

#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
long long a[210000],n,c,sum;
map<int,int>mp;
int main(){
    cin>>n>>c;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        mp[a[i]]++;
        a[i]-=c;
    }
    for(int i=1;i<=n;i++){
            sum+=mp[a[i]];
    }
    cout<<sum;
	return 0;
}

朗诵比赛

题目描述

达达最近参加了一个诗歌朗诵比赛。评委会打出一个整数数值的评分，分越高获奖的可能性越大，且存在分值相同的情况。由于所有参赛选手只能看到在自己前面朗诵的选手的分值，他们心里都在计算自己前面有多少选手分不如自己高。请你帮这些选手们计算一下。

输入描述

第一行输入一个正整数 n ，表示参赛人数。

第二行内输入 n 个正整数，用空格间隔，依次表示所有选手的得分。

输出描述

输出 n 个整数，用空格间隔，依次表示每个参赛选手前面有多少人比他得分低。

#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
int main(){
	int n,a[110];
	cin>>n;
	for(int i=1;i<=n;i++){
	    cin>>a[i];
	    int cnt=0;
	    for(int j=1;j<i;j++){
	      if(a[i]>a[j]){
	        cnt++;
	      }
	   }
	   cout<<cnt<<" ";
}
	return 0;
}

质数的最大距离

题目描述

给定一个正整数n，表示数组中元素个数，给定数组中n个元素，求两个质数在数组中下标的最大距离。

两个质数是不一定不同的。

输入描述

第一行输入一个整数 n（1≤n≤300000）第二行输入 n 个整数（1≤整数≤1000），整数之间以一个空格隔开

输出描述

输出一个整数，表示数组中两个质数的最大距离

#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
int zs(int x){
    int f=1;
	for(int i=2;i<=x-1;i++){
	    if(x%i==0){
	       f=0;
	       	break;
	}
}
if(f==1){
   return 1; 
}
else{
    return 0;
}
}
int main(){
	int n,c=0,t;
	int a[350000];
	cin>>n;
	for(int i=1;i<=n;i++){
	    cin>>t;
	    if(zs(t)==1){
	        a[++c]=i;
	    }
	}
	if(c>1){
	    cout<<a[c]-a[1];
	}
	else{
	    cout<<"0";
	}
	return 0;
}

分析数据

题目描述

小可是一名数据分析师，她手里有一份表格，记录了工人们某次安全意识测验的成绩，包括工人的工号、姓名、分数。需要小可对这份表格进行排序，以便进一步分析数据。

输入描述

测试输入包含若干测试用例。每个测试用例的第1行包含两个整数 N 和 M，其中 N 是纪录的条数，M 是指定排序的列号。以下有 N 行，每行包含一条成绩纪录。每条成绩纪录由工号、姓名、成绩三项组成，每个项目间用1个空格隔开。当读到 N=0 时，全部输入结束，相应的结果不要输出。

输出描述

对每个测试用例，首先输出1行“Case i:”，其中 i 是测试用例的编号（从1开始）。随后在 N 行中输出按要求排序后的结果，即：当 M=1 时，按工号递增排序；当 M=2 时，按姓名的非递减字典序排序；当 M=3 时，按成绩的非递减排序。当若干工人具有相同姓名或者相同成绩时，则按他们的工号递增排序。

#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
struct stu{
    int gh;
    string mz;
    int cj;
}c[110000];
bool cmp1(stu a,stu b){
    return a.gh<b.gh;
}
bool cmp2(stu a,stu b){
    if(a.mz==b.mz){
        return a.gh<b.gh;
    }
    else{
        return a.mz<b.mz;
    }
}
bool cmp3(stu a,stu b){
    if(a.cj==b.cj){
        return a.gh<b.gh;
    }
    else {
        return a.cj<b.cj;
    }
}
int main(){
	int n,m,cnt=0;
	while(cin>>n>>m){ 
	cnt++;
	if(n==0){
	       return 0;
	    }
		for(int i=1;i<=n;i++){
			 cin>>c[i].gh>>c[i].mz>>c[i].cj;
		}
	   if(m==1){
	       sort(c+1,c+n+1,cmp1);
	   }
	   if(m==2){
	       sort(c+1,c+n+1,cmp2);
	   }
	   if(m==3){
	       sort(c+1,c+n+1,cmp3);
	       
	   }  
	   cout<<"Case "<<cnt<<":"<<endl;
	   for(int i=1;i<=n;i++){
	       printf("%06d",c[i].gh);
	           cout<<" "<<c[i].mz<<" "<<c[i].cj;
	           cout<<endl;
	       }
	}
	
	return 0;
}

开枪射击

题目描述

小可来到射击场进行体验，面向一堆固定靶进行射击，请问最少使用几发子弹可以击中每个靶子？

现在已知每个靶子的宽度（使用区间进行表示），且每个靶子都是高度相同的。

可以假定每发子弹射出后，无限制的向前移动（即可以遇到靶子就击中，然后再持续向前），且不会偏移。

例如：

已知有四个靶子，每个靶子宽度：[9,25],[7,16],[2,8],[1,3]，此时需要使用 22 发子弹才可以击中。

第一发子弹击中靶子[1,3],[2,8]，第二发子弹击中靶子[7,16],[9,25]。

输入描述

第一行输入一个 N，表示靶子数量。

下面输入 N 行，每行两个整数[l,r]，表示每个靶子的宽度区间。

输出描述

输出一行，包含一个整数，表示最少使用几发子弹可以击中每个靶子。

#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
struct stu{
    int l;
    int r;
}c[110000];
bool cmp1(stu a,stu b){
    return a.r<b.r;
}

int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>c[i].l>>c[i].r;
    }
    sort(c+1,c+n+1,cmp1);
    int pos=c[1].r,cnt=1;
    for(int i=2;i<=n;i++){
        if(pos<c[i].l){
            cnt++;
            pos=c[i].r;
        }
    }
    cout<<cnt;
	return 0;
}

字符串中最长的连续出现的字符

题目描述

求一个字符串中最长的连续出现的字符，输出该字符及其出现次数。字符串中无空白字符（空格、回车和tab），如果这样的字符不止一个，则输出出现最早的字符。

输入描述

一行，一个不包含空白字符的字符串，字符串长度小于200。

输出描述

一行，输出最长的连续出现的字符及其最长的连续出现次数，中间以一个空格分开。

#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
int main(){
	string a;
	int sum=1,maxx=0;
	char t;
	cin>>a;
	for(int i=0;i<a.size();i++){
	    if(a[i]==a[i+1]){
	        sum++;
	    }
	    else{
	        if(maxx<sum){
	            maxx=sum;
	            t=a[i];
	        }
	        sum=1;
	    }
	}
	cout<<t<<" "<<maxx;
	return 0;
}

小可喜欢的数

题目描述：

如果一个数字各个位之和是一个质数，那么这就是小可喜欢的数！例如102的各个位之和 = 1 + 0 + 2 等于3，而3是一个质数，所以102是小可喜欢的数。而123的各个位之和等于6，6不是一个质数，那么123就不是小可喜欢的数。

给定两个整数n,m(1 < n < m < 10000)，求n到m的范围内有多少个小可喜欢的数！

输入描述：

第一行,输入两个整数n,m(1 < n < m < 10000)

输出描述：

一个整数，代表n到m的范围内小可喜欢的数的个数！

#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
int s[11000],p[11000],cnt,sum,n,m;
int prime(int n){
    for(int i=2;i<n;i++){
        if(n%i==0){
            return 0;
        }   
    }
    return 1;
}
int swfl(int n){
    int ans=0;
    while(n!=0){
        int t=n%10;
        n/=10;
        ans+=t;
    }
    return ans;
}
int main(){
	cin>>n>>m;
	for(int i=n;i<=m;i++){
	    int y=swfl(i);
	    if(prime(y)){
	        sum++;
	    }
	}
	cout<<sum;
	return 0;
}

逃跑

题目描述：

小可正被暗杀组织追杀。有连续的 n 个位置，编号从 1 到 n。每个位置上可能有暗杀组织的成员，也可能没有。只要小可从第1个位置移动到第n个位置，小可就安全了。如果小可走到有暗杀组织成员的位置，小可就会被抓住。我们用 0 表示有暗杀组织成员的位置，用 1 表示没有暗杀组织成员的位置。小可只有一次机会，可以从位置 i 直接传送到位置 i + m，这需要消耗 m 块能量石，而相邻位置之间的移动是不需要消耗能量石的。同时保证第一个位置和最后一个位置没有暗杀组织的成员！问小可最少需要多少块能量石才能成功逃脱？

输入描述：

第一行，一个整数t （ 1 < t < 100），表示测试数据的组数。

每组数据的第一行包括一个整数n（1 < n < 100），表示位置数。

第二行有n个整数0或者1，其中0表示这个位置有暗杀组织成员，1表示这个位置没有暗杀组织成员。

输出描述：

对于每组测试数据输出一行一个整数表示问题的答案。

#include<iostream>
#include<cstdio> 
using namespace std;
int main(){
    int n,t,a[110];
    cin>>t;
    for(int i=1;i<=t;i++){
        cin>>n;
        for(int j=1;j<=n;j++){
            cin>>a[j];
        }
        int l=1,r=n;
        while(l<r){
	        if(l+1<=n&&a[l+1]==1){
	            l++;
	        }
	        else if(r-1>=1&&a[r-1]==1){
	            r--;
	        }
	        else{
	            break;
	        }
	    }
        cout<<r-l<<endl;
    }
	return 0;
}

花式完成作业

题目描述

小可正在完成他的假期作业，因为作业太多，小可有些垂头丧气。突然小可想到了一个绝妙的办法，把不同科目的作业区分之后分别放在左右两侧不同位置上，然后开始左右摇摆写作业，具体规则如下：

首先小可选择一个方向完成距离最近一个科目的作业，

然后小可转向继续完成另一个方向距离最近且没有被完成的一个科目的作业，

不断重复这个过程，直至规则不满足停止，请问小可最多可以完成多少本作业。

输入描述

第一行一个数字 n ，表示科目的数量。

然后输入 n 行，每行两个数字 x 和 k，x 表示方向（正数时表示右方向，负数时表示左方向），k 表示作业每个科目作业的本数。

输出描述

输出小可最多可以做完多少本作业？

#include<iostream>
#include<cstdio> 
#include<iostream>
#include<iomanip>
#include<cmath> 
#include<string>
#include<algorithm> 
#include<cstdio>
#include<queue>
#include<map>
#include<vector>
using namespace std;
struct nd{
    int x,k;
}a[110000],b[110000];
bool cmp1(nd a,nd b){
    return a.x<b.x;
}
bool cmp2(nd a,nd b){
    return a.x>b.x;
}
int main(){
    int n,x,y,cnt1=0,cnt2=0;
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>x>>y;
        if(x<0){
            a[++cnt1].x=x;
            a[cnt1].k=y;
        }
        else{
             b[++cnt2].x=x;
            b[cnt2].k=y;
        }
    }
        sort(a+1,a+cnt1+1,cmp2);
        sort(b+1,b+cnt2+1,cmp1);
        int sum=0;
        for(int j=1;j<=min(cnt1,cnt2);j++){
            sum+=a[j].k+b[j].k;
        } 
        if(cnt1>cnt2){
                sum+=a[cnt2+1].k;
            }
            else{
                sum+=b[cnt1+1].k;
            }
        cout<<sum;
	return 0;
}