蓝桥杯题型分布2

news2025/4/1 3:58:56

蓝桥杯

  • 蓝桥杯题型分类2
    • 素数
      • 孪生素数
      • 素数个数
        • 朴素筛法求素数
        • 线性筛法求素数
      • 因数分解
        • 试除法分解质因数
      • 等差素数列
      • 梅森素数
      • 组素数
      • 素数环
      • 找素数(分段筛)
      • 连续素数和
      • 小明的素数对
      • 疑似素数
      • 质数拆分
      • 纯质数
      • 超级质数
      • 质数日期
      • 质数游戏2
      • 魔法阵的能量
      • 阿坤老师切割年糕
      • 阶乘分解
      • 阶乘的约数和
      • 程序的输出零
      • 双子数
      • 躲炮弹
    • GCD+LCM
      • 互质数的个数
      • 等差数列
      • Hankson 的趣味题
      • 核桃的数量
      • 奇偶比例
      • 旅行I
      • 寻找她
      • 小咕咕

蓝桥杯题型分类2

素数

孪生素数

传送门
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

// 定义最大范围,m <= 100,因此数组大小只需要开到 110 即可
const int N = 1e2 + 10;

// primes 用于存储素数,cnt 记录素数的数量
int primes[N], cnt;
// st[i] 如果为 true 表示 i 已经被筛选掉(非素数)
bool st[N];

// 获取 [2, n] 范围内的所有素数,采用线性筛法
void get_primes(int n) {
    for (int i = 2; i <= n; i++) {
        // 如果 st[i] 为 false,说明 i 还是素数
        if (!st[i]) {
            // 将该素数存入 primes 数组,并计数
            primes[cnt++] = i;
        }
        // 遍历用来进行筛选的素数列表
        for (int j = 0; primes[j] <= n / i; j++) {
            // 将当前下标对应的合数标记为 true
            st[primes[j] * i] = true;
            // 若当前数 i 能被 primes[j] 整除,就退出,避免重复筛
            if (i % primes[j] == 0) break;
        }
    }
}

int main() {
    int m;
    cin >> m;  // 读取输入

    // 获取 [2, m] 范围内所有素数
    get_primes(m);

    // 从后往前遍历 primes 数组,查找相隔为 2 的孪生素数对
    for (int i = cnt - 1; i >= 1; i--) {
        // 检查相邻两素数之差是否为 2
        if (primes[i] - primes[i - 1] == 2) {
            // 输出这对最大孪生素数
            cout << primes[i - 1] << " " << primes[i];
            break;
        }
    }

    return 0;
}

素数个数

传送门

朴素筛法求素数
int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (st[i]) continue;
        primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)
            st[j] = true;
    }
}
线性筛法求素数
int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

因数分解

传送门

试除法分解质因数
void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;
        }
    if (x > 1) cout << x << ' ' << 1 << endl;
    cout << endl;
}
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
const ll N=1e12;

void divide(ll x)
{
	for(ll i=2;i<=x/i;i++)
	{
		if(x%i==0)
		{
			int s=0;
			while(x%i==0)
			{
				x/=i;
				s++;
			}
			if(s==1)
			{
				cout<<i<<" * ";
			}
			else
			{
				cout<<i<<'^'<<s<<" * ";
			}
		}
	}
	if(x>1)cout<<x<<endl;
}
void solve()
{
	ll n;
  	cin>>n;
  	divide(n);
}
int main()
{
	solve();
  return 0;
}

等差素数列

传送门

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

// 使用ll表示long long,方便处理较大数值
using ll = long long;

// N 定义为 1e8,表示可能存储的最大范围
const ll N = 1e8;

// primes 数组用于存储素数,cnt 表示当前素数数量
int primes[N], cnt;
// st 数组标记某个数是否为合数,如果 st[x] = true,表示 x 不是素数
bool st[N];

// 筛选素数函数,埃氏筛或线性筛的思路
void get_primes(int n)
{
    // 从 2 开始判断每个数
    for(int i = 2; i <= n; i++)
    {
        // 如果 st[i] == false,说明 i 是素数
        if(!st[i]) primes[cnt++] = i;
        // 使用已得到的素数来标记合数
        for(int j = 0; primes[j] <= n / i; j++)
        {
            // 将 i * primes[j] 标记为合数
            st[primes[j] * i] = true;
            // 如果 i 能被当前素数整除,则无需再继续标记
            if(i % primes[j] == 0) break;
        }
    }
}

int main()
{
    // 先筛选出 10000 以内的素数
    get_primes(10000);

    // 枚举可能的首项,从 2 开始到 10000
    for(int head = 2; head <= 10000; head++)
    {
        // 如果 head 是素数(st[head] == false),再去尝试不同的公差 d
        if(!st[head])
        {
            // 从公差 d=2 开始枚举到 1000
            for(int d = 2; d <= 1000; d++)
            {
                // len 用于统计当前等差序列中连续的素数个数,这里初始设为 1
                int len = 1;
                // 从 head 开始,每次加上公差 d
                for(int j = head; ; j += d)
                {
                    // 如果当前数 j 仍为素数
                    if(!st[j])
                    {
                        len++;
                        // 当连续素数个数达到 10 时,说明找到一个长度为 10 的等差素数序列
                        if(len == 10)
                        {
                            // 输出此时的公差 d 并直接结束
                            cout << d << endl;
                            return 0;
                        }
                    }
                    // 遇到合数时,当前公差无法构成长度 10 的素数序列,跳出循环
                    else
                    {
                        break;
                    }
                }
            }
        }
    }
    return 0;
}

梅森素数

梅森素数

在这里插入图片描述
在这段程序中,a[1] 初始化为 1,然后在整个运算过程中它并不会回到 0。
具体原因是:
• a[1] 一开始被设为 1(代表当前值的最低位)。
• 随后的循环每次都对所有位进行乘 2 运算,此时最低位始终会在 2、4、8、6 之间循环(或产生进位后继续保持非零),不会变为 0。
• 最后减去 1 时,也只是在原先非零的最低位上进行简单的 -1 操作,因此不会出现 a[1] 是 0 而再继续减 1 的问题。

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

