蓝桥杯基础练习

奇树谦

已于 2024-07-16 18:33:01 修改

阅读量683

点赞数

文章标签：算法 c++

于 2020-03-20 21:59:59 首次发布

本文链接：https://blog.csdn.net/weixin_42964413/article/details/104068171

版权

文章目录

闰年判断
01字串
字母图形
数列特征
查找整数
杨辉三角形
特殊的数字
回文数
- - 解题思路：
  - 示例代码：

蓝桥杯基础练习

闰年判断

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

解题步骤：
定义函数：创建一个名为IsLeapYear的函数，接受一个整数参数y，代表需要判断的年份。
判断条件：在函数内部，使用逻辑运算符来判断年份是否满足上述两个条件之一。
返回结果：根据判断结果，返回true或false。

#include <iostream>
using namespace std;
int IsLeapYear(int y) //判断是否位闰年
{
	return (y % 100 != 0 && y % 4 == 0) || (y % 400 == 0);
}
int main()
{
	int year = 0;
	cin >> year;
	int check = IsLeapYear(year);
	if (0 == check)
		cout << "no";
	else
		cout << "yes";
	return 0;
}

01字串

输出长度为5位的01字符串 32行
要输出长度为5位的01字符串共32行，我们可以使用嵌套循环来生成所有可能的组合。每个字符串由5个位组成，每一位可以是0或1。总共有32种不同的组合，正好对应题目要求的32行。
下面是解题思路和示例代码：
解题思路：
初始化变量：使用5个变量，每个变量代表一个位的位置，初始值都为0。
外层循环：从0到1循环5次，每次循环代表一个位的位置从0变为1。
内层循环：对于外层循环的每次迭代，使用4个内层循环来生成剩余位的所有组合。
输出结果：在每次内层循环结束后，输出当前生成的01字符串。
换行：每输出一行后，输出一个换行符以开始新的一行。

#include <iostream>
using namespace std;
int main()
{
	int array[5] = { 0 };
	for (array[0] = 0; array[0] <= 1; array[0]++)
	{
		for (array[1] = 0; array[1] <= 1; array[1]++)
		{
			for (array[2] = 0; array[2] <= 1; array[2]++)
			{
				for (array[3] = 0; array[3] <= 1; array[3]++)
				{
					for (array[4] = 0; array[4] <= 1; array[4]++)//大于1时跳出循环
					{
						cout << array[0] << array[1] << array[2] << array[3] << array[4] << endl;
					}
				}
			}
		}
	}
	return 0;
}

字母图形

利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

这个字母图形的规律是每一行的字符串都是由字母A到字母G组成的，且每行的起始字母依次向后移动一个位置。同时，每一行的字符串都是对称的，即从前向后和从后向前读都是一样的。

解题思路：
接收输入：首先，我们需要从用户那里获取行数n和列数m。
初始化字符：确定起始字符为A，即char start = ‘A’。
生成每一行：对于每一行，我们需要生成一个对称的字符串。
前半部分：从start开始，逐个打印字符直到start + (m/2 - 1)。
后半部分：如果m是奇数，中间的字符是start + m/2，然后从start + (m/2 - 1)打印回start。
输出每一行：将生成的字符串输出到控制台。

//1
#include <iostream>
#include <string>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m; // 接收用户输入的行数和列数

    for (int i = 0; i < n; ++i) {
        string row; // 存储每一行的字符串
        char start = 'A' + i; // 计算起始字符

        // 生成前半部分
        for (int j = 0; j < m / 2; ++j) {
            row += start + j;
        }

        // 如果列数是奇数，添加中间的字符
        if (m % 2 != 0) {
            row += start + (m / 2);
        }

        // 生成后半部分（如果需要）
        for (int j = m / 2 - 1; j >= 0; --j) {
            row += start + j;
        }

        // 输出当前行
        cout << row << endl;
    }

    return 0;
}
//2
#include <iostream>
#include<math.h>
using namespace std;
int main()
{
	int m, n;
	cin >> m >> n;
	char a[30][30];
	int linenum = 0;
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			a[i][j] = 'A' + abs(linenum + j);
			cout << a[i][j];
		}
		linenum--;
		cout << endl;
	}
	return 0;
}

数列特征

数列特征的题目要求我们找出一个整数数组中的最大值、最小值以及所有元素的总和。以下是解题思路和示例代码：

