蓝桥杯基础练习超全习题题解VIP版——BASIC-14~19（时间转换、字符串对比、分解质因数、矩阵乘法、矩形面积交、完美的代价）

最新推荐文章于 2021-12-08 12:00:00 发布
最新推荐文章于 2021-12-08 12:00:00 发布
阅读量404 收藏 1
点赞数 1
分类专栏： 蓝桥杯训练题题解 文章标签： c语言 算法 其他 程序人生 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44631615/article/details/104829840
版权

每日刷题（三十）

BASIC-14、时间转换

在这里插入图片描述
在这里插入图片描述
这题非常简单，这里就不做过多赘述了，详细C代码如下

#include<stdio.h>

int main()
{
	int n;
	scanf("%d", &n);
	printf("%d:%d:%d\n", n / 3600, n % 3600 / 60, n % 3600 % 60);
	return 0;
}

部分示例结果展示如下
在这里插入图片描述

在这里插入图片描述

BASIC-15、字符串对比

在这里插入图片描述
在这里插入图片描述
这个题其实给人的思路也很清晰，分四类讨论，第一个划分条件是两个字符串的长度是否相等，第二个划分条件是字符串是否相等，第三个划分条件是不考虑大小写字符串是否相等。详细C代码如下：

#include<stdio.h>
#include<string.h>
#include<math.h>

int f(char s1[], char s2[])
{
	int i, num = 0;
	for(i = 0; s1[i] != '\0'; i++)
	{
		if(abs(s1[i] - s2[i]) == 32)
			num++;
		else if(s1[i] == s2[i])
			num++;
	}
	if(num == i)
		return 1;
	else
		return 0;	
}

int main()
{
	char s1[10], s2[10];
	scanf("%s", s1);
	scanf("%s", s2);
	int c1, c2;
	c1 = strlen(s1);
	c2 = strlen(s2);
	if(c1 != c2)
		printf("1\n");
	else
	{
		if(strcmp(s1, s2) == 0)
			printf("2\n");	
		else if(f(s1, s2))
			printf("3\n");
		else
			printf("4\n");
	}
	return 0;
}

部分示例运行结果如下：
在这里插入图片描述
在这里插入图片描述

BASIC-16、分解质因数

在这里插入图片描述
在这里插入图片描述
对于这道题的题意，有一部分人可能没读懂，质因数就是这个数既是质数，同时又是组成k的乘数之一。根据样例输入可以发现一个规律，奇数的质因数绝对都是奇数，而偶数的质因数一定有2，那么就要分两种情况考虑，一种是目标数是奇数，一种是目标数是偶数，而且对于大多数数据而言，他们都有很多质因数，所以就要用变量k来装i的值，进行运算。这里还要考虑输出格式的问题，如果目标数含有两个及其以上的质因数，那么就要考虑符号的输出格式，这里我们用cnt记载有多少质因数。当只有一个时，就输出数字无须附上*，所以在奇偶条件内还要包括一层if语句，详细C代码如下：

#include<stdio.h>

int main()
{
	int n, m;
	scanf("%d %d", &n, &m);
	int i;
	int k;
	int cnt;
	for(i = n; i <= m; i++)
	{
		cnt = 0;				//质因数个数 
		printf("%d=",i);
		k = i;
		while(k != 1)
		{
			if(k % 2 == 0)		//本为偶数
			{
				
				if(cnt >= 1)
					printf("*2");
				else
					printf("2");
				k /= 2;
				cnt++; 
			} 
			else				//本为奇数 
			{
				int j;
				for(j = 3; j < m; j += 2)
				{
					if(k % j == 0)
					{
						
						if(cnt >= 1)
							printf("*%d",j);
						else
							printf("%d",j);
						k /= j;
						cnt++;
						break;
					}
				}
			}
		}
		printf("\n");
	}
}

部分示例运行结果如下：
在这里插入图片描述

BASIC-17、矩阵乘法

