【蓝桥杯】蓝桥杯入门训练+蓝桥杯基础训练

野性酷女 2022-12-03 01:59 551阅读 0赞

## BEGIN-1 A+B问题 ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
输入A、B，输出A+B。  
输入格式  
输入的第一行包括两个整数，由空格分隔，分别表示A、B。  
输出格式  
输出一行，包括一个整数，表示A+B的值。  
样例输入  
12 45  
样例输出  
57  
数据规模与约定  
\-10000 <= A, B <= 10000。

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
    	int a, b;
    	scanf("%d %d", &a, &b);
    	printf("%d", a + b);
    	return 0;
    }

## BEGIN-2 序列求和 ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
求1+2+3+…+n的值。  
输入格式  
输入包括一个整数n。  
输出格式  
输出一行，包括一个整数，表示1+2+3+…+n的值。  
样例输入  
4  
样例输出  
10  
样例输入  
100  
样例输出  
5050  
数据规模与约定  
1 <= n <= 1,000,000,000。

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
    	long long n;
    	cin>>n;
    	cout<<n * (n + 1) / 2;
    	return 0;
    }

## BEGIN-3 圆的面积\* ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
给定圆的半径r，求圆的面积。  
输入格式  
输入包含一个整数r，表示圆的半径。  
输出格式  
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。  
样例输入  
4  
样例输出  
50.2654825  
数据规模与约定  
1 <= r <= 10000。

#include<bits/stdc++.h>
    using namespace std;
    const double pi = acos(-1);
    int main()
    {
        
    	double r;
    	cin>>r;
    	printf("%.7f", pi * r * r);
    	return 0;
    }

**【注】求派：`const double pi = acos(-1);`**

## BEGIN-4 Fibonacci数列\* ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。  
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。  
输入格式  
输入包含一个整数n。  
输出格式  
输出一行，包含一个整数，表示Fn除以10007的余数。  
样例输入  
10  
样例输出  
55  
样例输入  
22  
样例输出  
7704  
数据规模与约定  
1 <= n <= 1,000,000。

#include<bits/stdc++.h>
    using namespace std;
    int F[1000007];
    int main()
    {
        
    	int n;
    	F[1] = F[2] = 1;
    	for(int i = 3; i <= 1000000; i++)
    		F[i] = (F[i - 1] + F[i - 2]) % 10007; 
    	cin>>n;
    	cout<<F[n];
    	return 0;
    }

**【注】斐波那契数列取模用数组不超时**

## BASIC-1 闰年判断 ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
给定一个年份，判断这一年是不是闰年。

当以下情况之一满足时，这一年是闰年：

1.  年份是4的倍数而不是100的倍数；
2.  年份是400的倍数。

其他的年份都不是闰年。

输入格式  
输入包含一个整数y，表示当前的年份。  
输出格式  
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。  
说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。

样例输入  
2013  
样例输出  
no  
样例输入  
2016  
样例输出  
yes  
数据规模与约定  
1990 <= y <= 2050。

#include<iostream>
    using namespace std;
    //BASIC-1	闰年判断
    int main()
    {
        
    	int n;
    	scanf("%d", &n);
    	if(n % 400 == 0 || n % 4 == 0 && n % 100 != 0)
    		printf("yes");
    	else
    		printf("no");
    	return 0;
    }

## BASIC-2 01字串\* ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：

00000

00001

00010

00011

00100

请按从小到大的顺序输出这32种01串。

输入格式  
本试题没有输入。  
输出格式  
输出32行，按从小到大的顺序每行一个长度为5的01串。  
样例输出  
00000  
00001  
00010  
00011  
<以下部分省略>

#include<iostream>
    using namespace std;
    //BASIC-2	01字串
    int main()
    {
        
    	int a, b, c, d, e;
    	for(a = 0; a < 2; a++)
    		for(b = 0; b < 2; b++)
    			for(c = 0; c < 2; c++)
    				for(d = 0; d < 2; d++)
    					for(e = 0; e < 2; e++)
    						cout<<a<<b<<c<<d<<e<<endl;
    	return 0;
    }

**【注】输出5位01字串，暴力循环**