解题思路：

读取输入：首先，我们需要从用户那里获取数组的长度n，然后读取n个整数到数组a中。
初始化变量：使用变量max和min来存储最大值和最小值，初始值可以设为数组的第一个元素。使用变量sum来存储所有元素的总和，初始值设为0。
遍历数组：使用一个循环遍历数组中的每个元素。
在每次循环中，如果当前元素大于max，则更新max的值。
如果当前元素小于min，则更新min的值。
同时，将当前元素加到sum上。
输出结果：循环结束后，输出最大值、最小值和总和。

//1
//这段代码使用了C++标准库中的max_element和min_element函数来简化最大值和最小值的查找过程。
//当然，如果你需要不使用额外的库函数，可以手动遍历数组来找到最大值和最小值，就像你提供的代码示例那样。
//不过，使用标准库函数可以使代码更加简洁和高效。
#include <iostream>
#include <algorithm> // 引入算法库，使用min和max函数
using namespace std;

int main() {
    int n;
    cin >> n; // 读取数组长度
    int a[n]; // 根据输入动态创建数组
    int max = a[0], min = a[0], sum = 0;

    // 读取数组元素并初始化sum
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        sum += a[i];
    }

    // 找出最大值和最小值
    max = *max_element(a, a + n);
    min = *min_element(a, a + n);

    // 输出结果
    cout << max << endl << min << endl << sum << endl;

    return 0;
}

//2
#include <iostream>
using namespace std;

int main()
{
	int n, a[10000], max,min,sum=0;
	cin >> n;
	for (int i=0; i < n; i++) {
		cin >> a[i];
	}
	max = a[0];
	min = a[0];
	for (int i = 0; i <n; i++) {
		if (max < a[i]) 
			max = a[i];
		if (min > a[i]) 
			min = a[i];
		sum += a[i];
	}
	cout << max << endl << min << endl << sum << endl;
}

查找整数

查找整数的题目要求我们在给定的整数数组中查找特定的整数m，并输出它在数组中首次出现的索引加1（如果找到的话）。如果没有找到，则输出-1。

解题思路：

读取输入：首先，我们需要从用户那里获取数组的长度n，然后读取n个整数到数组a中。接着，读取需要查找的整数m。
初始化变量：使用变量b来存储是否找到整数m，初始值设为0（表示未找到）。
遍历数组：使用一个循环遍历数组中的每个元素。
在每次循环中，检查当前元素是否等于m。如果是，则将b设置为当前元素的索引加1，并使用break跳出循环。
输出结果：循环结束后，如果b不为0，则输出b；否则，输出-1。

#include <iostream>
using namespace std;

int main() {
    int n, m, b = 0;
    cin >> n; // 读取数组长度
    int a[n]; // 根据输入动态创建数组

    // 读取数组元素
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    cin >> m; // 读取需要查找的整数

    // 查找整数m
    for (int i = 0; i < n && b == 0; ++i) {
        if (a[i] == m) {
            b = i + 1; // 找到整数m，记录索引加1
            break; // 跳出循环
        }
    }

    // 输出结果
    cout << (b != 0 ? b : -1) << endl; // 使用三元运算符简化输出

    return 0;
}

杨辉三角形

杨辉三角形，又称帕斯卡三角形，是一个由数字组成的三角形数阵。每行的数字从1开始，并且每个数字是它正上方和左上方两个数字的和。下面是生成杨辉三角形的解题思路和示例代码：

解题思路：

初始化数组：创建一个二维数组a，其大小为n行n列，用于存储杨辉三角形的数字。
边界条件：杨辉三角形的每行的第一个和最后一个数字都是1。
填充数组：使用嵌套循环填充数组。对于数组的每个元素a[i][j]，它的值是a[i-1][j-1]和a[i-1][j]的和，除非它是第一列或最后一列，这时它的值是1。
输出结果：遍历数组，输出每一行的数字。