在这里插入图片描述
在这里插入图片描述
这个题还是很值得思考的。这里也有很多坑。
（1）要考虑幂数，如果幂为0，那么矩阵处理后就应该是单位矩阵，如果幂为1，则矩阵就是为输入的矩阵本身，当然，需要注意输出格式。
（2）要考虑如何处理已经乘完的矩阵同时又不影响乘法过程，我这里设了三个数组，a[N][N]用来继承原始数组数据，b[N][N]开始初始化时跟a数组的值一样，但之后b数组就来承接依次幂运算后的结果，c[N][N]数组用来继承每一轮矩阵乘法后的数组，等一次矩阵乘法结束后再把它的值赋给b，以便下一次矩阵运算。
（3）要考虑数组数据大小，如果数据可能超出int所能记录的范围，可以考虑全程用long long型

我这里有两款C代码，一种是普通版，一种是高阶版（用了二维指针）

普通版：

#include<stdio.h>
int N;

void f(long long a[][N], long long b[][N], long long c[][N])
{
	int i, j, t, k;
	long sum;
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			sum = 0;
			for(t = 0; t < N; t++)
			{
				sum += a[i][t] * b[t][j];
			}
			c[i][j] = sum;
		}
	}
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			b[i][j] = c[i][j];
		}
	}
}

int main()
{
	int M;
	scanf("%lld %lld", &N, &M);
	int i, j;
	long long a[N][N];
	long long b[N][N];
	long long c[N][N];
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			scanf("%lld", &a[i][j]);
			b[i][j] = a[i][j];
		}
	}
	int t;
	for(t = 1; t < M; t++)
	{
		f(a, b, c);
	}
	
	if(M > 1)
	{
		for(i = 0; i < N; i++)
		{
			for(j = 0; j < N; j++)
			{
				printf("%lld ",b[i][j]);
			}
			printf("\n"); 
		}	
	}
	else if(M == 1)
		{
			for(i = 0; i < N; i++)
			{
				for(j = 0; j < N; j++)
				{
					printf("%lld ", a[i][j]);
				}
				printf("\n"); 
			}
		}
	else if(M == 0)
		{
			for(i = 0; i < N; i++)
			{
				for(j = 0; j < N; j++)
				{
					if(i == j)
						a[i][j] = 1;
					else
						a[i][j] = 0;
					printf("%lld ", a[i][j]);
				}
				printf("\n");
			}
		}
	return 0;
}

高阶版：

#include<stdio.h>
int N;

void f(int (*p)[N], int (*q)[N], int (*k)[N])
{
	int i, j, t;
	int sum;
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			sum = 0;
			for(t = 0; t < N; t++)
			{
				sum += *(*(p + i) + t) * (*(*(q + t) + j));
			}
			*(*(k + i) + j) = sum;
		}
	}
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			*(*(q + i) + j) = *(*(k + i) + j);
		}
	}
}

int main()
{
	int M;
	scanf("%d %d", &N, &M);
	int i, j;
	int a[N][N];
	int b[N][N];
	int c[N][N];
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			scanf("%d", &a[i][j]);
			b[i][j] = a[i][j];
		}
	}
	int t;
	int (*p)[N] = a;
	int (*q)[N] = b;
	int (*k)[N] = c;
	for(t = 1; t < M; t++)
	{
		f(p, q, k);
	}
	
	if(M > 1)
	{
		for(i = 0; i < N; i++)
		{
			for(j = 0; j < N; j++)
			{
				printf("%lld ",b[i][j]);
			}
			printf("\n"); 
		}	
	}
	else if(M == 1)
		{
			for(i = 0; i < N; i++)
			{
				for(j = 0; j < N; j++)
				{
					printf("%lld ", a[i][j]);
				}
				printf("\n"); 
			}
		}
	else if(M == 0)
		{
			for(i = 0; i < N; i++)
			{
				for(j = 0; j < N; j++)
				{
					if(i == j)
						a[i][j] = 1;
					else
						a[i][j] = 0;
					printf("%lld ", a[i][j]);
				}
				printf("\n");
			}
		}
	return 0;
}

在这里插入图片描述
内存使用都一样大，第一个是高阶版，第二个是普通版的结果。

部分示例运行结果如下：
在这里插入图片描述
在这里插入图片描述