## BASIC-3 字母图形\* ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
利用字母可以组成一些美丽的图形，下面给出了一个例子：

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式  
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。  
输出格式  
输出n行，每个m个字符，为你的图形。  
样例输入  
5 7  
样例输出  
ABCDEFG  
BABCDEF  
CBABCDE  
DCBABCD  
EDCBABC  
数据规模与约定  
1 <= n, m <= 26。

#include<iostream>
    #include<math.h>
    using namespace std;
    //BASIC-3	字母图形
    int main()
    {
        
    	int n, m;
    	cin>>n>>m;
    	for(int i = 0; i < n; i++)
    	{
        
    		for(int j = 0; j < m; j++)
    			cout<<(char)(abs(i - j) + 65);
    		cout<<endl;
    	}
    	return 0;
    }

**【注】abs函数在头文件`#include<math.h>`里，ASCII码表 48 - 0 | 65 - A | 97 - a**

## BASIC-4 数列特征\* ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
给出n个数，找出这n个数的最大值，最小值，和。

输入格式  
第一行为整数n，表示数的个数。

第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。

输出格式  
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。  
样例输入  
5  
1 3 -2 4 5  
样例输出  
5  
\-2  
11  
数据规模与约定  
1 <= n <= 10000。

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-4	数列特征
    int a[10008];
    int main()
    {
        
    	int n, b = -inf, c = inf, sum = 0;
    	cin>>n;
    	for(int i = 1; i <= n; i++)
    	{
        
    		cin>>a[i];
    		b = max(b, a[i]);
    		c = min(c, a[i]);
    		sum += a[i];
    	}
    	cout<<b<<endl<<c<<endl<<sum;
    	return 0;
    }

**【注】“每个数的绝对值都小于10000”，所以最大值b的初值不能设为0，至少为-10001，在此更保险设为-inf：`const int inf = 0x3f3f3f3f;`  
inf是一个神奇的int范围内的无穷大，具体参考[这篇博客][Link 1]**

## BASIC-5 查找整数 ##

资源限制  
时间限制：1.0s 内存限制：256.0MB  
问题描述  
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

输入格式  
第一行包含一个整数n。

第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

第三行包含一个整数a，为待查找的数。

输出格式  
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。  
样例输入  
6  
1 9 4 8 3 9  
9  
样例输出  
2  
数据规模与约定  
1 <= n <= 1000。

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-5	查找整数
    int main()
    {
        
    	int n, a, b[1007], flag = 0;
    	scanf("%d", &n);
    	for(int i = 1; i <= n; i++)
    		scanf("%d", &b[i]);
    	scanf("%d", &a);
    	for(int i = 1; i <= n; i++)
    	{
        
    		if(a == b[i])
    		{
        
    			printf("%d", i);
    			flag = 1;
    			break;
    		}
    	}
    	if(!flag)
    		printf("-1");
    	return 0;
    }

## BASIC-6 杨辉三角形 ##

问题描述  
杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)^i的展开式的系数。  
它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。  
下面给出了杨辉三角形的前4行：  
1  
1 1　  
1 2 1  
1 3 3 1  
给出n，输出它的前n行。  
输入格式  
输入包含一个数n。  
输出格式  
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。  
样例输入  
4  
样例输出  
1  
1 1  
1 2 1  
1 3 3 1  
数据规模与约定  
1 <= n <= 34。

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-6	杨辉三角形
    int main()
    {
        
    	int n, a[40][40];
    	cin>>n;
    	for(int i = 1; i <= n; i++)
    	{
        
    		a[i][1] = a[i][i] = 1;
    		for(int j = 2; j < i; j++)
    			a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
    	}
    	for(int i = 1; i <= n; i++)
    	{
        
    		printf("%d", a[i][1]);
    		for(int j = 2; j <= i; j++)
    			printf(" %d", a[i][j]);
    		printf("\n");
    	}
    	return 0;
    }

## BASIC-7 特殊的数字 ##

资源限制  
时间限制：1.0s 内存限制：512.0MB  
问题描述  
　　153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。  
输出格式  
　　按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-7	特殊的数字
    int main()
    {
        
    	for(int i = 100; i <= 999; i++)
    	{
        
    		int tmp = i, a, b, c;
    		a = tmp % 10;
    		tmp /= 10;
    		b = tmp % 10;
    		tmp /= 10;
    		c = tmp;
    		if(i == a * a * a + b * b * b + c * c * c)
    			printf("%d\n", i);
    	}
    	return 0;
    }