int main()
{
    // 初始化一个大小为101的整型向量a,所有元素初始为0,用于模拟“高精度”存储数字的每一位。
    // 下标1到100将存储数字的各位(下标1表示最低位,100最高位)。
    vector<int> a(101, 0);
    
    // 将最低位初始化为1,相当于保存数字"1"。
    a[1] = 1;
    
    // 这层循环共执行11213次,相当于做 2^11213 的计算
    for (int i = 1; i <= 11213; ++i) {
        int c = 0; // c用来记录进位
        // 将每一位都乘以2,再加上上一位留下的进位c
        for (int j = 1; j <= 100; ++j) {
            a[j] = a[j] * 2 + c;   // 乘2并加进位
            c = a[j] / 10;        // 计算新的进位值
            a[j] %= 10;           // 当前位保留一位,超过10的部分变成下一位进位
        }
        // 此时若c不为0,说明还产生新的进位,不过只要求后100位,不再额外处理进位
    }
    
    // 计算 2^11213 - 1,即将结果最低位减1
    a[1] -= 1;
    
    // 从最高位到最低位输出,拼接成完整的数字串
    for (int i = 100; i >= 1; --i) {
        cout << a[i];
    }
    return 0;
}

组素数

组素数
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
using ll=long long;

const int N=1e4;
int primes[N],cnt;
bool st[N];

void get_primes(int n)
{
  for(int i=2;i<=n;i++)
  {
    if(!st[i])primes[cnt++]=i;
    for(int j=0;primes[j]<=n/i;j++)
    {
      st[primes[j]*i]=true;
      if(i%primes[j]==0)break;
    }
  }
}
int main()
{
  get_primes(10000);
  int ans=0;
  if (!st[1949]) ans++;
  if (!st[1499]) ans++;
  if (!st[1994]) ans++;
  if (!st[4199]) ans++;
  if (!st[4919]) ans++;
  if (!st[4991]) ans++;
  if (!st[9914]) ans++;
  if (!st[9941]) ans++;
  if (!st[9419]) ans++;
  if (!st[9491]) ans++;

  cout<<ans;
  return 0;
}

素数环

素数环
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;

/*
  全局变量说明:
  - n: 输入的整数 n (1 ~ n 的所有数字需要组成素数环).
  - ans: 用于存储当前构造的排列环.
  - used[i]: 标记数字 i 是否已经被放入环中(default false).
  - ok: 用于在最后判断是否输出过解, 若一直为 false 表示无解.
*/

// 数组范围较大以防越界, 但实际 n < 20 即可
int n;
vector<int> ans;
bool used[N];
bool ok; // 是否已经找到或输出过解

// 判断 x 是否为素数的函数
bool check(int x) {
    if (x < 2) return false;
    for (int i = 2; i * i <= x; i++) {
        if (x % i == 0) {
            return false;
        }
    }
    return true;
}

/*
  dfs(u) 表示已经在 ans 中放入了 u 个数字 (其中 ans[0] = 1 已固定),
  接下来要尝试放第 (u+1) 个数字. 
*/
void dfs(int u) {
    // 如果已经放满 n 个数字, 检查首尾之和是否是素数
    if (u >= n) {
        int firstnum = ans[0];
        int lastnum = ans[n-1];
        int sum = firstnum + lastnum;
        // 如果首尾之和为素数, 则输出该排列
        if (check(sum)) {
            ok = true;
            for (auto x : ans) {
                cout << x << " ";
            }
            cout << endl; 
        }
        return; 
    }

    // 尝试在位置 u 放所有可用数字 i (1 <= i <= n)
    for (int i = 1; i <= n; i++) {
        if (!used[i]) {
            // 取当前环的最后一个数字与 i 相加, 若为素数才可放置
            int sum = ans.back() + i;
            if (check(sum)) {
                ans.push_back(i);
                used[i] = true;

                // 继续放下一个位置
                dfs(u + 1);

                // 回溯, 恢复状态
                ans.pop_back();
                used[i] = false;    
            }
        }
    }
}

int main() {
    cin >> n;
    // 先将数字 1 放入环 (作为第一个元素), 并标记已用
    used[1] = true;
    ans.push_back(1);

    // 从第 2 个位置开始尝试放数字, 因为第一个位置已固定 1
    dfs(1);

    // 如果一直没有输出答案, 输出 "No Answer"
    if (!ok) {
        cout << "No Answer";
    }
    return 0;
}

找素数(分段筛)

找素数
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

/*
   题意: 给定区间 [a, b] (2 ≤ a ≤ b ≤ 2147483647 且 b - a ≤ 1000000),
   求其中的素数个数。

   算法: "分段筛" (Segmented Sieve)
   - 步骤:
     1) 先用传统埃氏筛法在 [2, sqrt(b)] 区间内找出所有素数,并存放到 primes 容器中。
     2) 在要处理的区间 [a, b] 内,创建一个布尔数组 isPrimeSegment,默认都设为 true。
     3) 用前面找到的小素数集合 primes 来标记 [a, b] 区间中的合数。
        若 p 为小素数,则从 max(p * p, ceil(a/p)*p) 开始,每隔 p 步将对应位置标记为 false。
     4) 统计未被标记的数即为该区间内的素数个数。若 a <= 1,则特判排除 0、1。

   复杂度:
   - 第1步在 sqrt(b) 内作普通筛,复杂度约 O( sqrt(b) log log sqrt(b) )。
   - 第2、3步对区间长 (b - a + 1) 作标记,最多 1,000,001 长度,可行。

   注意事项:
   - 需要用 64 位类型 (long long 或 int64_t) 存储 b 的开根与下标计算。
   - 避免越界。
*/

static const int MAXN = 1000000; // b-a <= 1000000
// 用来存 [2, sqrt(b)] 中所有素数
vector<long long> primes;