BASIC-18、矩形面积交*

在这里插入图片描述
在这里插入图片描述
这题很简单，注释里已经写的很清楚了，详细代码如下：

#include<stdio.h>

double max(double a, double b)
{
	return (a > b ? a : b);
}

double min(double a, double b)
{
	return (a < b ? a : b);
}


int main()
{
	double x1, y1, x2, y2, x3, y3, x4, y4;
	scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
	scanf("%lf %lf %lf %lf", &x3, &y3, &x4, &y4);
	double l1, l2, r1, r2;
	l1 = max(min(x1, x2), min(x3, x4));			//相交面积的左下角区域横坐标 
	l2 = max(min(y1, y2), min(y3, y4));			//相交面积的左下角区域纵坐标 
	r1 = min(max(x1, x2), max(x3, x4));			//相交面积的右上角区域横坐标
	r2 = min(max(y1, y2), max(y3, y4)); 		//相交面积的右上角区域纵坐标
	
	if(l1 < r1 && l2 < r2)
		printf("%.2lf\n", (r1 - l1) * (r2 - l2));
	else
		printf("0.00\n");	
	return 0;
}

部分示例结果如下：
在这里插入图片描述

BASIC-19、完美的代价

在这里插入图片描述
在这里插入图片描述
这个题很有价值，很有逻辑性。

这肯定要分情况讨论。
1、Impossible的情况：
      i)字符串长度N为偶数：如果存在一种字符的重复次数为奇数，那么肯定无法构成回文串；
      ii)字符串长度N为奇数：如果存在两种及其以上的字符的重复次数为奇数，那么也无法构成回文串
2、可构成回文串的情况：
      i)字符串长度N为偶数：则从第0到N/2 - 1遍历，排出回文串，并记录交换次数
      ii)字符串长度N为奇数：则从第0到N/2 - 1遍历，排出回文串，并记录交换次数，如果遇到无法匹配的数字，则设一些标识变量记录数字，保证后续可能遍历不受影响，最后再根据标识情况移动数字，并记录交换次数

详细代码如下：

#include<stdio.h>

int main()
{
	int N;
	scanf("%d", &N);
	char a[N];
	getchar();		//消化回车
	gets(a);
	int b[26] = {0};
	int i;
	for(i = 0; i < N; i++)
	{
		b[a[i] - 'a']++;
	} 
	
	int cnt = 0;
	for(i = 0; i < 26; i++)
	{
 		if(b[i] % 2)		
			cnt++;				//得出出现奇数次的字母的种类个数 
	}
	
	if(N % 2 == 0)				//字符数为偶数的字符串	 
	{
		if(cnt >= 1)
		{
			printf("Impossible\n");
			return 0;
		}	
		int k, t, j, num = 0;
		for(t = 0; t < N / 2; t++)		//循环遍历所有左边字符构造回文串 
		{
			k = N - 1 - t;
			j = k;
			while(a[t] != a[j])			//先找到与a[i]配对的字符 
			{
				j--;			
			}  
			char tmp;			//用来交换字符 
			while(j != k)
			{
				tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
				j++;
				num++;			//记录交换次数 
			} 
		}
//		for(i = 0; i < N; i++)
//			printf("%c", a[i]);
		printf("%d\n", num);
	} 
	if(N % 2)				//字符数为奇数的字符串 
	{
		if(cnt >= 2)
		{
			printf("Impossible\n");
			return 0;
		}
		int k, t, j, num = 0;
		int cn;
		k = N - 1;
		int flag = -1;
		for(t = 0; t < N / 2; t++)		//循环遍历所有左边字符构造回文串 
		{
		    cn = -1;
			j = k;
			while(a[t] != a[j])			//先找到与a[i]配对的字符 
			{
				j--;		
				if(j == t)
				{
					cn = t;
					break;
				}	
			}  
			
			char tmp;			//用来交换字符 
			if(cn != -1)
			{
				flag = t;
				continue;
			}
			else
			{
				while(j != k)
				{
					tmp = a[j];
					a[j] = a[j + 1];
					a[j + 1] = tmp;
					j++;
					num++;			//记录交换次数 
				} 
				k--;
			}	
				
		}
		if(flag < N / 2 && flag != -1)
		{
			int c1;
			int tmp1;
			for(c1 = flag; c1 < N / 2; c1++)
			{
				tmp1 = a[c1];
				a[c1] = a[c1 + 1];
				a[c1 + 1] = tmp1;
				num++;
			}
			
		}
//		for(i = 0; i < N; i++)
//			printf("%c", a[i]);
//		printf("\n");
		printf("%d\n", num);
		
	}
	 
	return 0;
}

