蓝桥杯第十六届模拟赛——基础细节考频分析

文章目录

• 前言
• 一、STL函数
• 二、日期问题
• 三、质数与约数
• 四、基本常识
• 总结

---

前言

一、STL函数

1. #include< cmath >
   详解floor函数、ceil函数和round函数

1.floor()
功能：把一个小数向下取整
     如果数是2.2 ，那向下取整的结果就为2.000000
     如果数是-2.2 ，那向下取整的结果就为-3.000000
原型：double floor(doube x);
返回值：成功：返回一个double类型的数，此数默认有6位小数无失败的返回值

注：带有强制转化功能，但与int(sqrt(n))有区别
sqrt()意思是平方根函数，计算一个非负实数的平方根。
floor对正负参数皆是向下取整，而强制转化是向零取整。

2.ceil()
功能：把一个小数向上取整
      如果数是2.2 ，那向上取整的结果就为3.000000
      如果数是-2.2 ，那向下取整的结果就为-2.000000
原型：double ceil(doube x);
返回值：成功：返回一个double类型的数，此数默认有6位小数无失败的返回值

3.round()
功能：把一个小数四舍五入
      即就是如果数是2.2 ，那四舍五入的结果就为2
           如果数是2.5,那结果就是3
原型：double round(doube x);

4.返回类型时输入/输出
区分 %d, %ld, %lld, %lf, %f 等
%d：用于 int  %ld：用于 long  %lld：用于 longlong
输入时：float 输入用 %f  double 输入用 %lf
输出时：float, double都用 %f 输出就行了(在C89/C90环境下，double 用 %lf 会出错)

2. #include< string >
   细解常用函数

1. 构造函数
    string s2("Hello World");  // 字符串初始化为 "Hello World" 
	string s3(s2);			   //拷贝构造: 将s2复制给s3、  输出为: Hello World
	string s4(s2, 2, 3);	   // 从 s2 的下标 2 的位置开始复制 3 个值给 s4，输出为: llo
	string s5(s2, 3);		   // 从 s2 的下标 3 的位置开始复制到结尾个字符给s5
	//输出为: llo World
	string s6(5, '#');			// 生成5个字符为 # 的字符串，输出为: #####

2. compare: 字符串大小比较（字典序比较）
   原理: 两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇 '\0'为止。
   例如：aaa < ab; a < b; baa < bbc;
   string s1("abcd");  string s2("aBcd");
   // s1 与 s2 相比第二个字符 b 的ASCII值大于 B
   cout << s1.compare(s2) << endl; // s1 > s2 所以输出1

3. getline:
   getline(cin, str) 获取一行字符串
   // cin 输入时默认空格是作为结束分隔，所以可以用getline将空格输入字符串中
   string s4; getline(cin, s4);
   cout << "s4: " << s4 << endl; //输入：hh nn ll！ 输出 hh mm LL！

4. find / rfind：
   string s3("Youth gives you light please don't let it down");
   int pos = s3.find(' '); int rpos = s3.rfind(' '); // 5 41

5. substr:
   string s4("Hello World!");
   // 当substr给两个参数时主要功能为复制子字符串,从下标 n 开始，复制 m 个字符
   string s5 = s4.substr(3, 5); // 输出为: lo Wo
   // 当substr不给参数时就为直接拷贝构造
   string s6 = s4.substr(); // 输出为: Hello World!
   // 当只给定左参数时，就从 n 开始复制到结尾
   string s7 = s4.substr(3); // 输出为: lo World!

二、日期问题

//求日期问题的模板 
int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

bool check_valid(int year, int month, int day)
{
    if (month == 0 || month > 12) return false;
    if (day == 0) return false;
    if (month != 2)
    {
        if (day > days[month]) return false;
    }   //一定要打大括号，不然第二个if会与else呼应
    else
    {
        int leap = ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0));
        if (day > days[month] + leap) return false;
    }
    return true;
}

三、质数与约数

1. 如何快速判断质数

