【蓝桥杯真题】2021年蓝桥杯省赛B组题目解析+代码（C/C++）
2024-05-25 23:20:55
2021年蓝桥杯省赛B组题解（C/C++）
来自微信公众号：算法梦工厂，二维码见文末。可关注公众号获取往年试题题解。
欢迎加入蓝桥杯备赛群：768245918，获取往届试题，测试数据，算法课程等相关资源。
试题 A: 空间
问题描述
涉及知识点：计算机基础知识
答案：67108864
解析：
主要考察一些计算机的基础知识， 323232 位二进制数需要占 444 个字节， 256MB=256∗1024KB=256∗1024∗1024256MB = 256*1024KB = 256*1024*1024256MB=256∗1024KB=256∗1024∗1024 字节，所以一共可以存储的 323232 位二进制整数的数量就是：256∗1024∗1024/4=67108864256*1024*1024/4 = 67108864256∗1024∗1024/4=67108864 。
代码：
#include <bits/stdc++.h>
int main() {printf("%d", 256 * 1024 * 1024 / 4);return 0;
}
试题 B: 卡片
问题描述
答案：3181
解析
- 涉及知识点：枚举，十进制拆分
- 做法：初始化 res_num 数组记录当前每种卡牌剩余数量，从1向上枚举需要组合的卡片，直到剩余卡片不足则停止累加，最后成功组合成的卡片即为答案。
代码
#include <bits/stdc++.h>
using namespace std;vector<int> Split(int x) { // 将x按照十进制拆分每一位vector<int> ret;if (x == 0) {ret.push_back(0);return ret;}while (x > 0) {ret.push_back(x % 10);x /= 10;}return ret;
}const int maxn = 2021;
int rest_num[10] = {0}; // 记录当前每种数字卡牌剩余数量bool Sub(const vector<int> &x) { // 将当前需要的数字卡牌从卡牌库中去除，卡牌库剩余卡牌不足则返回falsefor (unsigned int i = 0; i < x.size(); i++) {rest_num[x[i]]--;if (rest_num[x[i]] < 0) {return false;}}return true;
}int main() {for (int i = 0; i < 10; i++) {rest_num[i] = maxn;}int ans = 1;while (1) { // 尝试利用剩余卡牌组合出数字ans，剩余卡牌不足则跳出循环vector<int> need = Split(ans);bool succFlag = Sub(need);if (!succFlag) {break;}ans++;}printf("ans = %d\n", ans - 1);return 0;
}
试题 C: 直线
问题描述
答案：40257
解析
- 涉及知识点：枚举、浮点数判
- 做法：
- 枚举所有点的两两组合，对于每一对两个点的组合就确定了一条直线，对于每条直线都判断其是否和之前已经出现过的直线相同，如果相同则忽略。
- 判断两个直线是否相同的做法：每个直线存储直线上两个点，对于直线 L0(p0,p1)L_0(p_0,p_1)L0(p0,p1) 和直线 L1(p2,p3)L_1(p_2,p_3)L1(p2,p3)，当且仅当点 p2p_2p2 和 p3p_3p3 均在直线 L1L_1L1 上，则直线 L1L_1L1 ，L2L_2L2 重合。
- 判断一个点是否在直线上的做法：假设存在点 p2p_2p2 和直线 L(p0,p1)L(p_0,p_1)L(p0,p1)，如果三个点两两之间的距离 a+b=ca+b=ca+b=c，则说明三个点在一条直线上。（注意这里判断距离相等因为是浮点类型可能存在误差，所以不可以之间判断是否相等，而是需要判断两个浮点数之间的差是否小于一个较小值，如：10−710^{-7}10−7）。
代码
#include <bits/stdc++.h>
using namespace std;
struct Point {int x, y;Point() {}Point(int x, int y) {this->x = x;this->y = y;}
};struct Line {Point a, b;Line(Point a, Point b) {this->a = a;this->b = b;}
};vector<Line> lineList;double Dis(Point p0, Point p1) { // 计算点p0和p1之间的直线距离return sqrt((p0.x - p1.x) * (p0.x - p1.x) + (p0.y - p1.y) * (p0.y - p1.y));
}bool CheckPointInLine(Line x, Point p) { // 检查点p是否在直线x上double dis[3];dis[0] = Dis(x.a, x.b);dis[1] = Dis(x.a, p);dis[2] = Dis(x.b, p);sort(dis, dis + 3);if (fabs(dis[0] + dis[1] - dis[2]) < 1e-5) { // 三点在一条直线则较短两距离相加等于较长距离return true;} else {return false;}
}// 检查当先直线cur是否和之前已经出现过得直线集合（lineList）中的某一直线重合
bool CheckLineRepeat(Line cur) {for (unsigned int i = 0; i < lineList.size(); i++) {if (CheckPointInLine(lineList[i], cur.a) &&CheckPointInLine(lineList[i], cur.b)) {return true;}}return false;
}int main() {vector<Point> pointList;// 将所有点记入pointList中for (int i = 0; i < 20; i++) {for (int j = 0; j < 21; j++) { pointList.push_back(Point(i, j));}}// 尝试任意两点的组合组成的直线，如果直线没出现过则记录下来，否则跳过int ans = 0;for (unsigned int i = 0; i < pointList.size(); i++) {for (unsigned int j = i + 1; j < pointList.size(); j++) {Line curLine = Line(pointList[i], pointList[j]);if (!CheckLineRepeat(curLine)) {ans++;lineList.push_back(curLine);}}}printf("ans = %d\n", ans);return 0;
}
试题 D: 货物摆放
问题描述
答案：2430
解析
- 涉及知识点：质因数分解
- 做法：
- 问题可以转化成，将 202104182021041820210418202104182021041820210418 分解成三个数 a∗b∗ca*b*ca∗b∗c 的形式，有多少种拆分方法。
- 将 202104182021041820210418202104182021041820210418 质因数分解成： p0n0∗p1n1∗...∗pnnnp_0^{n_0} *p_1^{n_1}* ... *p_n^{n_n}p0n0∗p1n1∗...∗pnnn 的形式（其中 p0,p1,...,pnp_0, p_1, ... , p_np0,p1,...,pn 均为质数），可得： 2021041820210418=21∗33∗171∗1311∗28571∗588235312021041820210418 = 2^1* 3^3 *17^1* 131^1 *2857^1* 5882353^12021041820210418=21∗33∗171∗1311∗28571∗58823531 。
- 对于质因数： 2,17,131,2857,58823532,17,131,2857,58823532,17,131,2857,5882353 ，每个均可以分别分配给 a,b,ca,b,ca,b,c 三个位置，所以总共方法数是 353^535 。
- 对于出现了 333 次的质数 333 ，可以枚举出其所有的分配方式，共10种。故总方法数为： 35∗10=24303^5 * 10 = 243035∗10=2430 。
代码
#include <bits/stdc++.h>
using namespace std;vector<long long int> primeNum, primeVal;
// 将x质因数分解
void CalaPrime(long long int x) {printf("%lld = ", x);for (long long int i = 2; i * i <= x; i++) {if (x % i == 0) {int num = 0;while (x % i == 0) {x /= i;num++;}primeNum.push_back(num);primeVal.push_back(i);}}if (x > 1) {primeNum.push_back(1);primeVal.push_back(x);}for (unsigned int i = 0; i < primeNum.size(); i++) {if (i != 0) {printf(" * ");}printf("\n(%lld ^ %lld)", primeVal[i], primeNum[i]);}printf("\n");
}int main() {CalaPrime(2021041820210418);long long int ans = 0;ans = 3 * 3 * 3 * 3 * 3;ans *= 10;printf("ans = %lld\n", ans);return 0;
}
试题 E: 路径
问题描述
答案：10266837
解析
- 涉及算法：图论，最短路，最大公约数
- 做法：
- 建图：共2021个结点组成的图，枚举任意两点组合，通过计算最大公约数，记录这两个点之间的距离，即增加一条边。
- 公式： lcm(x,y)=x∗ygcd(x,y)lcm(x,y) = \frac {x*y} {gcd(x,y)}lcm(x,y)=gcd(x,y)x∗y （ lcm(x,y)lcm(x,y)lcm(x,y) 表示 xxx 和 yyy 的最小公倍数， gcd(x,y)gcd(x,y)gcd(x,y) 表示 xxx 和 yyy 的最大公约数）
- 最短路求解：可以使用Floyd算法或DijkStra算法计算最短路。（这里因为是填空题，建议使用Floyd算法更加好写，可以考虑两个算法都实现用来相互验证）
代码
#include <bits/stdc++.h>
using namespace std;const int maxn = 2021;vector<int> u[maxn + 52];
vector<int> v[maxn + 52];
int disDijk[maxn + 52];
int disFloyd[maxn + 52][maxn + 52];
bool vis[maxn + 52];// 初始化建图，u[i][j]表示i的第j条出边编号，v[i][j]表示i的第j条边的长度，也就是i和u[i][j]的距离
void InitGroup() {for (int i = 1; i <= maxn; i++) {for (int j = i + 1; j <= maxn; j++) {if (j - i <= 21) {u[i].push_back(j);v[i].push_back(i * j / __gcd(i, j));u[j].push_back(i);v[j].push_back(i * j / __gcd(i, j));}}}
}// floyd算法计算最短路，disFloyd[i][j] 表示i到j的最短距离
void Floyd() {// 初始化disFloyd为一个较大值memset(disFloyd, 0x3f, sizeof(disFloyd));for (unsigned int i = 1; i <= maxn; i++) {for (unsigned int j = 0; j < v[i].size(); j++) {disFloyd[i][u[i][j]] = v[i][j];disFloyd[u[i][j]][i] = v[i][j];}}// 执行floyd算法for (int k = 1; k <= maxn; k++) {for (int i = 1; i <= maxn; i++) {for (int j = 1; j <= maxn; j++) {disFloyd[i][j] = disFloyd[j][i] = min(disFloyd[i][j], disFloyd[i][k] + disFloyd[k][j]);}}}printf("floyd ans = %d\n", disFloyd[1][maxn]);
}// Dijkstra算法计算最短路，disDijk[i]表示i距离结点1的最短距离
void Dijkstra() {memset(disDijk, 0x3f, sizeof(disDijk));memset(vis, 0, sizeof(vis));disDijk[1] = 0;for (int i = 1; i <= maxn; i++) {int curMin = 0x3f3f3f3f;int curIndex = -1;for (int j = 1; j <= maxn; j++) {if (vis[j]) {continue;}if (curMin > disDijk[j] || curIndex == -1) {curMin = disDijk[j];curIndex = j;}}vis[curIndex] = true;for (unsigned int j = 0; j < u[curIndex].size(); j++) {int t = u[curIndex][j], val = v[curIndex][j];disDijk[t] = min(disDijk[t], disDijk[curIndex] + val);}}printf("Dijkstra ans = %d vis = %d\n", disDijk[2021], vis[2021]);
}int main() {InitGroup();Floyd();Dijkstra();return 0;
}
试题 F: 时间显示
问题描述
涉及知识点：取模，时间计算，格式化输出
解析
注意题目中给定的是毫秒，利用整除和取模就可以完成计算。具体细节可以参照代码中的注释。
代码
#include <bits/stdc++.h>
using namespace std;int main() {long long int dayMs = 24 * 60 * 60 * 1000; //一天包含多少毫秒long long int n;scanf("%lld", &n);// 扣除整天的描述之后，得到最后一天剩下了多少毫秒n = n % dayMs;// 忽略毫秒，得到还剩多少秒n = n / 1000;// 一小时3600秒，走过了多少个完整的3600秒就代表当前小时数是多少int hour = n / (3600);// 扣除整小时之后剩下的秒数，可以走过多少个完整的60秒就代表当前分钟数是多少int minutes = (n - hour * 3600) / 60;// 走完全部的完整60秒之后剩下的秒数就是秒数int second = n % 60;printf("%02d:%02d:%02d\n", hour, minutes, second);
}
试题 G: 砝码称重
问题描述
解析
涉及知识点：动态规划，类背包问题
思路一：问题可以转化成：给定 nnn 个正整数，计算从中选出若个数字组合，每个数字可以加或者减，最终能得到多少种正整数结果。
- 状态定义： dp(i,j)dp(i,j)dp(i,j) 表示前 iii 个数字选择若干个加或者减，能否获得和为 jjj 。( −105≤j≤105-10^5\le j \le 10^5−105≤j≤105 )
- 状态转移方程： dp(i,j)=dp(i−1,j)∣dp(i−1,j−a[i])∣dp(i−1,j+a[i])dp(i,j) = dp(i-1,j) | dp(i-1, j-a[i]) | dp(i-1,j+a[i])dp(i,j)=dp(i−1,j)∣dp(i−1,j−a[i])∣dp(i−1,j+a[i]) 。
- 初始状态： dp(0,0)=1dp(0,0) = 1dp(0,0)=1 。
- 时间复杂度分析：状态数 n∗sum∗2n*sum* 2n∗sum∗2 ，状态转移方程复杂度 O(1)O(1)O(1) ，总时间复杂度 O(n∗sum)O(n*sum)O(n∗sum) ， sumsumsum 表示所有数总和的最大值为 10510^5105 。
思路二：问题还可以转化成：给定 2∗n2*n2∗n 个正整数， a0,a1,...,an,−a0,−a1,...,−ana_0,a_1,...,a_n,-a_0,-a_1,...,-a_na0,a1,...,an,−a0,−a1,...,−an ，每个数字可以选或者不选，问相加可以组合成多少种不同的正整数。这样就是一个经典的01背包问题了，只要注意一下负数问题即可。
其它技巧注意事项：
- 利用滚动数组，反复交换 curcurcur 和 preprepre 来节约空间。
- 使用 offsetoffsetoffset 偏移来保证 dpdpdp 过程中可以记录获取负数重量的可能性，以便后续转移。
代码
#include <bits/stdc++.h>
using namespace std;const int offset = 100052; // 为处理负数情况引入的偏移量
const int maxn = 100052 + offset;
int n, vis[2][maxn], a[2000];int main() {scanf("%d", &n);for (int i = 0; i < n; i++) {scanf("%d", &a[i]);}memset(vis, 0, sizeof(vis));vis[0][offset] = 1;int pre = 0, cur = 1;// 三种情况分别是，不选择a[i]，选择a[i]，选择-a[i]for (int i = 0; i < n; i++) {for (int j = 0; j < maxn; j++) {vis[cur][j] = max(vis[cur][j], vis[pre][j]);if (j - a[i] >= 0) {vis[cur][j] = max(vis[pre][j - a[i]], vis[cur][j]);}if (j + a[i] < maxn) {vis[cur][j] = max(vis[pre][j + a[i]], vis[cur][j]);}}swap(pre, cur); // 滚动循环利用数组的pre行和cur行}// 注意要从offset+1开始，因为能称出来的重量不应该是负数int ans = 0;for (int i = offset + 1; i < maxn; i++) {if (vis[pre][i]) {ans++;}}printf("%d", ans);return 0;
}
试题 H: 杨辉三角形
问题描述
涉及知识点：二分，组合数计算，打表
解析
这里其实需要知道或者自己分析出一些杨辉三角的性质，首先为了方便表示，将这个杨辉三角表示成这种形式：
第 iii 行第 jjj 个数表示成 c(i,j)c(i,j)c(i,j) ，行数和列数都从 000 开始计算。
可以发现如下的结论：
- c(n,m)=n!m!∗(n−m)!c(n,m) = \frac{n!}{m!*(n-m)!}c(n,m)=m!∗(n−m)!n!
- c(n,m)=c(n,n−m)c(n,m) = c(n,n-m)c(n,m)=c(n,n−m)
- c(n,m)=c(n−1,m−1)+c(n−1,m)c(n,m) = c(n-1,m-1) + c(n-1,m)c(n,m)=c(n−1,m−1)+c(n−1,m)
考虑到每一行是对称的，所以如果如果一个数字在某一行的右半边出现，那么它一定也在这一行的左半边出现，因此每一行右半边的数字一定不会作为第一个出现的数字。此外可以发现 c(i,1)=ic(i,1) = ic(i,1)=i ，所以任意一个数字 nnn 一定会在这个杨辉三角矩阵中出现过。另外根据上面的公式1可以发现，每一行的数字都是呈现一个先增后减的形式，并且增长速度极快。每一列数字则是完全单调递增的。因此可以尝试在每一列二分搜索是否有该数字。只需要考虑前 202020 列即可，因为后面的数字大小已经完全超过了 nnn 的最大范围，所以一定不会等于 nnn。
代码
#include <bits/stdc++.h>
using namespace std;// 打印杨辉三角前x行，帮助直观感受
void Print(int x) {long long int c[100][100];for (int i = 1; i <= x; i++) {c[i][0] = 1;printf("%lld\t", c[i][0]);for (int j = 1; j < i; j++) {c[i][j] = c[i - 1][j - 1] + c[i - 1][j];printf("%lld\t", c[i][j]);}printf("\n");}
}// 二分方法
long long int n;
long long int C(long long int a, long long int b) {long long int ret = 1;for (long long int i = a, j = 1; j <= b; i--, j++) {ret = ret * i / j;if (ret > n) {return n + 1;}}return ret;
}long long int GetAns(int col) {long long int l = col, r = max(n, (long long int)col);while (l < r) {long long int mid = (l + r) / 2;if (C(mid, col) >= n)r = mid;elsel = mid + 1;}if (C(r, col) != n) { // 没有出现则返回出现位置无限大return 4e18;} else {return r * (r + 1) / 2 + col + 1;}
}int main() {scanf("%lld", &n);long long int ans = 4e18;for (int i = 0; i < 20; i++) { // 枚举前20列，记录最早出现位置long long int cur = GetAns(i);ans = min(ans, cur);}printf("%lld\n", ans);return 0;
}
试题 I: 双向排序
问题描述
涉及知识点：贪心，线段树，排序
解析
此题完全通过较为困难，此处给出简单版本使用sort函数代码。可以考虑，对于连续的0操作或者1操作，只需要执行覆盖数组长度最长的操作即可，这样就可以一定程度上减少操作次数，从而提高程序运行效率。
代码
#include <bits/stdc++.h>
using namespace std;const int maxn = 100052;
int a[maxn];
bool cmp(int x, int y) { return x > y; }struct Oper {int pos, op;
};int main() {int n, m;scanf("%d%d", &n, &m);for (int i = 0; i < n; i++) {a[i] = i + 1;}// 读取操作列表vector<Oper> opList;for (int i = 0; i < m; i++) {Oper temp;scanf("%d%d", &temp.op, &temp.pos);opList.push_back(temp);}// 操作去重转变成01交错的操作序列vector<Oper> newList;Oper curOp = opList[0];for (unsigned int i = 0; i < opList.size(); i++) {if (curOp.op != opList[i].op) { // 操作01转换则保存当前等价操作并重新记录newList.push_back(curOp);curOp = opList[i];continue;}if (opList[i].op == 0 && opList[i].pos > curOp.pos) {curOp = opList[i];}if (opList[i].op == 1 && opList[i].pos < curOp.pos) {curOp = opList[i];}}newList.push_back(curOp);// 模拟执行操作for (unsigned int i = 0; i < newList.size(); i++) {if (newList[i].op == 0) {sort(a, a + newList[i].pos, cmp);} else {sort(a + newList[i].pos - 1, a + n);}}// 打印结果for (int i = 0; i < n; i++) {if (i != 0) {printf(" ");}printf("%d", a[i]);}return 0;
}
试题 J: 括号序列
问题描述
解析
- 涉及知识点：动态规划，取模
- 动态规划设计：
- 状态设计： dp(i,j)dp(i,j)dp(i,j) 表示前 iii 个括号插入若干个括号之后，左括号比右括号多 jjj 个的插入方法数。
- 状态转移方程： dp(i,j)=dp(i−1,j−1)dp(i,j) = dp(i-1,j-1)dp(i,j)=dp(i−1,j−1)（stristr_istri 是左括号）， dp(i,j)=∑k=0j+1dp(i−1,k)dp(i,j) = \sum_{k=0}^{j+1}dp(i-1,k)dp(i,j)=∑k=0j+1dp(i−1,k) （ stristr_istri 是右括号）
- 状态转移优化：当 stristr_istri 是右括号时，因为： dp(i,j−1)=∑k=0jdp(i−1,k)dp(i,j-1) = \sum_{k=0}^{j}{dp(i-1,k)}dp(i,j−1)=∑k=0jdp(i−1,k) ，所以 dp(i,j)=dp(i−1,j+1)+dp(i,j−1)dp(i,j) = dp(i-1,j+1) + dp(i,j-1)dp(i,j)=dp(i−1,j+1)+dp(i,j−1) 。相当于是利用一个前缀和来把 O(n)O(n)O(n) 的状态转移方程优化成 O(1)O(1)O(1) 。
- 初始状态： dp(0,0)=1dp(0,0) = 1dp(0,0)=1
- 注意事项：要增加 visvisvis 数组用于表示 dpdpdp 数组每个位置取模前的实际值是否为 000 ，如果只判断 dpdpdp 值可能会出现 dpdpdp 值实际不为 000 但是因为取模恰好为 000 的情况（虽然因为这个模数的特殊性，这个情况出现的概率几乎为 000 ）
代码
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5052;
const long long int MOD = 1e9 + 7;int dp[maxn][maxn];
bool vis[maxn][maxn];
char str[maxn];
int n;long long int mod(long long int x) { return x % MOD; }long long int GetAns() {memset(dp, 0, sizeof dp);memset(vis, 0, sizeof vis);dp[0][0] = 1;vis[0][0] = true;for (int i = 1; i <= n; i++) {if (str[i - 1] == '(') {for (int j = 1; j <= n; j++) {dp[i][j] = dp[i - 1][j - 1];vis[i][j] = vis[i - 1][j - 1];}} else {dp[i][0] = mod(dp[i - 1][0] + dp[i - 1][1]);vis[i][0] = vis[i-1][0] | vis[i-1][1];for (int j = 1; j <= n; j++) {dp[i][j] = mod(dp[i - 1][j + 1] + dp[i][j - 1]);vis[i][j] = vis[i - 1][j + 1] | vis[i][j - 1];}}}for (int i = 0; i <= n; i++) {if (vis[n][i] != 0) {return dp[n][i];}}return -1;
}
int main() {scanf("%s", str);n = strlen(str);long long int ansL = GetAns();reverse(str, str + n);for (int i = 0; i < n; i++) {if (str[i] == ')') {str[i] = '(';} else {str[i] = ')';}}long long int ansR = GetAns();printf("%lld\n", mod(ansL * ansR));return 0;
}获取更多题解，算法讲解欢迎关注公众号：算法梦工厂
【蓝桥杯真题】2021年蓝桥杯省赛B组题目解析+代码（C/C++）相关推荐
- 【蓝桥杯真题】2021年蓝桥杯省赛A组题目解析+代码（python组）
2021年蓝桥杯省赛A组题解(python组) 来自微信公众号:算法梦工厂,二维码见文末. 欢迎加入蓝桥杯备赛群:768245918,获取往届试题,测试数据,算法课程等相关资源. A:卡片 答案:31 ...
- 蓝桥杯 真题 2021 4、路径
[题目] 小蓝学习了最短路径之后特别高兴,他定义了一个特别的图,希望找到图中的最短路径. 小蓝的图由2021 个结点组成,依次编号1 至2021. 对于两个不同的结点a, b,如果a 和b ...
- #蓝桥杯真题【思特奇杯·云上蓝桥-算法集训营】第2周
蓝桥杯训练营第二周作业 1.带分数 问题描述 100 可以表示为带分数的形式:100 = 3 + 69258 / 714. 还可以表示为:100 = 82 + 3546 / 197. 注意特征:带分数 ...
- 【蓝桥杯真题】2020蓝桥杯真题-跑步锻炼
本文首发于微信公众号:"算法与编程之美",欢迎关注,及时了解更多此系列文章. 问题描述 小蓝每天都锻炼身体.正常情况下,小蓝每天跑 1 千米.如果某天是周一或者月初(1 日),为了 ...
- 蓝桥杯python省赛冲刺篇2——常用算法的详细解析及对应蓝桥杯真题：打表模拟法、递推递归法、枚举法、贪心算法、差分与前缀和
注意:加了题目链接 目录 注意:加了题目链接 一.打表模拟法 介绍 1. 算式问题 题目描述 解析与代码演示 2. 求值 题目描述 解析与代码演示 3. 既约分数 题目描述 解析与代码演示 4. 天干 ...
- 蓝桥杯真题2017-2021
刷完近几年真题,感觉理解完之后,拿奖问题不大,本人这次获得2022年蓝桥杯javaB组省一,以下是历年javaB组省赛题目. 文章目录 2017年真题 一.购物单 二.纸牌三角形 三.承压计算 四.魔 ...
- python解答蓝桥杯真题2 猜年龄 美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在19351936年应邀来中国清华大学讲学。。。
python解答蓝桥杯真题2 猜年龄 美国数学家维纳(N.Wiener)智力早熟,11岁就上了大学.他曾在1935~1936年应邀来中国清华大学讲学... 问题描述 全排列模板: 美国数学家维纳(N. ...
- 第五届蓝桥杯真题解析【JavaC组】
第五届蓝桥杯真题解析[JavaC组] 业精于勤,荒于嬉:行成于思,毁于随.--韩愈 文章目录 ***第五届蓝桥杯真题解析[JavaC组]*** 前言 A:猜年龄 B:等额本金 C:猜字母 D:大衍数列 ...
- 【蓝桥杯真题】16天冲刺 Python
距离比赛很快了,希望和我一起准备的PY党能更加熟练的掌握Python! 1.距离和(模拟赛填空题) 问题描述: 两个字母之间的距离定义为它们在字母表中位置的距离.例如 A和 C 的距离为 2,L 和 ...
- 蓝桥杯真题：三羊献瑞
蓝桥杯真题:三羊献瑞 观查下面的加法算式: 其中相同的汉字代表相同的数字,不同的汉字代表不同的数字. 请你填写"三羊献瑞"所代表的4位数字(答案唯一),不要填写任何多余内容. 分析 ...
最新文章
- 表格(增加行号) http://www.blogjava.net/zeyuphoenix/archive/2010/04/19/318788.html
- java 注解生成实例_Java 8 开发的 Mybatis 注解代码生成工具
- 字节流的 创建 写入文字 复制文件
- QT的QStackedWidget类的使用
- 小米手机反复提示“请勿遮挡听筒区域“
- Cordova+Ionic之坑
- 一个简单的Kafka Flink Rabbitmq Demo
- console.log(12.toString())为啥会报错呢？
- 关于破解百度文库的方法(非常实用)
- redis作用_Java高级架构笔记——实现故障恢复自动化：详解Redis哨兵技术
- axis1 c# 接口 调用_C#图形编程GDI+基础
- 计算机械效率的公式四种,物理计算公式;
- python题库大一_1000道Python题库系列分享三
- 【Pytorch教程】：激励函数
- kodi树莓派_【树莓派】树莓派与XBMC及Kodi、LibreELEC插件（二）
- JS 数组 isAarray() typeof push() unshift() splice()替换/删除/插入 slice()切片 join() split() reverse concat
- 哪个程序猿还没段风花雪月的错过
- # PPT进阶——文字环绕
- MySQL 设计与开发规范
- python怎么表示循环小数_循环小数表示法