今天搞了mini版蓝桥杯比赛，有时间的话，我们每天都会补充15道主观题。废话不多说，开整！！！
2022.10.11
抽象：在C++中，如果一个类并没有什么实际信息，那么就是一个抽象类
多态：相同名字的函数有不同的功能，这些函数在不同的类中
静态成员函数：类中函数+static，只能访问静态成员变量
友元函数：在类中函数前+friend（全局函数做友元），friend+所属区域（成员函数做友元）或者实现全局函数访问私有类
友元类：子类前+friend，实现类访问私有类
编译期间是：静态多态
类模板：一个通用类，类中内容可以不确定
语法：template<class T1,class T2>
函数模板：一个通用函数，函数参数可以不确定
语法：template<typename T>
cin，cout，cerr，clog是预留的流对象
二维数组，必须初始化列
判断字符串为空函数：empty，size，length ，compare
C：只在复合语句中有效
A，B写反了
2022.12.2不在沉默中爆发，就在沉默中GG，选择题终于迎来了更新，本次内容来源于我网上搜的内容，参考文章为：
https://blog.csdn.net/bless_my_head/article/details/107116563
ok，我们继续学习选择题吧。
虚函数：加上virtual修饰的类内函数
纯虚函数：虚函数 = 0。
抽象类：具有纯虚函数的类，其纯虚函数的实现由派生类给出
基类：父类
派生类：子类
总结：一个基类如果是抽象类，那么它的派生类可以是抽象类也可以不是，这是根据该派生类是否对纯虚函数进行了声明（不要后面的＝0）
公共权限 public ，类内可以访问，类外可以
保护权限 protected ，类内可以访问，类外不行，儿子可以访问父亲保护内容
私有权限 private ，类内可以访问，类外不行，儿子不能访问父亲内容
构造函数：可以有参数，可以重载：先父类再子类
析构函数：不能有参数，不能重载 ：先子类再父类
前置：add++，后置是 ++add（int）
执行顺序：1构造A，2调用后A，2构造B，1析构a，2调用a，2析构b
AABaab
有说明，没有实现的类
string是一个类
2022.10.28
#include<iostream>
using namespace std;
int main()
{
int HH, MM, SS, hh, mm, ss;
long long int ans;
int h;
scanf("%d:%d:%d%d:%d:%d",&HH,&MM,&SS,&hh,&mm,&ss);
h = (hh - HH + 24) % 24;
h = h * 3600;
ans = h + mm * 60 - MM * 60 + ss - SS;
cout<< ans<<endl;
return 0;
}2022.11.21
前一阵重庆遇到小🐏人了，emmmm，希望疫情早点结束吧，然后咧，从今天开始这个比赛的文章要开始继续更新了。
这里我参考该博主的文章，按着它的刷题下来，因为他说刷了这个不想拿奖都难！那懂得都懂！
1
1.本题理解num数组为一个关键，其实我也说不太清楚了，但是对这写就行
2.for循环采用 -- 操作，这是因为访问输入值的时候，从最低位开始，如果你写 ++ 那么就从高位开始了
3.对于字符串和数字之间转换问题，切记！！！
‘0’->48 '9'->57
'a'->97 'z'->122
'A'->65 'Z'->90
然后本题转换为：
字符串num【i】这一位对应的整型
如果这一位字符串是0-9之间，那么ans = num【i】-47
如果这一位字符串是a-f之间，那么ans = num【i】-87
注意：0-9之间，说明改字符串不超过58，a-f之间，说明改字符串不超过103
#include<iostream>
#include<string>
using namespace std;
int main() {
string str;
cin >> str;
long long temp = 0;
long long result = 0;
int i, num[] = { 1, 2, 6, 30, 210, 2310, 30030, 510510, 9699690, 223092870 }, toDec;
for (i = str.length() - 1; i > -1; --i) {
toDec = num[str.length() - 1 - i];
if (str[i] > 47 && str[i] < 58) { //‘0’ == 48 ， ‘9’== 57
temp = str[i] - 48;
result += temp * toDec;
}
else {
temp = str[i] - 87; //'a' =97 - 87 = 10;
result += temp * toDec;
}
}
cout << result;
return 0;
}
2
1.char类型求长度，按照下面固定方式即可，-1是因为还有一个'\'
int len = (sizeof(s) / sizeof(s[0])) - 1;//获取长度
2.由于在原题找不到题目，所以对于判错是有问题的，比如说这里题目是说给定字符串全是AA这种，不会有1 +这种类型，那么在判定的时候，只需要判断为空即可
#include<iostream>
#include<string>
using namespace std;
int main() {
char s[10000];
cin >> s;
int len = (sizeof(s) / sizeof(s[0])) - 1;//获取长度
for (int i = 0; i< len; i++) {
//满足if条件就break，说明不是我要的字符串
if (s[i] > 'z' || s[i] < 'A' || s[i]>'Z'&& s[i]<'a') break;//跳过空元素
s[i] = 187 - s[i];
}
for (int i = 0; i< len; i++) {
if (s[i] > 'z' || s[i] < 'A'||s[i]>'Z'&& s[i]<'a') break;//跳过空元素
cout << s[i];
}
return 0;
}
#include<iostream>
#include<string>
using namespace std;
int main() {
char s[10000];
cin >> s;
int i = 0;
//直接判断字符串最后一位，不到最后一位就一直替换
while (s[i] != '\0'){
s[i] = 187 - s[i];
i++;
}
i = 0;
while (s[i] != '\0') {
cout << s[i];
i++;
}
return 0;
}
3
最简单方法就是利用find函数去按个查找。所以我们先对str2中用substr求得每一个的字符，然后利用find函数查找
#include<iostream>
#include<string>
using namespace std;
int main()
{
string str1;
string str2;
cin >> str1;
cin >> str2;
int len1 = str1.length();
int len2 = str2.length();
int index = 0;
for (int i = 0; i < len2; i++) {
index = str1.find(str2.substr(i, 1));
if (index == -1) {
cout << "N";
}
else {
cout << "Y";
}
}
cout << endl;
return 0;
}4
质因素很关键，这是最基础的，简单来说就比如，2，3，4，5，6各自质因素为2，3，2x2，5，6。关键就在于理解质因数。
比如说给你2，4求公共质因数，那么2是2，4是2x2，那么公共质因数就是2
比如说给你4，8求公共质因数，那么4是2x2，8是2x2x2，那么公共质因数是2+2=4
比如说给你9，27求公共质因数，那么9是3x3，27是3x3x3，那么公共质因数是3+3=6
因此本题分为如下步骤：
1，遍历两两元素，这个用两个for循环实现
2. 求两个数的公共质因数，首先因为最小公共质因数为2，那么该函数先对两个数从2开始取模看能不能除掉，如果可以，则说明有个2的公共质因数，同时，有些数不仅只有2，还有3的可能，因此这里加了循环。此外还有一点就是得到一个公共质因数之后要把两数除掉该公共质因数，才能继续求下一个
3.最后一步完成相加即可
#include<iostream>
#include<cstdio>
#include<iomanip>
#include<cstdlib>
#include <algorithm>
#include<string.h>
#include<set>
#include<math.h>
#define llu unsigned long long
using namespace std;
int yinshu(int x, int y)
{
if (x < y) swap(x, y);
for (int i = 2; i <= y; i++)
{
if (x % i == 0 && y % i == 0) return i;
}
return 1;
}
int a[110];
llu s = 0;
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n - 1; i++)
{
for (int j = i + 1; j < n; j++)
{
int x = a[i], y = a[j];
while (true)
{
int t = yinshu(x, y);
if (t != 1)
{
s = (s + t) % 1000000007;
x /= t;
y /= t;
}
else break;
}
}
}
cout << s << endl;
return 0;
}
1.为什么对h取模关键在于，加入当前10：50：10，经过20分钟后是11：10：10.那么计算的时候先得出11-10=1h，但其实只有20分钟，那么在减去50分钟，加上10分钟，刚好就是20分钟。这就是本题的关键。
2.试题中用scanf，vistudio用scanf_s
#include<iostream>
#include<cstdio>
#include<iomanip>
#include<cstdlib>
#include <algorithm>
#include<string.h>
#include<math.h>
#define llu unsigned long long
using namespace std;
int main()
{
int hh1, mm1, ss1, hh2, mm2, ss2;
scanf_s("%d:%d:%d%d:%d:%d", &hh1, &mm1, &ss1, &hh2, &mm2, &ss2);
long long int h,m;
h = (hh2 - hh1 + 24) % 24;
h *= 3600;
h = h + mm2 * 60 + ss2 - mm1 * 60 - ss1;
cout << h << endl;
return 0;
}
1.对给定的秒数进行判断可以分成多少个小时，分钟和秒，然后把结果加上
2.需要注意，每次确定完分配多少小时之后是需要减去分配时间的
3.最后的输出要进行取模以及保留两位小数
#include<iostream>
#include<cstdio>
#include<iomanip>
#include<cstdlib>
#include <algorithm>
#include<string.h>
#include<math.h>
#define llu unsigned long long
using namespace std;
int main()
{
int hh, mm, ss, second;
scanf_s("%d:%d:%d", &hh, &mm, &ss);
scanf_s("%d", &second);
int h = second / (60 * 60);//求出有几小时
int m,s;
int temp1, temp2;
if (h != 0) {
//说明有小时，那么减去该小时
temp1 = second - h * 60 * 60;
m = temp1 / 60;//求出多少分钟
}
else {
temp1 = second;
m = second / 60;//求出多少分钟
}
if (m != 0) {
//说明有分钟，那么减去该分钟
temp2 = temp1 - m * 60 ;
s = temp2 % 60;//求出多少miao
}
else {
s = second % 60;//求出多少miao
}
hh += h;
hh %= 24;
mm += m;
mm %= 60;
ss += s;
printf("%02d:%02d:%02d", hh, mm, ss);
return 0;
}
1.这次终于用c++写法了，实现两行输入这种
2.注意求公因数的方法，辗转相除法，建议去搜一下
#include<iostream>
#include<vector>
using namespace std;
using ll = long long;
inline ll gys(ll a, ll b) {
int temp;
if (a < b) {
swap(a, b);
}
while (b != 0) {//最大公约数用辗转相除法
temp = a % b;
a = b;
b = temp;
}
return a;
}
inline ll gbs(ll a, ll b) {//两个数的乘积等于这两个数的最大公约数与最小公倍数的积
return a * b / gys(a, b);
}
int main()
{
int N;
int n;
vector<int>vec;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> n;
vec.push_back(n);
}
//完成输入，现在遍历vec
ll result = 0;
for (int i = 0; i < vec.size() - 1; i++) {
for (int j = i + 1; j < vec.size(); j++) {
result += gbs(vec[i], vec[j]);
result %= 1000000007;
}
}
cout << result;
return 0;
}
到这里，我对这个比赛很气！！！真的，它这个测试系统以及题目，各自牛头不对马嘴！很难受，想着天下一家亲原则，我选择开始直接刷蓝桥杯的题目了，只是后续适应一下一些规则就ok。
2022.11.30
我们现在不从题目入手，而是更多偏向写法开始。
输入整型
int N;
int num;
cin>>N;
for(int i = 0; i < N; i++){
cin>>num;
vec.push_back(num);
//或者用数组
a[i] = num;
}输出浮点型，以及固定字符串
注意头文件
#include<algorithm>
#include <iomanip>
float ans2 = 100.0 * num / N;//num是int
cout<<setiosflags(ios::fixed)<<setprecision(0)<<ans1<<"%"<<endl;
//(0)表示保留0个小数平闰年判断
bool isLeap(int y){
return (y%4==0&&y%100!=0)||(y%400==0);
}回文串判断及输出
#include<bits/stdc++.h>
using namespace std;
long long n,x;
bool hws(long long n)
{
long long ans=0,m=n;
while(m>0)
{
ans=ans*10+m%10;
m/=10;
}
x=ans;
return ans==n;
}
int main()
{
cin>>n;
if(hws(n)) cout<<"Yes";
else cout<<x;
return 0;
}字符串查找，插入，删除
其中，查找下标从0开始，后面两个从1开始
int main()
{
string str;
int N;
int first, second;
string ch;
cin >> str;
cin >> N;
cin >> ch;
for (int i = 0; i < N; i++) {
cin >> first >> second;
int pos = str.find(ch, first-1);
if (pos <= second - 1 && pos >= first - 1) {
str.erase(pos , 1);
}
else {
str.insert(second , ch);
}
}
cout << str;
return 0;
}vector插入字符串，以及复制vector，删除vector元素
vec.push_back(char(str[j])); 其中str是字符串，对于str[j]这是一个asiic码，通过char进行转换为char后插入的就是字母，或者to_string转为字符串。注意插入要根据vector类型
vec1.assign(vec.begin(), vec.end());
vec.clear();
844
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