部分示例运行结果如下：
在这里插入图片描述

如果喜欢我的文章，请记得三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持，下期更精彩！！！

源代码•宸
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础练习 分解质因数
weixin_30487201的博客
03-01 143
时间限制：1.0s 内存限制：512.0MB 问题描述 　　求出区间[a,b]中所有整数的质因数分解。 输入格式 　　输入两个整数a，b。 输出格式 　　每行输出一个数的分解，形如k=a1*a2*a3...(a1<=a2<=a3...，k也是从小到大的)(具体可看样例) 样例输入 3 10 样例输出 3=34=2*25=5...
蓝桥杯C++：BASIC30 阶层计算
MilkLeong的博客
03-09 856
关键词：高精度 问题描述： 输入一个正整数n，输出n!的值。 其中n!=123*…*n。 输入格式： 输入包含一个正整数n，n<=1000。 输出格式： 输出n!的准确值。 算法描述： n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。 将a乘以一个整数k变为将数组A的每一个元素都乘以...
2020国赛能力挑战赛java试题4-3
llx20001212的博客
12-05 649
计算机能力挑战赛java试题。小明设计了一种基于质数(2、3、5、7、11…)的变进制数，第一位为2进制，第二位为3进制，第三位为5进制，以此类推。请将该变进制数转化为十进制数。
一种基于质数(2、3、5、7、11…)的变进制数，第一位为2进制，第二位为3进制，第三位为5进制，以此类推。请将该变进制数转化为十进制数。
叶绿体不忘呼吸
12-08 693
import java.math.BigInteger; import java.util.Scanner; import static java.math.BigInteger.*; public class Main{ public static void main(String[] args){ int i, num[] = {1, 2, 6, 30, 210, 2310, 30030, 510510, 9699690, 223092870}, toDec; .
蓝桥杯基础练习 阶乘计算（简单模拟）
林下的码路
01-28 4008
Link：http://lx.lanqiao.org/problem.page?gpid=T71  基础练习 阶乘计算   时间限制：1.0s   内存限制：512.0MB 问题描述 　　输入一个正整数n，输出n!的值。 　　其中n!=1*2*3*…*n。 算法描述 　　n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。
蓝桥杯-蓝桥杯竞赛练习题-详细题解-题解源码
01-17
在“蓝桥杯_蓝桥杯竞赛练习题_详细题解_题解源码”这个压缩包中，包含了丰富的资源，帮助参赛者理解和解决竞赛中的实际问题。首先，详细的题解部分是关键，它通常会为每一道竞赛题目提供清晰的思路分析，包括问题的...
华为od-华为od练习题之求字符串字符匹配-题库题解.zip
05-08
"华为od-华为od练习题之求字符串字符匹配-题库题解.zip" 这个标题表明，这是一个与华为OD（可能是Online Judge或者某种在线编程训练平台）相关的压缩包文件，其中包含了关于字符串字符匹配的练习题目及其解答。...
华为od-华为od练习题之公共字符串计算-题库题解.zip
05-08
在IT领域，特别是软件开发和算法设计中，公共字符串计算是一项重要的基础知识，它涉及到字符串处理、数据结构和算法等多个方面。华为OD（可能是Operation Director或Online Judge的简称）的练习题常常会涵盖这类问题...
华为od-华为od练习题之矩阵乘法-题库题解.zip
05-08
在IT领域，特别是数据分析、机器学习以及计算机科学的范畴中，矩阵乘法是一个核心概念，对于理解复杂的算法和系统有着至关重要的作用。华为OD（Organizational Development，组织发展）可能在此背景下，涉及到对技术...
蓝桥杯 蓝桥杯竞赛练习题的题解
最新发布
05-23
**内容概要**：本资源提供了蓝桥杯竞赛练习题的详细题解，涵盖了不同难度和类型的题目，包括基础算法、数据结构、数学建模、动态规划、图论、字符串处理等。每道题解都包括题目描述、思路解析、代码实现和运行结果。...
Java基础编程之分解质因数
11-16 5348
将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5 程序分析 对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成： (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。 (2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。 (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
【程序14】将一个正整数分解质因数
xiaofeilong321的专栏
03-24 1832
题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：  (1)如果这个质数恰等于（小于的时候，继续执行循环）n，则说明分解质因数的过程已经结束，另外 打印出即可。 (2)但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n.重复执行第二步。 (3)如果n不
分解质因数
攀大小熊猫的专栏
03-16 1087
基础练习 分解质因数   时间限制：1.0s   内存限制：512.0MB        问题描述 　　求出区间[a,b]中所有整数的质因数分解。 输入格式 　　输入两个整数a，b。 输出格式 　　每行输出一个数的分解，形如k=a1*a2*a3...(a1 样例输入 3 10 样例输出 3=3 4=2*2 5=5
蓝桥杯算法训练超全习题题解——ALGO-142.P1103
Atticus的博客
04-10 973
每日刷题（七十一） ALGO-142、P1103 这里需要注意的就是结构体的构建以及复数的除法公式 详细C++代码如下： #include<iostream> #include<iomanip> using namespace std; struct V{ float a, b; }V1; int main() { char s; float a, b, c,...
蓝桥杯基础练习超全习题题解——BASIC-10~13题（十进制转十六进制、十六进制转十进制、十六进制转八进制、数列排序）
Atticus的博客
03-18 844
每日刷题（三十一） BASIC-10、十进制转十六进制 思路如下： 其实这根本就不算一个题，你可以直接提交一个六行代码 #include<stdio.h> int main() { int n; scanf("%d",&n); printf("%X\n", n); return 0; } 正统代码如下： #include<stdio.h> int...
蓝桥杯算法训练超全习题题解——ALGO-194.审美课**
Atticus的博客
04-07 817
每日刷题（六十一） ALGO-194、审美课 这个题绝对不可以用暴力破解法，这样会远远超出题目要求的时间。 我们可以换个角度看问题。要求答案完全相反的对数，而且给出的是1和0，我们很容易想到位运算这一类知识点。 由于最多20列，就相当于最大数是220-1，那么我们设一个数组ans来存数的种类的数目。这里有点难懂，没事，继续看就会懂了。我们首先要存数，但我们要处理一下，把传统思路的二维数组转化为...
蓝桥杯算法训练超全习题题解——ALGO-246.猴子吃包子
Atticus的博客
04-05 760
每日刷题（五十七） ALGO-246、猴子吃包子 这个题用C++做的话就会非常简单，我强烈建议如果要考蓝桥的同学如果C++不会，那从现在开始赶紧学，趁一切还来得及，C++里面有很多不错的函数，如果要自学我推荐C++ Primer Plus 详细C++代码如下： #include<iostream> #include<iomanip> using namespace st...
适合新手的蓝桥杯入门训练四道题满分超全题解
Atticus的博客
03-12 712
每日刷题（二十八） 1.Fibonacci数列 这个题千万不要用递归做，因为递归只适合做小点的数据，这里的数据范围很大，而递归一旦面对大的数据只会耗费大量内存，速度慢，因为要形成很多栈空间。 正确的方法是用非递归方式处理 #include<stdio.h> int main() { int i = 1, j = 1, sum = 0; int n, t; scanf("...
蓝桥杯微信编程题解：时间转换与字符串比较
这些题目涵盖了C语言基础、控制结构、输入输出、字符串处理和基本算法（如质数判断）等知识点，适合学习者通过实践来提升编程技能，同时也能帮助理解和巩固理论知识在实际问题中的应用。在蓝桥杯微信题中，除了技术...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值