**【注】3位水仙花数：153、370、371、407**

## BASIC-8 回文数 ##

资源限制  
时间限制：1.0s 内存限制：512.0MB  
问题描述  
　　1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。  
输出格式  
　　按从小到大的顺序输出满足条件的四位十进制数。

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-8	回文数
    int main()
    {
        
    	for(int i = 1000; i <= 9999; i++)
    	{
        
    		int a, b, c, d, tmp = i;
    		a = tmp % 10;
    		tmp /= 10;
    		b = tmp % 10;
    		tmp /= 10;
    		c = tmp % 10;
    		tmp /= 10;
    		d = tmp;
    		if(d == a &&  c == b)
    			printf("%d\n", i);
    	}
    	return 0;
    }

## BASIC-9 特殊回文数\* ##

资源限制  
时间限制：1.0s 内存限制：512.0MB  
问题描述  
　　123321是一个非常特殊的数，它从左边读和从右边读是一样的。  
　　输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。  
输入格式  
　　输入一行，包含一个正整数n。  
输出格式  
　　按从小到大的顺序输出满足条件的整数，每个整数占一行。  
样例输入  
52  
样例输出  
899998  
989989  
998899  
数据规模和约定  
　　1<=n<=54。

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-9	特殊回文数
    int main()
    {
        
    	int n;
    	scanf("%d", &n);
    	for(int i = 10000; i <= 99999; i++)
    	{
        
    		int a, b, c, d, e, tmp = i;
    		a = tmp % 10;
    		tmp /= 10;
    		b = tmp % 10;
    		tmp /= 10;
    		c = tmp % 10;
    		tmp /= 10;
    		d = tmp % 10;
    		tmp /= 10;
    		e = tmp;
    		if(e == a && d == b && (a + b + c + d + e == n))
    			printf("%d\n", i);
    	}
    	for(int i = 100000; i <= 999999; i++)
    	{
        
    		int a, b, c, d, e, f, tmp = i;
    		a = tmp % 10;
    		tmp /= 10;
    		b = tmp % 10;
    		tmp /= 10;
    		c = tmp % 10;
    		tmp /= 10;
    		d = tmp % 10;
    		tmp /= 10;
    		e = tmp % 10;
    		tmp /= 10;
    		f = tmp;
    		if(f == a && e == b && d == c && (a + b + c + d + e + f == n))
    			printf("%d\n", i);
    	}
    	return 0;
    }

**【注】回文数长度为奇数和偶数的要分开算**

## BASIC-10 十进制转十六进制\* ##

资源限制  
时间限制：1.0s 内存限制：512.0MB  
问题描述  
　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。  
　　给出一个非负整数，将它表示成十六进制的形式。  
输入格式  
　　输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647  
输出格式  
　　输出这个整数的16进制表示  
样例输入  
30  
样例输出  
1E

法1：

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-10	十进制转十六进制
    char x[20] = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; 
    int main()
    {
        
    	int a, b, t = 0;
    	char c[10];
    	cin>>a; 
    	b = a;
    	while(b >= 16)
    	{
        
    		c[t] = x[b % 16];
    		b /= 16;
    		t++;
    	}
    	c[t] = x[b];
    	for(int i = t; i >= 0; i--)
    		printf("%c", c[i]);
    	return 0;
    }

**【注】10进制转16进制，int最大值10进制10位数2147483648，对应16进制8位数7fffffff，开c\[10\]的数组就够用， 最后倒着输出**

法2：

#include<iostream>
    #include<math.h>
    #include<iomanip>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-10	十进制转十六进制
    int main()
    {
        
    	int a;
    	cin>>a;
    	cout<<setiosflags(ios::uppercase)<<hex<<a;
    	return 0;
    }

**【注】这是C++偷懒的做法，也能过。。但16进制大写输出要加头文件`#include<iomanip>`，详见[这篇博客][Link 2]**

法3：用这个吖！！！！

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    //BASIC-10	十进制转十六进制
    int main()
    {
        
    	int a;
    	scanf("%d", &a);
    	printf("%X", a);
    	return 0;
    }

**【注】这是C偷懒的做法，也能过。。**