//1
//这段代码首先读取用户输入的行数n，然后初始化一个n行n列的二维数组，并按照杨辉三角形的规则填充数组。
//最后，它遍历并输出整个数组，每行元素后面跟一个空格，每行结束后换行。
#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n; // 读取杨辉三角形的行数
    int a[n][n]; // 创建二维数组

    // 初始化杨辉三角形的第一列和最后一列
    for (int i = 0; i < n; ++i) {
        a[i][0] = 1;
        a[i][n - 1] = 1;
    }

    // 填充杨辉三角形的其它值
    for (int i = 2; i < n; ++i) { // 从第三行开始填充
        for (int j = 1; j < n - 1; ++j) { // 填充除第一列和最后一列外的值
            a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
        }
    }

    // 输出杨辉三角形
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cout << a[i][j] << " "; // 输出当前元素，后面跟一个空格
        }
        cout << endl; // 每行结束后换行
    }

    return 0;
}

//2
#include <iostream>
using namespace std;
int main()
{
    int a[34][34];
    int n;
    cin>>n;
    for(int i=1;i<n;i++)
        {
            a[i][0]=1;
        }
    for(int j=1;j<n;j++)
        {
            a[0][0]=1;
            a[0][j]=0;
        }
    for(int i=1;i<n;i++)
    {
        for(int j=1;j<n;j++)
        {
            a[i][j]=a[i-1][j-1]+a[i-1][j];
        }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(j>i)
            {
                cout<<" ";
            }
            else if(j<=i)
            {
            cout<<a[i][j];
            }
            if(j<i)
            {
                cout<<" ";
            }
        }
        cout<<endl;
    }
    return 0;
}

特殊的数字

"特殊的数字"通常指的是具有某些数学特性的数字，例如回文数、完全数、素数等。从你提供的代码来看，这段代码是用来找出水仙花数（也称为自幂数或阿姆斯壮数，Armstrong number），即一个n位数，其各位数字的n次幂之和等于该数本身。

水仙花数的解题思路如下：

确定数字位数：首先确定数字的位数。例如，100到999是三位数。
遍历范围内的每个数字：使用循环遍历指定范围内的每个数字。
分解数字并计算各位数字的立方和：对于每个数字，分别计算它的每一位数字，并计算这些数字的立方和。
判断是否为水仙花数：如果立方和等于原始数字，则该数字是一个水仙花数。
输出结果：如果找到水仙花数，将其输出。

//1
//这段代码将找出所有的三位数水仙花数，并将其打印出来。如果你想找出其他位数的水仙花数，
//只需更改循环的范围和立方和计算中的位数n即可。例如，对于四位数，将循环的范围设置为1000到9999，并将n设置为4。
#include <iostream>
using namespace std;

int main() {
    // 假设我们要找的是三位数的水仙花数
    for (int i = 100; i <= 999; ++i) {
        int original = i;
        int sum = 0;
        int n = 3; // 三位数的特性，即每一位数字的立方

        // 分解数字并计算立方和
        while (original > 0) {
            int digit = original % 10; // 获取当前最低位的数字
            sum += digit * digit * digit; // 累加每一位数字的立方
            original /= 10; // 去掉当前最低位
        }

        // 判断是否为水仙花数并输出
        if (sum == i) {
            cout << i << endl;
        }
    }

    return 0;
}
//2
#include <iostream>
using namespace std;

int main()
{
	for (int i = 100; i <= 999; i++) {
		int n1 = i / 100;
		int n2 = (i % 100) / 10;
		int n3 = i % 10;
		if (n1*n1*n1 + n2 * n2*n2 + n3 * n3*n3 == i)
			cout << i<<endl;
	}
}

回文数

回文数是指从前往后读和从后往前读都一样的数字。例如，数字121是一个回文数，因为它满足[ 1 \cdot 10^2 + 2 \cdot 10^1 + 1 \cdot 10^0 = 1 \cdot 10^2 + 1 \cdot 10^1 + 2 \cdot 10^0 ]。

解题思路：

确定范围：首先确定要检查的数字范围，比如四位数，即从1000到9999。
遍历数字：使用循环遍历指定范围内的每个数字。
判断是否回文：对于每个数字，通过反转数字并与原数字比较来判断是否为回文数。
输出结果：如果数字是回文数，则输出它。

示例代码：

#include <iostream>
using namespace std;

bool isPalindrome(int number) {
    int original = number;
    int reversed = 0;
    while (number > 0) {
        reversed = reversed * 10 + number % 10; // 反转数字
        number /= 10; // 去掉最后一位
    }
    return original == reversed; // 比较原数字和反转后的数字
}