bool is_Prime(int n){
    if(n <= 1) return false;
    if(n <= 3) return true;
    if(n % 2 == 0 || n % 3 == 0) return false;
    //只需检查6k±1的数是否满足行了
    for(int i = 5; i * i <= n; i += 6){
       if(n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}  

2. 如何求约数
   1. 先求出两个数的最大公约数gcd: int gcd(int a, int b) return b ? gcd(b, a%b) : a;
   2. 找出gcd的所有约数, 采用质因数分解法

#include <iostream>
#include <vector>
#include <map>
using namespace std;

// 质因数分解函数
map<int, int> prime_factors(int n) {
    map<int, int> factors;
    for (int i = 2; i * i <= n; ++i) {
        while (n % i == 0) {
            factors[i]++;
            n /= i;
        }
    }
    if (n > 1) factors[n]++;
    return factors;
}

// 生成所有约数
vector<int> get_divisors(int n) {
    map<int, int> factors = prime_factors(n);
    vector<int> divisors = {1};
    for (auto [p, exp] : factors) {
        int curr_size = divisors.size();
        int p_power = 1;
        for (int e = 1; e <= exp; ++e) {
            p_power *= p;
            for (int i = 0; i < curr_size; ++i) {
                divisors.push_back(divisors[i] * p_power);
            }
        }
    }
    return divisors;
}

// 计算GCD（欧几里得算法）
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int main() {
    int a = 24, b = 36;
    int d = gcd(a, b); // 计算GCD
    vector<int> common_divisors = get_divisors(d); // 获取所有公约数
    
    cout << "GCD(" << a << ", " << b << ") = " << d << endl;
    cout << "所有公约数：";
    for (int x : common_divisors) cout << x << " ";
    return 0;
}

3. 如何求最大质约数

#include <bits/stdc++.h>
using namespace std;
int main()
{
   int ans = 0;
   int n = 2024;
   for (int i = 2; i * i <= n; i++){
     if (n % i == 0){
       ans = i;
       while (n % i == 0) n /= i;
     }
   }
   if (n > 1) ans = n;
   cout << ans;
}

四、基本常识

1. 常见进制表示法

   前缀：

   0b：二进制表示法。例如，0b1101 表示二进制数 1101。

   0o：八进制表示法。例如，0o57 表示八进制数 57。

   0x：十六进制表示法。例如，0x1A 表示十六进制数 1A。

   后缀：

   b 或 B：二进制表示法。例如，101b 或 101B 表示二进制数 101。

   o 或 O：八进制表示法。例如，75o 或 75O 表示八进制数 75。

   x 或 X：十六进制表示法。例如，1E2x 或 1E2X 表示十六进制数 1E2。

2. 常用进制转化法

#include<iostream>
using namespace std;
int s[N];
int main()
{
    int R, n; //表示R进制，该转化皆以十进制为中转站
	int count = 0;
	cout << "请输入要转化的进制：" << endl;
	cin >> n;
	cout << "请输入转化成的进制：" << endl;
	cin >> R;
	while (n){
		s[++count] = n % R;
		n = n / R;
	}
	for (; count > 0; count--) cout << s[count];
	return 0;
}

3. 字符串转换为数字（头文件< string >)

   1.stoi()：将字符串转换为整型 string s = "123"; int n = stoi(s);

   2.stoll()：将字符串转换为long long

   3.stof()：将字符串转换为float型

   4.stod()：将字符串转换为double型 以上同理可得

4. memset用法及注意事项

   void* memset(void* ptr, int value, size_t num);

   ptr：指向要填充的内存区域的指针。

   value：要设置的值（以 int 形式传递，但实际是按字节填充）。

   num：要填充的字节数。

   value 参数是 1：
   memset(b, 1, sizeof b) 会将 b 的每一个字节（byte）设置为 1。

   注意：1 是一个字节值，而不是整数 1。sizeof b：这是 b 的总字节大小。

   int 类型的存储方式：

   在大多数系统中，int 类型占 4 个字节。

   例如，int 值为 1 的二进制表示为：00000000 00000000 00000000 00000001。

   但是memset 会将 b 的每一个字节设置为 1，而不是将每个 int 设置为 1。

   因此，每个 int 的 4 个字节都会被设置为 1，即 00000001 00000001 00000001 00000001。

   这个二进制值对应的十进制数是 16843009（即 0x01010101）。

   结果：数组 b 中的每个 int 元素都会被设置为 16843009，而不是 1。

5. 对于长度为 k 的素数等差数列，其公差 d 必须被所有小于 k 的素数整除

   例如，当 k=5，公差应为 6 的倍数；当 k=7，公差应为 30 的倍数。用户示例中的 210 对应更大的 k，如 k = 11。

总结

注意细节问题，往往不注意细节会产生不必要的异常