## BASIC-11 十六进制转十进制 ##

资源限制  
时间限制：1.0s 内存限制：512.0MB  
问题描述  
　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。  
　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。  
样例输入  
FFFF  
样例输出  
65535

#include<iostream>
    #include<math.h>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    typedef long long ll;
    // BASIC-11	十六进制转十进制
    int main()
    {
        
    	ll a;
    	scanf("%llX", &a);
    	printf("%lld", a);
    	return 0;
    }

**【注】不超过8位的16进制数转换成10进制数有可能爆int，所以必须用long long才能过**

## BASIC-12 十六进制转八进制 ##

资源限制  
时间限制：1.0s 内存限制：512.0MB  
问题描述  
　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式  
　　输入的第一行为一个正整数n （1<=n<=10）。  
　　接下来n行，每行一个由0-9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式  
　　输出n行，每行为输入对应的八进制正整数。

【注意】  
　　输入的十六进制数不会有前导0，比如012A。  
　　输出的八进制数也不能有前导0。

样例输入  
　　2  
　　39  
　　123ABC

样例输出  
　　71  
　　4435274

【提示】  
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

#include<iostream>
    #include<math.h>
    #include<string.h>
    #include<algorithm>
    using namespace std;
    const int inf = 0x3f3f3f3f;
    typedef long long ll;
    //BASIC-12	十六进制转八进制
    string h[20] = {
        "0000", "0001", "0010", "0011", 
    				"0100", "0101", "0110", "0111", 
    				"1000", "1001", "1010", "1011",
    				"1100", "1101", "1110", "1111"};
    string o[10] = {
        "000", "001", "010", "011", "100", "101", "110", "111"};
    int main()
    {
        
    	int n;
    	cin>>n;
    	while(n--) 
    	{
        
    		string s1, s2, s3, s4;
    		cin>>s1;
    		for(int i = 0; i < s1.size(); i++)
    		{
        
    			if(s1[i] <= '9')
    				s2.append(h[(int)s1[i] - 48]); 
    			else if(s1[i] >= 'A')
    				s2.append(h[(int)s1[i] - 55]);	
    		}
    		reverse(s2.begin(), s2.end ());
    		int t = s1.size() * 4 % 3;
    		if(t == 1)
    			s2.append("00");
    		else if(t == 2)
    			s2.append("0");
    		reverse(s2.begin(), s2.end ());
    		for(int i = 0; i <= s2.size() - 3; i += 3)
    		{
        
    			s3 = s2.substr(i, 3);
    			for(int j = 0; j < 8; j++)
    				if(s3 == o[j])
    					s4.push_back((char)(j + 48));
    		}
    		int i;
    		for(i = 0; i < s4.size(); i++)
    		{
        
    			if(s4[i] != '0')
    				break;
    		}
    		for(int j = i; j < s4.size(); j++)
    			cout<<s4[j];
    		cout<<endl;
    	}
    	return 0;
    }

**【注】reverse (s.begin(),s.end ()); 反向排序函数，即字符串反转函数，在\#include头文件里，字符串常用基本操作参考[这篇博客][Link 3]**  
感觉用的方法有点蠢。。。

## BASIC-13 数列排序 ##

资源限制  
时间限制：1.0s 内存限制：512.0MB  
问题描述  
　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200  
输入格式  
　　第一行为一个整数n。  
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。  
输出格式  
　　输出一行，按从小到大的顺序输出排序后的数列。  
样例输入  
5  
8 3 6 4 9  
样例输出  
3 4 6 8 9

#include<iostream>
    #include<algorithm>
    using namespace std;
    //BASIC-13	数列排序
    int main()
    {
        
    	int n, a[204];
    	scanf("%d", &n);
    	for(int i = 1; i <= n; i++)
    		scanf("%d", &a[i]);
    	sort(a + 1, a + 1 + n);
    	for(int i = 1; i <= n; i++)
    		printf("%d ", a[i]);
    	return 0;
    }

**【注】sort函数在头文件`#include<algorithm>`里**

[Link 1]: https://blog.csdn.net/jiange_zh/article/details/50198097
[Link 2]: https://blog.csdn.net/qq_45878292/article/details/108350212
[Link 3]: https://blog.csdn.net/qq_45878292/article/details/108369307