int main() {
    // 假设我们要找的是四位数的回文数
    for (int i = 1000; i <= 9999; ++i) {
        if (isPalindrome(i)) {
            cout << i << endl; // 输出回文数
        }
    }
    return 0;
}

这段代码定义了一个isPalindrome函数，用于判断一个数字是否是回文数。然后在主函数中，通过循环遍历四位数的范围，并使用isPalindrome函数检查每个数字是否是回文数。如果是，就将其打印出来。

这种方法适用于任何位数的回文数检查，只需更改循环的范围即可。例如，要检查三位数的回文数，可以将循环的范围设置为100到999。

#include <iostream>
using namespace std;

int main()
{
	for (int i = 1000; i <=9999; i++) {
		int n1 = i / 1000;
		int n2 = (i % 1000) / 100;
		int n3 = ((i % 1000) % 100) / 10;
		int n4 = i % 10;
		if ((n1 == n4) && (n2 == n3))
			cout << i << endl;
   }
}

特殊回文数1

#include<iostream>
#include<cmath>
#include<iomanip>
#include<cstring>
#include<algorithm> 
#include<sstream>
using namespace std;
int main()
{
	stringstream str;
	string s;
	int n;
	cin>>n;
	for(int i = 10000;i<100000;i++)
	{
		str<<i;
		str>>s;
		if(s[0] == s[4] && s[1] == s[3] && n == (s[0]-48+s[1]-48) * 2 + s[2]-48)
		{
			cout<<i<<endl;
		}
		str.clear();
	}
	for(int i = 100000;i<1000000;i++)
	{
		str<<i;
		str>>s;
		if(s[0] == s[5] && s[1] == s[4] && s[2] == s[3] && n == (s[0]-48+s[1]-48+ s[2]-48) * 2)
		{
			cout<<i<<endl;
		}
		str.clear();
	}
	return 0;
}

特殊回文数2

#include<iostream>
using namespace std;
int main()
{
	int n;
	cin>>n;
	for(int i=10000;i<100000;i++)
	{
		int a=i%10,b=i/10%10,c=i/100%10,d=i/1000%10,e=i/10000;
		if(a+b+c+d+e==n&&a==e&&b==d)
		cout<<i<<endl;
	}
	for(int i=100000;i<1000000;i++)
		{
			int a=i%10,b=i/10%10,c=i/100%10,d=i/1000%10,e=i/10000%10,f=i/100000;
			if(a+b+c+d+e+f==n&&a==f&&b==e&&c==d)
			cout<<i<<endl;
		}
	return 0;
}

十进制转十六进制

#include<iostream>
#include<stack>
using namespace std;
void sixt_to10(stack<char> S,long long n,int base);
int main(){
    long long n;
    cin>>n;
    stack<char> S;
    sixt_to10(S,n,16);
    return 0;
}
void sixt_to10(stack<char> S,long long n,int base){
	char a[]="0123456789ABCDEF";
	if(n==0){
		S.push(a[0]);
	}
	while(n>0){
		S.push(a[n%base]);
		n/=base;
	}
	while(!S.empty()){
		cout<<S.top();
		S.pop();
	}
}

十六进制转十进制

#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
int main(){
	string str;
	cin>>str;
	int leng=str.length();
	long long sum=0;
	for(int i=leng-1;i>=0;i--){
		if(isdigit(str[i])){
			sum+=(str[i]-'0')*pow(16,leng-1-i);
		}
		else{
			sum+=(str[i]-'A'+10)*pow(16,leng-1-i);
		}	
	}
	cout<<sum;
	return 0;
}

十六进制转八进制

#include <iostream>
#include <string>  
using namespace std;  