// 普通埃氏筛, 获得 [2..upper] 以内所有素数
void getPrimesUpTo(long long upper) {
    // 使用简单的布尔数组进行标准筛法
    vector<bool> isPrime(upper + 1, true);
    isPrime[0] = false;
    isPrime[1] = false;
    for(long long i = 2; i * i <= upper; i++) {
        if(isPrime[i]) {
            for(long long j = i * i; j <= upper; j += i) {
                isPrime[j] = false;
            }
        }
    }
    // 将筛出的素数放到 primes 容器中
    for(long long i = 2; i <= upper; i++) {
        if(isPrime[i]) {
            primes.push_back(i);
        }
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    long long a, b;
    cin >> a >> b; 

    // 特判:若区间起点小于 2,将其拉到 2
    if(a < 2) a = 2;

    // 第 1 步: 筛出 [2, sqrt(b)] 的所有素数
    long long limit = (long long)floorl(sqrtl((long double)b));
    getPrimesUpTo(limit);

    // 第 2 步: 根據区间 [a, b] 建立 isPrimeSegment 数组
    long long segmentSize = b - a + 1; 
    vector<bool> isPrimeSegment(segmentSize, true); // 默认都当作素数

    // 第 3 步: 用上一步 primes 标记区间 [a, b] 内的合数
    for(long long p : primes) {
        if((long long)p * p > b) break; // 超出区间上界则停止
        // 找到 [a, b] 区间内, 以 p 为步长需要开始标记的位置
        long long start = max((long long)p * p, ( (a + p - 1) / p ) * p);
        for(long long x = start; x <= b; x += p) {
            isPrimeSegment[x - a] = false;
        }
    }

    // 第 4 步: 统计 isPrimeSegment 中为 true 的个数
    long long countPrime = 0;
    for(long long i = 0; i < segmentSize; i++) {
        if(isPrimeSegment[i]) countPrime++;
    }

    cout << countPrime << "\n";
    return 0;
}

连续素数和

连续素数和
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

const int N = 1e4 + 10;
using ll = long long;

int primes[N], cnt;  // primes[] 用于存储已筛出的素数,cnt 表示素数总数量
bool st[N];          // st[x] 表示 x 是否是合数;true 表示合数,false 表示尚未判断为合数

// 筛出 [2..n] 范围内的所有素数,保存到 primes[],并更新 cnt
void get_primes(int n) {
    for (int i = 2; i <= n; i++) {
        if (!st[i]) {
            primes[cnt++] = i;
        }
        for (int j = 0; j < cnt && (long long)primes[j] * i <= n; j++) {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) {
                break;
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // 先筛出 2..N 范围内的素数
    get_primes(N);

    while (true) {
        int n;
        cin >> n;
        if (!cin || n == 0) {
            break;
        }

        int ans = 0;
        // 遍历所有连续子区间 [i..j]
        for (int i = 0; i < cnt; i++) {
            ll sum = 0;
            // 连续累加
            for (int j = i; j < cnt; j++) {
                sum += primes[j];
                if (sum > n) {
                    // 过大则不必继续累加
                    break;
                }
                if (sum == n) {
                    ans++;
                }
            }
        }

        cout << ans << "\n";
    }

    return 0;
}

小明的素数对

小明的素数对
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

const int N = 100000 + 10;  
int primes[N], cnt;         // primes数组存储素数,cnt记录素数个数
bool st[N];                 // st数组标记是否为素数,st[i] = true 表示 i 不是素数


void get_primes(int n) {
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i;  

        for (int j = 0; j < cnt && primes[j] <= n / i; j++) {
            st[primes[j] * i] = true; 
            if (i % primes[j] == 0) break;  
        }
    }
}

int main() {
    int n;
    cin >> n;               
    get_primes(n);         

    int ans = 0;            
    // 遍历 primes 数组,枚举所有的素数对 (p1, p2)
    for (int i = 0; i < cnt; i++) {
        for (int j = i + 1; j < cnt; j++) {
            int diff = primes[j] - primes[i];  // 计算素数对的差
            // 检查差 diff 是否在范围内,且为素数
            if (2 <= diff && diff <= n && !st[diff]) {
                ans++;  
            }
        }
    }
    cout << ans << endl;    
    return 0;
}

疑似素数

传送门
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

const int N = 1e6+10;  
int primes[N], cnt;         // primes数组存储素数,cnt记录素数个数
bool st[N];                 // st数组标记是否为素数,st[i] = true 表示 i 不是素数


void get_primes(int n) {
  st[1]=true;
  st[0]=true;
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i;  

        for (int j = 0; j < cnt && primes[j] <= n / i; j++) {
            st[primes[j] * i] = true; 
            if (i % primes[j] == 0) break;  
        }
    }
}

int solve(int x)
{
  int sum=0;
  string s=to_string(x);
  for(int i=0;i<s.size();i++)
  {
    sum+=s[i]-'0';
  }
  return sum;
}
int main() 
{
  int n;
  cin>>n;
  int ans=0;
  get_primes(N);
  for(int i=2;i<=n;i++)
  {
    int sum=solve(i);
    if(!st[sum])
    {
      ans++;
    }
  }
  cout<<ans;
  return 0;
}

质数拆分

质数拆分
在这里插入图片描述
在这里插入图片描述

这里,若干两两不同的质数之和,这里其实很容易想到首先我们要求出2019内的所有质数,这个打个表就好了,其次两两不同,我们应该要想到动态规划。

这里设dp[i][j]表示前i个质数,可以两两不同加起来等于j的方案数。

如果当前j>=prime[i],说明当前的质数可以取,取完后我们只要看j-prime[i]有多少种取法,那么方案数之中有部分为dp[i-1][j-prime[i]]种,另外一部分是不取当前的质数prime[i],即dp[i-1][j]。若j<prime[i],说明当前我们取不了prime[i],只有上面两种情况下的后一种即dp[i-1][j]。

其次,我们怎么初始化呢?我们初始化dp[0][0]=1,这样我们就能在第一次质数2的时候初始化了。

#include <iostream>
using namespace std;

const int N=10000;
const int M=2020;
long long dp[M][M];

int primes[N], cnt;
bool st[N];         

void get_primes(int n)
{
    for (int i = 2; i <= n; i++)
    {
        if (!st[i]) {
            primes[cnt++] = i;
        }
        for (int j = 0; j < cnt; j++)
        {
            // 如果当前primes[j]*i超过n,则可跳出循环
            long long t = (long long)primes[j] * i;
            if (t > n) break;
            st[t] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

int main()
{
    get_primes(2019);

    dp[0][0] = 1;
    // i从1开始到cnt,但使用primes[i-1]
    for(int i = 1; i <= cnt; i++)
    {
        int p = primes[i-1];
        for(int j = 0; j <= 2019; j++)
        {
            dp[i][j] = dp[i-1][j];
            if(j >= p) {
                dp[i][j] += dp[i-1][j - p];
            }
        }
    }

    cout << dp[cnt][2019] << endl;
    return 0;
}

将dp改为一维数组

#include <iostream>
using namespace std;

static const int M = 2020; // 要覆盖到 2019
long long dp[M];

int primes[10000], cnt;
bool st[10000];

void get_primes(int n)
{
    for(int i = 2; i <= n; i++)
    {
        if(!st[i]) primes[cnt++] = i;
        for(int j = 0; j < cnt; j++)
        {
            long long t = (long long)primes[j] * i;
            if(t > n) break;
            st[t] = true;
            if(i % primes[j] == 0) break;
        }
    }
}

int main()
{
    get_primes(2019);

    dp[0] = 1;
    // 使用 下标 i ∈ [0, cnt-1],对应第 i 个质数
    for(int i = 0; i < cnt; i++)
    {
        int p = primes[i];
        for(int j = 2019; j >= p; j--)
        {
            dp[j] += dp[j - p];
        }
    }

    cout << dp[2019] << endl;
    return 0;
}

纯质数

纯质数
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
const int N=20210605+10;
int primes[N],cnt;
bool st[N];// 标记是否为合数,st[i]=false => i是质数或i=1

void get_primes(int n)
{
  for(int i=2;i<=n;i++)
  {
    if(!st[i])primes[cnt++]=i;
    for(int j=0;primes[j]<=n/i;j++)
    {
      st[primes[j]*i]=true;
      if(i%primes[j]==0)break;
    }
  }
}

bool solve(int x)// 判断整数 x 的每个十进制位是否都是 2,3,5,7
{
   while(x>0)
    {
        int d = x%10;
        if(d!=2 && d!=3 && d!=5 && d!=7) {
            return false;
        }
        x/=10;
    }
    return true;
}

int main()
{
  int ans=0;
  get_primes(20210605);
  for(int i=2;i<=20210605;i++)
  {
    if(!st[i])// i是质数
    {
      if(solve(i))
      {
        ans++;
      }
    }
 }
 cout<<ans;
  return 0;
}

超级质数

超级质数
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
/*
1.10以内的质数有2,3,5,7
2.根据超级质数的组成规则可以组成23,37,53,57,73这样的相邻质数组合,
满足要求的有23,37,53,73 
3.根据这些组合可以组成237,373,573,737这样的数字组合,满足要求的只有373
4.根据组成规则已经不能在373的基础之上进行组合,即为最大超级质数 
*/
bool is_primes(int x)
{
  if(x<2)return false;
  for(int i=2;i<=x/i;i++)
  {
    if(x%i==0)
    {
      return false;
    }
  }
  return true;

}
int main()
{
  // int n;
  // while(1)
  // {
  //   cin>>n;
  //   if(is_primes(n))
  //   {
  //     cout<<"是素数"<<endl;
  //   }
  //   else 
  //   {
  //     cout<<"不是素数"<<endl;
  //   }

  // }
  cout<<373;
  return 0;
}

质数日期

质数日期
在这里插入图片描述

暴力做法

#include <bits/stdc++.h>
using namespace std;

const int N=3e7+10;
using ll=long long;



int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉
void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

int months[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int date)
{
  int year=date/10000,month=date%10000/100,day=date%100;

  if(!month||month>=13||!day)return false;
  if(month!=2&&day>months[month])return false;
  if(month==2)
  {
    int leap=(year%4==0&&year%100!=0)||year%400==0;
    if(day>28+leap)return false;
  }
  return true;
}
int main()
{
  ll s,t;
  cin>>s>>t;

  get_primes(t);
  int cnt=0;

  for(int i=s;i<=t;i++)
  {
    if(check(i))
    {
      if(!st[i])
      {
        cnt++;
      }
    }
    
  }
  cout<<cnt;
  return 0;
}

在这里插入图片描述

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

typedef long long LL;

const int N = 100010;

int n;
int f[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
int primes[N],cnt;
bool st[N];

void get_primes(int n)
{
    for(int i = 2;i <= n;i++)
    {
        if(!st[i]) primes[cnt++] = i;
        for(int j = 0;primes[j] <= n / i;j++)
        {
            st[primes[j] * i] = true;
            if(i % primes[j] == 0) break;
        }
    }
}

bool check(int n)
{
    if((n % 400 == 0) || (n % 4 == 0 && n % 100 != 0)) return true;
    return false;
}

int main()
{
    get_primes(N - 1);
    
    LL a,b;
    cin >> a >> b;
    
    int res = 0;
    for(int i = a / 10000;i <= b / 10000;i++)
    {
        if(check(i)) f[2] = 29;
        else f[2] = 28;
        for(int j = 1;j <= 12;j++)
        {
            for(int k = 1;k <= f[j];k++)
            {
                LL p = i * 10000ll + j * 100ll + k;
                if(p < a) continue;
                else if(p > b) break;
                else
                {
                    bool flag = true;
                    for(int l = 0;l < cnt && (LL)primes[l] * primes[l] <= p;l++)
                        if(p % primes[l] == 0)
                        {
                            flag = false;
                            break;
                        }
                    if(flag)
                    {
                        res++;
                    }
                }
            }
        }
    }
    
    cout << res << '\n';
    
    return 0;
}

质数游戏2

质数游戏2
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5 + 10; // 定义素数的最大值

int primes[N], cnt;     // primes[] 存储素数,cnt计数素数的数量
bool st[N];            // st[x] 存储 x 是否被筛掉

// 函数用于获取1到 n 的所有素数
void get_primes(int n) {
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i; 
        for (int j = 0; primes[j] <= n / i; j++) { 
            st[primes[j] * i] = true; 
            if (i % primes[j] == 0) break; 
        }
    }
}

int ans; // 计数满足条件的子序列数量
int n; // 序列长度
int a[N]; // 存放数字序列

// DFS函数
void dfs(int u, int cnt, int sum) { // u: 当前遍历位置,cnt:当前子序列数字个数,sum:当前子序列数字和
    // 当 u 超过 n 时,表示已遍历完序列
    if (u == n + 1) {
        // 判断数量和和是否满足条件
        if (cnt >= 2 && !st[cnt] && sum >= 2 && !st[sum]) {
            ans++; 
        }
        return;
    }

    // 选择当前数字
    dfs(u + 1, cnt + 1, sum + a[u]); // 选择当前数字,增加个数和和
    // 不选择当前数字
    dfs(u + 1, cnt, sum); // 不选择当前数字,保持不变
}

int main() {
    cin >> n; 

    get_primes(N); // 获取所有素数
    for (int i = 1; i <= n; i++) {
        cin >> a[i]; 
    }

    dfs(1, 0, 0); // 从第一个数字开始DFS
    cout << ans; 
    return 0;
}

魔法阵的能量

魔法阵的能量

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

/*
  思路说明(以代码注释形式呈现):

  1. 先读取输入 n,然后判断 n 是奇数还是偶数。
     如果 n 是奇数 (n & 1),则直接输出 0 并返回。原因是通过该实现的逻辑认为,
     如果 n 为奇数,则没有充分的 2 的因子来与 5 配对形成末尾零。

  2. 如果 n 是偶数,将 ans 设为 n/10,表示在此实现中,
     先简单认为除以 10 得到其中 2 的数量(实际上并不精准匹配题意,但这是此代码的做法)。
     然后再将 n 减少 10 倍(n /= 10)。

  3. 循环中使用 e=5,每次将 e *= 5,不断统计 n/e,累加到 ans 中,试图统计 5 的因子总数。
     这种统计 5 的方法类似于统计 n! 里 5 的因子个数的方法。

  4. 最终打印 ans,作为末尾零的数量。


*/

signed main() {
    long long n;
    cin >> n;

    // 如果 n 是奇数,直接返回 0
    if (n & 1) {
        cout << 0 << '\n';
        return 0;
    }

    // 将 n 除以 10,试图统计其中的 2 的数量
    long long ans = n / 10;
    n /= 10;

    // 统计 5 的数量
    long long e = 5;
    while (e <= n) {
        ans += n / e;
        e *= 5;
    }

    // 最终打印累加值 ans
    cout << ans << '\n';
    return 0;
}

阿坤老师切割年糕

阿坤老师切割年糕
在这里插入图片描述

解题思路
大致题意:

给定一个整数n,把n分为两个整数,如果这两个整数存在一个是另一个的因数,输出加1,求n中有多少个这样的输出

一般思路 :

n为输入的值

x + (n-x) = n

(n-x) % x == 0时计数器加1

可行但时间复杂度大

枚举因数 :

由题意x + y =n 已知x是y的因数 即c * x = y, c为大于0的任意常数

则x + y = x + c*x = x(c + 1 ) = = n

枚举x

一个数的因数只用遍历到此数的开根号,例如100,只需遍历1~10,这样就可以大大提升效率,具体原理就自己百度一下;

如果n % x == 0, 即存在一个整数c + 1 使(c +1)* x = n, 结果加2

为什么加2,当n%x == 0时,x是n的因数,n/x也是n的因数

例如n=4时,x的实际范围是1~2,当x=1时,4%1 = 0,4/1=4,1和4都是n的因数 所以加2

如果n // x = x,结果加1(因为两个数是一样的,加1即可)

当x=2时,x=n/x=2,加1即可

最后,我们会发现因数不能等于n,例如x=4时,1+4=5已经大于n了,故cnt要减1
#include <bits/stdc++.h>
using namespace std;

int main()
{
  int n;
  cin>>n;

  int cnt=0;

  for(int i=1;i<=n/i;i++)
  {
    if(n%i==0)
    {
      if(n/i==i)
      {
        cnt+=1;
      }
      else 
      {
        cnt+=2;
      }
    }
  }
  cout<<cnt-1;
  return 0;
}

阶乘分解

阶乘分解

阶乘的约数和

阶乘的约数和

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

const int mod = 998244353; // 模数

// 定义一个全局 map,用于存储质因数及其对应的次数
map<int, long long> mp;

// 对整数 x 进行质因数分解,并将其质因数及对应的次数存入 mp 中
void solve(int x) {
    
    for (int i = 2; i <= x / i; i++) {
        int cnt = 0; 
        while (x % i == 0) { // 如果 i 是 x 的一个因子
            cnt++;
            x /= i; 
        }
        if (cnt) mp[i] += cnt; // 如果 i 是质因数,记录其次数
    }
    // 如果 x 本身是一个大于 1 的质数
    if (x > 1) mp[x]++;
}

int main() {
    int n;
    cin >> n; 

    // 对 2 到 n 的所有整数进行质因数分解
    for (int i = 2; i <= n; i++) solve(i);

    long long sum = 1; // 用于存储约数之和的结果
    // 遍历所有质因数及其次数
    for (auto& [p, c] : mp) {
        long long ret = 0, t = 1;
        // 计算当前质因数 p 的约数和部分 (1 + p + p^2 + ... + p^c) % mod
        for (int i = 0; i <= c; i++) {
            ret = (ret + t) % mod; // 累加当前项
            t = t * p % mod; // 计算下一项 (p^i)
        }
        // 将当前质因数的约数和乘入结果
        sum = sum * ret % mod;
    }
    
    cout << sum << endl;
    return 0;
}

程序的输出零

程序的输出零

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

int main() {
  int n, res = 0;
  cin >> n;

  // 思路:需要计算f(n)的末尾有多少个零。
  // 尾数为0的数字来源于因子2和5的乘积,且因子5的数量通常比因子2少。
  // 所以,我们主要计算f(n)中因子5的数量。
  // 由于f(n) = n * f(n-2),相当于每隔2个数乘一次,只考虑偶数情况。

  if (n % 2 == 0) { // 如果n是偶数
    for (int i = n; i > 1; i = i - 2) { // 从n开始每隔2个数递减
      int temp = i;
      while (temp % 5 == 0) { // 计算当前数中包含多少个因子5
        res++; // 每找到一个因子5,结果加1
        temp /= 5; // 除以5继续检查
      }
    }
  }

  cout << res << endl; // 输出结果
  return 0;
}

双子数

双子数
在这里插入图片描述
在这里插入图片描述

#include <iostream>
using namespace std;
const int N = 4e6 + 10;

int primes[N], cnt; 
bool st[N];        


void get_primes(int n) {
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i;
        for (int j = 0; primes[j] <= n / i; j++) {
            st[primes[j] * i] = true; 
            if (i % primes[j] == 0) break;
        }
    }
}

int main() {
    int ans = 0;
    get_primes(N); // 获取所有小于等于N的素数

    // 遍历所有素数对(p, q)
    for (int i = 0; i < cnt; i++) {
        for (int j = 0; j < i && 1LL * primes[i] * primes[j] * primes[i] * primes[j] <= 23333333333333LL; j++) {
            // 检查p和q的乘积是否在给定范围内
            if (1LL * primes[i] * primes[j] * primes[i] * primes[j] >= 2333) {
                ++ans; 
            }
        }
    }

    cout << ans; // 输出结果
    return 0;
}

躲炮弹

躲炮弹
在这里插入图片描述
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
using ll=long long;

int n,L,R;
int ans;

bool check(int x)// 枚举x的所有因数
{
  for(int i=1;i<=x/i;i++)
  {
    if(x%i==0)
    {
      if(L<=i&&i<=R)return true;// 如果因数i或x/i在[L, R]范围内,则返回true
      if(L<=x/i&&x/i<=R)return true;
    }
  }
  // 如果没有因数在[L, R]范围内,则返回false
  return false;
}
int main()
{
  cin>>n>>L>>R;

	// 如果初始位置n在[L, R]范围内
  if(L<=n&&n<=R)
  {
    int ans = n - L + 1; // 初始位置到L的距离
    for(int i=1;i<=2000;i++) // 枚举从R开始向右最多2000步的距离,寻找一个合法位置
    {
      if(!check(R+i))
      {
        ans=min(ans,R+i-n);// 更新最小步数
        break;
      }
    }
    cout<<ans<<endl;
    return 0;
  }
  else // 如果初始位置n不在[L, R]范围内
  { // 枚举从n向左右最多2000步的距离,寻找一个合法位置
    for(int i=0;i<=2000;i++)
    {
      if(!check(n+i)||!check(n-i))
      {
        cout<<i<<endl;
        break;
      }
    }
  }
  
  return 0;
}

GCD+LCM

互质数的个数

互质数的个数
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const int MOD = 998244353;

// 快速幂算法,计算 a^b % c
ll qmi(ll a, ll b, ll c) {
    ll ans = 1;
    a %= c;
    while (b) {
        if (b & 1) {
            ans = (ans * a) % c;
        }
        a = (a * a) % c;
        b >>= 1;
    }
    return ans;
}

int main() {
    int a, b;
    cin >> a >> b;
    ll mi = qmi(a, b, MOD); // 计算 a^b % MOD
    ll ans = 0;
    // 统计与 mi 互质的数的个数
    for (int i = 1; i < mi; i++) {
        if (__gcd((ll)i, mi) == 1) ans++;
    }
    cout << ans;
    return 0;
}

等差数列

等差数列
在这里插入图片描述
在这里插入图片描述
a n = a 1 + ( n − 1 ) d a_n=a_{1}+(n-1)d an=a1+(n1)d

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int a[100000];
int main()
{
  int n;
  cin>>n;
  for(int i=1;i<=n;i++)
  {
    cin>>a[i];
  }
  sort(a+1,a+1+n);
  int d=0;
  for(int i=2;i<=n;i++)
  {
    d=__gcd(d,a[i]-a[i-1]);
    
  }

  if(d==0)
  {
    cout<<n<<endl;
  }
  else cout<<(a[n]-a[1])/d+1;
  return 0;
}

Hankson 的趣味题

Hankson 的趣味题
在这里插入图片描述
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
using ll=long long;

int lcm(int a,int b)
{
  return a/__gcd(a,b)*b;
}
int main()
{
  int n;
  cin>>n;
  while(n--)
  {
    int a0,a1,b0,b1;
    cin>>a0>>a1>>b0>>b1;
    int ans=0;
    for(int x=1;x<=sqrt(b1);x++)
    {
      if(b1%x==0)
      {
        if(__gcd(x,a0)==a1&&lcm(x,b0)==b1)ans++;
        int y=b1/x;
        if(x==y)
        {
          continue;
        }
        if(__gcd(y,a0)==a1&&lcm(y,b0)==b1)ans++;
      }
    }
    cout<<ans<<endl;
  }

  return 0;
}

核桃的数量

核桃的数量
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

/*
  题目思路:
  1. 我们需要确保每个开发组(共3个)分到的核桃数量相同,并且能够被各组人数整除。
  2. 这意味着每袋核桃数量是 a、b、c 三个数的最小公倍数 (LCM)。
  3. 先计算 a 和 b 的 LCM,再与 c 的 LCM 进行计算,得到所有人的最小公倍数即为答案。
*/

int lcm(int x, int y) {
    // 计算两个数的最小公倍数,公式:LCM(a, b) = (a * b) / GCD(a, b)
    return x / std::gcd(x, y) * y;
}

int main() {
    int a, b, c;
    cin >> a >> b >> c;               // 从输入读取 a, b, c
    int num = lcm(lcm(a, b), c);      // 先求 a 和 b 的 LCM,再与 c 一起求 LCM
    cout << num;
    return 0;
}

奇偶比例

奇偶比例
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

/*
  解题思路:
  1. 使用前缀数组 preodd 和 preven 分别统计前 i 个数中的奇数和偶数个数,方便快速获取任意区间的奇偶数目。
  2. 定义函数 getpair(l, r) 返回子区间 [l..r] 的奇偶数最简比例;将末端区间 [i..n] 的比例出现次数记录在哈希表中,并且在遍历时累加前端区间 [1..i-1] 所对应的相同比例出现次数。
*/

const int N = 1e5 + 7;
using PII = pair<int,int>;

// 存储奇偶数量前缀和
int a[N], preodd[N], preven[N];

// 计算最大公约数
int gcd(int x, int y) {
    return y == 0 ? x : gcd(y, x % y);
}

// 计算区间 [l..r] 的奇偶数最简比例
PII getpair(int l, int r) {
    int oddCount = preodd[r] - preodd[l - 1];
    int evenCount = preven[r] - preven[l - 1];
    
    // 若全部为偶数
    if (oddCount == 0) {
        return {0, 1};
    }
    // 若全部为奇数
    else if (evenCount == 0) {
        return {1, 0};
    }
    // 否则计算奇偶数的最简比
    else {
        int g = gcd(oddCount, evenCount);
        return {oddCount / g, evenCount / g};
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> a[i];
        // 更新奇数前缀和与偶数前缀和
        preodd[i] = preodd[i - 1] + (a[i] % 2);
        preven[i] = preven[i - 1] + (a[i] % 2 == 0);
    }
    
    // 哈希表统计 每种奇偶最简比例出现的次数
    map<PII, int> mp;
    long long cnt = 0;

    // 从后往前遍历,记录 [i..n] 这段的奇偶最简比例出现次数
    // 并累加和 [1..i-1] 区间有相同最简比例的次数
    for(int i = n; i > 1; i--) {
        mp[getpair(i, n)]++;
        cnt += mp[getpair(1, i - 1)];
    }
    
    cout << cnt << "\n";
    return 0;
}

旅行I

旅行I
在这里插入图片描述

最大公约数 (gcd) 的特性是,它能找到多个步长之间的最大公共步长。如果我们没有包含所有国家对 x 的影响,那我们可能会错过一些可行的移动步长 D。

#include <bits/stdc++.h>
using namespace std;

/*
  思路注释:
  1. 首先对国家坐标进行排序,方便确定最小和最大位置。
  2. 将移动距离 D 决定为 gcd(...),即 x 与每个国家坐标之间差值的最大公约数(若某个差值为0则修正为1),
     这样可以保证在固定步长 D 下依然可以到达所有国家。
  3. 根据小蓝初始坐标 x 所处的位置关系(可能在最右、在最左或在中间),
     分别计算在步长为 D 时从 x 覆盖到所有国家所需的最少移动次数。
*/

int gcd(int a, int b) {
    while (b != 0) {
        int tmp = a;
        a = b;
        b = tmp % b;
    }
    return a;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, x;
    cin >> n >> x;
    vector<int> a(n);

    for(int i = 0; i < n; i++) {
        cin >> a[i];
    }

    // 对所有国家坐标排序
    sort(a.begin(), a.end());

    // 初始化 d 为 |a[0] - x|
    int d = abs(a[0] - x);
    if(d == 0) {
        d = 1; // 避免 gcd(0,0) 的情况
    }

    // 计算 x 与其他国家之间坐标差值的最大公约数
    for(int i = 0; i < n - 1; i++) {
        d = gcd(d, abs(a[i + 1] - x));
    }

    int ans = 0;
    if(x >= a[n - 1]) {
        // 若 x 已经在最右侧,计算从 x 到最左侧坐标的距离 (x-a[0]),再除以步长 d
        ans = (x - a[0]) / d;
    } else if(x > a[0]) {
        // 若 x 在中间位置,则尝试向左/向右覆盖全部国家,取覆盖最大的距离
        if(a[n - 1] - x > x - a[0]) {
            ans = ((x - a[0]) + (a[n - 1] - a[0])) / d;
        } else {
            ans = ((a[n - 1] - x) + (a[n - 1] - a[0])) / d;
        }
    } else {
        // 若 x 在最左侧,计算从 x 到最右侧 a[n-1] 的距离 (a[n-1]-x),再除以 d
        ans = (a[n - 1] - x) / d;
    }

    cout << ans << endl;
    return 0;
}

寻找她

寻找她
在这里插入图片描述

#include <iostream>
using namespace std;

/*
  思路说明:
  1. 首先读取 n,即可买到的地铁票种数,并分别读入每种票的价格 a[i] 以及可移动站数 b[i]。
  2. 为了保证能到达所有地铁站,需要选择两张票的步数 b[i], b[j] 满足 gcd(b[i], b[j])=1,
     因为只有当步数之间的最大公约数为 1 时,才能组合出任意距离覆盖所有站点。
  3. 使用两重循环检索任意两张地铁票,若它们的 b 值满足 gcd(b[i], b[j])=1,则更新最小花费。
  4. 如果遍历结束都找不到 gcd=1 的票对,则输出 -1,否则输出最小花费。
*/

#define ll long long

// 计算最大公约数
ll gcd(ll a, ll b) {
    if (b > a) {
        ll t = a;
        a = b;
        b = t;
    }
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

int main() {
    ll n;
    cin >> n;
    ll a[n], b[n];

    // 读入价格数组
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    // 读入可移动站数数组
    for (int i = 0; i < n; i++) {
        cin >> b[i];
    }

    // 初始化最小花费(先取前两张票价格之和)
    ll money = a[0] + a[1];
    int flag = 0; // 标记是否能找到 gcd=1 的票对

    // 检索两两票组合,寻找 gcd=1
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (gcd(b[i], b[j]) == 1) {
                flag = 1;
                money = min(money, a[i] + a[j]);
            }
        }
    }

    // 若没找到满足 gcd=1 的任意票对,则输出 -1
    if (flag == 0) {
        cout << -1;
        return 0;
    }

    // 否则输出最小花费
    cout << money;
    return 0;
}

小咕咕

小咕咕

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

int lcm(int a,int b)
{
  return a/__gcd(a,b)*b;
}
int main()
{
  int a,b,t;
  cin>>a>>b>>t;
  
  int sum=lcm(a,b);
  int ans=t/sum;
  cout<<ans;
  return 0;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2322999.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

vue响应式原理剖析

一、什么是响应式? 我们先来看一下响应式意味着什么?我们来看一段代码: m有一个初始化的值,有一段代码使用了这个值; 那么在m有一个新的值时,这段代码可以自动重新执行; let m = 20 console.log(m) console.log(m * 2)m = 40上面的这样一种可以自动响应数据变量的代码机…

Element UI实现表格全选、半选

制作如图所示的表格全选、半选&#xff1a; 父组件 <template><div id"app"><SelectHost :hostArray"hostArray" /></div> </template><script> import SelectHost from ./components/SelectHost.vue export default…

如何使用动作捕捉系统训练人形机器人

随着人形机器人变得越来越先进&#xff0c;使用动作捕捉系统教会它们如何像人类一样移动成为了人形机器人领域正在研究的全新方向。本文探讨了如何使用Xsens技术捕捉精确的人类运动数据&#xff0c;使机器人能够通过人工智能和机器学习安全高效地学习、适应和执行复杂任务。 近…

内网渗透技术 Docker逃逸技术(提权)研究 CSMSF

目录 如何通过上传的webshell判断当前环境是否是物理环境还是Docker环境 方法一&#xff1a;检查文件系统 方法二&#xff1a;查看进程 方法三&#xff1a;检查网络配置 方法四&#xff1a;检查环境变量 方法五&#xff1a;检查挂载点 总结 2. 如果是Docker环境&#x…

生活电子常识——cmd不能使用anaconda的python环境,导致输入python打开应用商店

前言 电脑已经安装了anaconda,从自带的Anaconda Prompt (Anaconda3)中是可以识别python环境的&#xff0c;然而切换到cmd时&#xff0c;突然发现cmd中无法识别anaconda的python环境&#xff0c;竟然打开了应用商店让我安装Python&#xff0c;这当然是不对的。 解决 这是因为…

如何在linux中部署dns服务 主备dns (详细全过程)

环境centos 7.9 主DNS&#xff1a;192.168.60.131 备DNS&#xff1a;192.168.60.134 我以 chenxingyu0.com 指向 192.168.60.200为例 首先是主dns #!/bin/bash# 检查是否为 root 用户 if [ "$(id -u)" ! "0" ]; thenecho "请使用…

word写latex-Mathtype安装成功-方法

MathType安装报错 想在word写latexMathtype, 网上搜教程安装&#xff0c; 结果一直报错一直删重来&#xff0c; 一直报错一直删了重来 一直报错一直删了重来来来&#xff0c; 就这么反反复复一直不好 网上的教程都是教你不是删mathtype, 就是删office 时代变了啊&#x…

【踩坑日记】springboot 打包后实现类无法找到

试过了所有改什么目录 依赖 clean都以失败告终 最后将实现类的文件名从Impl改成impl宣布成功 记得使用idea自带的重构

deepseek(2)——deepseek 关键技术

1 Multi-Head Latent Attention (MLA) MLA的核心在于通过低秩联合压缩来减少注意力键&#xff08;keys&#xff09;和值&#xff08;values&#xff09;在推理过程中的缓存&#xff0c;从而提高推理效率&#xff1a; c t K V W D K V h t c_t^{KV} W^{DKV}h_t ctKV​WDKVht​…

Linux (Centos7)安装Mongodb4.0.28

一、官网下载安装包上传到服务器系统 官网&#xff1a;https://www.mongodb.com/try/download/community 放在/opt/software目录下&#xff1a; 二、解压至/usr/local目录下&#xff0c;并重新命名为mongodb [rootlocalhost software]# tar -zxvf mongodb-linux-x86_64-rhel7…

数据库设计-笔记4

1.操作词汇简介 insert&#xff1a;用于向表中插入新记录。 delete&#xff1a;用于从表中删除记录。 update&#xff1a;用于修改表中已有的记录。 select&#xff1a;用于从表中检索数据。 2.代码基础(增删改&#xff09; -- 修改表中的信息 -- 修改表名 alter table s…

基于python的图书管理系统设计与实现

摘要 21世纪的今天&#xff0c;随着计算机技术和网络技术的的不断推广发展和应用&#xff0c;图书馆管理方式也应该随之而更新&#xff0c;借由人力进行繁杂重复的图书管理工作已经不再可取&#xff0c;人们对于信息科学化的认识&#xff0c;已由低层次向高层次发展&#xff0…

RAG专栏:向量数据库

一、数据库分类 键值数据库&#xff08;Key-Value&#xff09;&#xff1a;通常用于简单的数据存储&#xff0c;通过键来快速访问数据。文档数据库&#xff08;Document&#xff09;&#xff1a;用于存储文档结构的数据&#xff0c;如 JSON 格式。图数据库&#xff08;Graph&a…

【GPUStack】【dify】【RAGflow】:本地部署GPUStack并集成到dify和RAGflow

目录 Nvidia-Driver CUDA NVIDIA Container Toolkit&#xff08;新版本的docker不用安装&#xff0c;自带&#xff09; Docker 部署GPUStack Text Embeddings 部署模型库模型 测试 部署开源模型&#xff08;modelscope&#xff09; dify 集成 RAGflow集成 Nvidia-Dri…

逼用户升级Win11,微软开始给Win10限速

随着Windows10的支持时间越来越短&#xff0c;微软也加大了对Win10用户的驱赶力度。 最近&#xff0c;微软官宣了将要在今年6月份降低OneNote for Windows 10的同步速度。软件也将和Windows10在今年的10月14日一同停止支持和维护。 这将影响实时协作和多设备访问。 对OneNote…

HarmonyOs-ArkUI List组件

列表是一个复杂的容器&#xff0c;当列表项达到一定数量&#xff0c;使得列表内容超出其范围的时候&#xff0c;就会自动变为可以滚动。列表适合用来展现同类数据类型。 List组件支持使用&#xff0c;条件渲染&#xff0c;循环渲染&#xff0c;懒加载等渲染控制方式生成子组件…

基于YOLOv8深度学习的PCB缺陷检测识别系统【python源码+GUI界面+数据集+训练代码+登录界面】

目录 一、界面全貌展示 二、前言摘要 三、GUI界面演示 &#xff08;一&#xff09;用户加载自定义模型 &#xff08;二&#xff09;单张图像检测 &#xff08;三&#xff09;检测图像文件夹 &#xff08;四&#xff09;检测视频 &#xff08;五&#xff09;摄像头检测 …

鸿蒙生态圈暗战:数字孪生三强争霸谁将主宰消费电子未来?

IDC数据显示&#xff0c;2025年Q1华为以38.7%份额领跑中国折叠屏市场&#xff0c;Pura X首月销量突破120万台。这款搭载HarmonyOS 5的旗舰&#xff0c;通过灵犀通信技术实现5G A网络下载速率提升30%&#xff0c;并在离线环境下完成厘米级导航。其爆款逻辑背后&#xff0c;是鸿蒙…

react 15-16-17-18各版本的核心区别、底层原理及演进逻辑的深度解析

一、React 15&#xff08;2016&#xff09; 核心架构&#xff1a;Stack Reconciler&#xff08;栈协调器&#xff09; 工作原理&#xff1a; 同步递归渲染&#xff1a;采用深度优先遍历方式递归处理 Virtual DOM&#xff0c;形成不可中断的调用栈渲染流程&#xff1a;1. 触发 …

CMS迁移中SEO优化整合步骤详解

内容概要 在CMS迁移过程中&#xff0c;系统化的规划与执行是保障SEO排名稳定性的核心。首先需明确迁移流程的关键阶段&#xff0c;包括数据备份、URL适配、元数据同步及安全配置等环节。其中&#xff0c;数据备份不仅需覆盖原始数据库与静态资源&#xff0c;还需验证备份文件的…