int main()  
{  
   int n = 0, i = 0, j = 0, temp = 0, nNum = 0;  
   char ch;  
   string strHex[10];  
   string strBin[10];  
   string strOct[10];  

   cin>>n;  
   for (i = 0; i < n; ++i)  
   {  
       cin>>strHex[i];  
   } 
   for (i = 0; i < n; ++i)  
   {  
       j = 0;  
       while (strHex[i][j])  
       {  
           switch(strHex[i][j])  
           {  
           case '0': strBin[i] += "0000"; break;  
           case '1': strBin[i] += "0001"; break;  
           case '2': strBin[i] += "0010"; break;  
           case '3': strBin[i] += "0011"; break;  
           case '4': strBin[i] += "0100"; break;  
           case '5': strBin[i] += "0101"; break;  
           case '6': strBin[i] += "0110"; break;  
           case '7': strBin[i] += "0111"; break;  
           case '8': strBin[i] += "1000"; break;  
           case '9': strBin[i] += "1001"; break;  
           case 'A': strBin[i] += "1010"; break;  
           case 'B': strBin[i] += "1011"; break;  
           case 'C': strBin[i] += "1100"; break;  
           case 'D': strBin[i] += "1101"; break;  
           case 'E': strBin[i] += "1110"; break;  
           case 'F': strBin[i] += "1111"; break;  
           default:break;  
           }  
           ++j;  
       }  
   }  
   for (i = 0; i < n; ++i)  
   {  
       j = strBin[i].size()-1;
       while (strBin[i][j] && j>=0)  
       {  
           temp = 3;  
           nNum = 0;  
           while (temp-- && j>=0)  
           {  
               if ('1' == strBin[i][j])  
               {  
                   switch(temp)  
                   {  
                   case 0: nNum += 4; break;  
                   case 1: nNum += 2; break;  
                   case 2: nNum += 1; break;  
                   default:break;  
                   }  
               }  
               --j;  
           }  
           strOct[i] += (nNum+'0');  
       }  
   }  
   for (i = 0; i < n; ++i)  
   {  
       temp = strOct[i].size()-1;  
       for (j = 0; j <= temp/2; ++j)  
       {  
           ch = strOct[i][j];  
           strOct[i][j] = strOct[i][temp-j];  
           strOct[i][temp-j] = ch;  
       }  
   }   
   for (i = 0; i < n; ++i)  
   {  
       j = 0;  
       while (strOct[i][j++] == '0'); 

       for(--j; j < strOct[i].size(); ++j)  
       {  
           cout<<strOct[i][j]-'0';  
       }   
           cout<<endl;  
   }  
   return 0;  
}

数列排序

#include<iostream>
using namespace std;
int main(){
	int n,a[200],t;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
	}
	for(int i=0;i<n;i++){
		for(int j=i+1;j<n;j++){
			if(a[i]>a[j]){
				t=a[i];
				a[i]=a[j];
				a[j]=t;
			}
		}
	}
	for(int i=0;i<n;i++){
		cout<<a[i]<<" ";
	}
	return 0;
}

时间转换

#include<iostream>
using namespace std;
int main(){
	int t,h=0,m=0,s=0;
	cin>>t;
	s=t%60;
	m=t/60%60;
	h=t/60/60;
	cout<<h<<":"<<m<<":"<<s;
	return 0;
}

字符串对比

#include <iostream>
#include<string>
#include <cctype>
using namespace std;

int main()
{
	string a, b;
	cin >> a >> b;

	if (a.length() == b.length()) {
		if (a== b) {
			cout << 2;	
		}
		else if (a != b) {
			int c = 0;
			for (int i = 0; i < a.length(); i++) {
				if (tolower(a[i]) == tolower(b[i])) {
					c++;
				}
			}
			if (c == a.length())
				cout << 3;
			else if(c!=a.length())
				cout << 4;
		}		
	}
	else
		cout<<1;
}

分解质因数

#include <iostream>
#include<cmath>
using namespace std;

int zs[10001];
int k;

string qys(int m) {
	if (m == 1) return "";
	for (int i = 0; i < k; i++) {
		if (m%zs[i] == 0) {
			cout << zs[i];
			if (m / zs[i] != 1) cout << "*";
			return qys(m / zs[i]);
		}
	}
}

void zhishu(int a, int b) {
	int i, j;
	k = 0;
	for (i = 2; i <= b; i++) {
		int s = sqrt(i);
		for (j = 2; j <= s; j++)
			if (i%j == 0) break;
		if (j > s) {
			zs[k] = i;
			k++;
		}
	}
}

int main()
{
	int a, b;
	cin >> a >> b;
	zhishu(a, b);
	for (int i = a; i <= b; i++) {
		cout << i << "=";
		qys(i);
		cout << endl;
	}
	return 0;
}

奇树谦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
蓝桥杯基础练习

蓝桥杯基础练习欢迎使用Markdown编辑器你好！这是你第一次使用 Markdown编辑器所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。新的改变我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：全新的界面设计，将...
复制链接

扫一扫