蓝桥杯2023年真题（1）

1.分糖果

在这里插入图片描述

#include <iostream>
using namespace std;
int a = 9, b = 16, c = 7, d = 2, e = 5;
int ans = 0;
//u是当前第几个分糖果的小朋友，x和y是还剩的糖果
void dfs(int u, int x, int y){
  if(u > c){
    //如果都为0，就是已经分完了
    if(!x && !y) ans++;
    return;
  }
  for(int i = 0; i <= x; i++)
    for(int j = 0; j <= y; j++)
      if(i + j >= d && i + j <= e)
        dfs(u + 1, x - i, y - j);
}
int main()
{
  dfs(1, a, b);
  cout<<ans;
  return 0;
}

2.字母数

在这里插入图片描述

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

int f(int x){
  vector<int> v;
  int t = x;
  while(t){
    int z = t % 16;
    t /= 16;
    v.push_back(z);
  }
  for(int i = 0; i < v.size(); i++)
    if(v[i] < 10) return 0;
  return 1;
}

int main()
{
  int a = 2022, flag = 1;
  while(flag){
    a++;
    if(f(a)){
      cout<<a;
      flag = 0;
    }
  }
  return 0;
}

3.列名

在这里插入图片描述

#include <iostream>
using namespace std;
int main()
{
  int a = 26 + 26 * 26;
  for(int i = 0; i <= 25; i++){
    for(int j = 0; j <= 25; j++){
      for(int k = 0; k <= 25; k++){
        a++;
        if(a == 2022){
          cout<<char('A' + i)<<char('A' + j)<<char('A' + k);
          return 0;
        }
      }
    }
  }
  return 0;
}

4.特殊日期

在这里插入图片描述

#include <iostream>
using namespace std;
int a[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int ans = 0;

int f(int x){
  int sum = 0;
  while(x){
    sum += x % 10;
    x /= 10;
  }
  return sum;
}

int main()
{
  for(int i = 1900; i <= 9999; i++){
    if(i % 400 == 0 || (i % 4 == 0 && i % 100 != 0)) a[1] = 29;
    else a[1] = 28;
    int x = f(i);
    for(int j = 0; j < 12; j++){
      for(int k = 1; k <= a[j]; k++){
        int y = f(j + 1), z = f(k);
        if(x == y + z) ans++;
      }
    }
  }
  cout<<ans;
  return 0;
}

5.大乘积

在这里插入图片描述

#include <iostream>
using namespace std;
int a[] = {99, 22, 51, 63, 72, 61, 20, 88, 40, 21, 63, 30, 11, 18, 99, 12, 93, 16, 7, 53, 64, 9, 28, 84, 34, 96, 52, 82, 51, 77};
int ans = 0;
int main()
{
  for(int i = 0; i < 30; i++)
    for(int j = i + 1; j < 30; j++)
      if(a[i] * a[j] >= 2022) ans++;
  cout<<ans;
  return 0;
}

6.最大连通

在这里插入图片描述

#include <iostream>
using namespace std;
int hh, tt = -1;
pair<int, int> q[30 * 60];
string g[] = {
"110010000011111110101001001001101010111011011011101001111110",

"010000000001010001101100000010010110001111100010101100011110", 

"001011101000100011111111111010000010010101010111001000010100", 

"101100001101011101101011011001000110111111010000000110110000", 

"010101100100010000111000100111100110001110111101010011001011", 

"010011011010011110111101111001001001010111110001101000100011", 

"101001011000110100001101011000000110110110100100110111101011", 

"101111000000101000111001100010110000100110001001000101011001", 

"001110111010001011110000001111100001010101001110011010101110", 

"001010101000110001011111001010111111100110000011011111101010", 

"011111100011001110100101001011110011000101011000100111001011", 

"011010001101011110011011111010111110010100101000110111010110", 

"001110000111100100101110001011101010001100010111110111011011", 

"111100001000001100010110101100111001001111100100110000001101", 

"001110010000000111011110000011000010101000111000000110101101", 

"100100011101011111001101001010011111110010111101000010000111", 

"110010100110101100001101111101010011000110101100000110001010", 

"110101101100001110000100010001001010100010110100100001000011", 

"100100000100001101010101001101000101101000000101111110001010", 

"101101011010101000111110110000110100000010011111111100110010", 

"101111000100000100011000010001011111001010010001010110001010", 

"001010001110101010000100010011101001010101101101010111100101",

"001111110000101100010111111100000100101010000001011101100001", 

"101011110010000010010110000100001010011111100011011000110010", 

"011110010100011101100101111101000001011100001011010001110011", 

"000101000101000010010010110111000010101111001101100110011100", 

"100011100110011111000110011001111100001110110111001001000111", 

"111011000110001000110111011001011110010010010110101000011111", 

"011110011110110110011011001011010000100100101010110000010011", 

"010011110011100101010101111010001001001111101111101110011101"};
int cnt, ans;
int st[30][60];

void bfs(int x, int y){
  int dx[] = {0, 0, 1, -1};
  int dy[] = {1, -1, 0, 0};
  st[x][y] = 1;
  q[++tt] = make_pair(x, y);
  while(hh <= tt){
    auto it = q[hh++];
    for(int i = 0; i < 4; i++){
      int a = it.first + dx[i], b = it.second + dy[i];
      if(a < 0 || a >= 30 || b < 0 || b >= 60) continue;
      if(g[a][b] != '1') continue;
      if(st[a][b]) continue;
      cnt++;
      st[a][b] = 1;
      q[++tt] = make_pair(a, b);
    }
  }
}

int main()
{
  for(int i = 0; i < 30; i++){
    for(int j = 0; j < 60; j++){
      if(g[i][j] == '1'){
        cnt = 1;
        bfs(i, j);
        ans = max(ans, cnt);
      }
    }
  }
  cout<<ans;
  return 0;
}

7.星期几

在这里插入图片描述

#include <iostream>
using namespace std;
int main()
{
  int w, n;
  cin>>w>>n;
  while(n--){
    w++;
    if(w == 8) w = 1;
  }
  cout<<w;
  return 0;
}

8.信号覆盖

在这里插入图片描述

#include <iostream>
using namespace std;
int ans, st[200][200];
int main()
{
  int w, h, n, r;
  cin>>w>>h>>n>>r;
  int x, y;
  while(n--){
    cin>>x>>y;
    for(int i = 0; i <= w; i++){
      for(int j = 0; j <= h; j++){
        if((x - i) * (x - i) + (y - j) * (y - j) <= r * r && !st[i][j]){
          ans++;
          st[i][j] = 1;
        }
      }
    }
  }
  cout<<ans;
  return 0;
}

9.清理水域

在这里插入图片描述

10.滑行

在这里插入图片描述

#include<iostream>
#include<cstring>
using namespace std;
const int N = 200;
int g[N][N], st[N][N];
int n, m;
int ans;

int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};

int dfs(int x, int y){
  //如果已存储过这个位置的最大值，那就返回
  if(st[x][y]) return st[x][y];
  //到最后一个点的时候才开始累加
  int res = 1;
  for(int i = 0; i < 4; i++){
    int a = x + dx[i], b = y + dy[i];
    if(a <  0 || a >= n || b < 0 || b >= m || g[a][b] >= g[x][y]) continue;
    //累加距离
    res = max(res, dfs(a, b) + 1);
  }
  //存储这个位置的最大值
  st[x][y] = res;
  return res;
}

int main(){
  cin>>n>>m;
  for(int i = 0; i < n; i++)  
    for(int j = 0; j < m; j++)
      cin>>g[i][j];
  
  for(int i = 0; i < n; i++)
    for(int j = 0; j < m; j++)
      ans = max(ans, dfs(i, j));
  cout<<ans;
  return 0;
}

11.附近最小

在这里插入图片描述

//ST表
#include<iostream>
#include<cmath>
using namespace std;
const int N = 1e6 + 10;
int n, k, a[N];
int f[N][50];

//预处理 
void pre(){
	for(int i = 1; i <= n; i++) f[i][0] = a[i];
	//以2为底，n的对数 
	int t = log(n) / log(2);
	for(int j = 1; j <= t; j++)
		for(int i = 1; i <= n - (1 << j) + 1; i++)
			f[i][j] = min(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}

int query(int l, int r){
	int k = log(r - l + 1) / log(2);
	return min(f[l][k], f[r - (1 << k) + 1][k]);
}

int main(){
  scanf("%d", &n);
	for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
	scanf("%d", &k);
	pre();
	for(int i = 1; i <= n; i++){
		int l = max(1, i - k), r = min(n, i + k);
		printf("%d ", query(l, r));
	}
	return 0;
}

//单调队列
#include<iostream>
#include<cmath>
using namespace std;
const int N = 1e6 + 10;
int q[N], hh, tt = -1; //队列存储数组下标
int n, k, a[N];


int main(){
  scanf("%d", &n);
	for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
	scanf("%d", &k);
  //扩展窗口到右边界
  int x = 1;
	for(int i = 1; i <= n; i++){
    //左边界，右边界
		int l = max(1, i - k), r = min(n, i + k);
    //处理队头下标
		if(hh <= tt && q[hh] < l) hh++;
    //处理队尾元素
    while(x <= r){
      while(hh <= tt && a[q[tt]] >= a[x]) tt--;
      q[++tt] = x;
      x++;
    }
    printf("%d ", a[q[hh]]);
	}
	return 0;
}

12.判断蓝桥

在这里插入图片描述

#include <iostream>
using namespace std;
int main()
{
  string s, t = "lanqiao";
  getline(cin, s);
  int n = s.size();
  for(int i = 0; i < n; i++){
    s[i] = tolower(s[i]);
  }
  if(s == t) printf("yes");
  else printf("no");
  return 0;
}

13.幸运数

在这里插入图片描述

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

//这个数组的前一个框表示数的有多少位，后一个是表示这些数位上的数的和，数组存的值表示像这样的数在1~9999有多少个
//至于有什么用请看下面注释（4*9-->因为一个数分两半最多也就每边各4位数，其中最大也就9-->9999 9999）
int a[5][4*9];

//制作 a[5][4*9] 表，数位拆分统计
void get(int x){
  int sum=0,num=0;
  while(x){
    sum+=x%10;
    num++;
    x/=10;
  }
  a[num][sum]++;
}
int main(){

  //因为一个数是对称的，左边可以由这些数组成，右边也是一样，所以我们只需要算4位即可
  for(int i=1;i<=9999;i++){
     get(i);    
  }
  
  //利用乘法原理来统计数量
  int ans=0;
  for(int i=1;i<=4;i++)  //通过控制变量法，首先确定前半边的位数
  {
    for(int k=1;k<=i*9;k++)  //再控制他们的和-->一个两位数最多是多少（99->2*9->18）
    { 
        for(int j=1;j<=i;j++)  //最后后半边，进行变化
         {
          ans+=a[i][k]*a[j][k];
       }
    }
  }
  cout<<ans;
  return 0;
}

14.日期统计

在这里插入图片描述

#include <stdio.h>

int main() {
    int array[100] = {
        5, 6, 8, 6, 9, 1, 6, 1, 2, 4, 9, 1, 9, 8, 2, 3, 6, 4, 7, 7,
        5, 9, 5, 0, 3, 8, 7, 5, 8, 1, 5, 8, 6, 1, 8, 3, 0, 3, 7, 9,
        2, 7, 0, 5, 8, 8, 5, 7, 0, 9, 9, 1, 9, 4, 4, 6, 8, 6, 3, 3,
        8, 5, 1, 6, 3, 4, 6, 7, 0, 7, 8, 2, 7, 6, 8, 9, 5, 6, 5, 6,
        1, 4, 0, 1, 0, 0, 9, 4, 8, 0, 9, 1, 2, 8, 5, 0, 2, 5, 3, 3
    };

    int daysInMonth[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    int ans = 0;

    for (int month = 1; month <= 12; ++month) {
        for (int day = 1; day <= daysInMonth[month]; ++day) {
            int dateSeq[8] = {2, 0, 2, 3, month / 10, month % 10, day / 10, day % 10};
            int k = 0;

            for (int i = 0; i < 100; ++i) {
                if (array[i] == dateSeq[k]) {
                    ++k;
                    if (k == 8) {
                        ans++;
                        break;
                    }
                }
            }
        }
    }

    printf("%d\n", ans);
    return 0;
}

15.求和

在这里插入图片描述

#include <iostream>
using namespace std;
int main()
{
  cout<<1ll * 20230409 * 20230408 / 2;
  return 0;
}

16.工作时长

在这里插入图片描述

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> v;
int a[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main()
{
  int year, month, day, h, m, s;
  while(scanf("%d-%d-%d %d:%d:%d", &year, &month, &day, &h, &m, &s) != EOF){
    long long sum = 0;
    for(int i = 1; i < month; i++)
      sum += a[i];
    sum *= 24 * 60 * 60;
    sum += day * 24 * 60 * 60;
    sum += h * 60 * 60;
    sum += m * 60;
    sum += s;
    v.push_back(sum);
  }
  long long ans = 0;
  sort(v.begin(), v.end());
  for(int i = 1; i < v.size(); i++){
    ans += v[i] - v[i - 1];
    i++;
  }
  cout<<ans;
  return 0;
}

17.2023

在这里插入图片描述

#include <iostream>
using namespace std;
int main()
{
  int x = 12345678, y = 98765432, ans = 0;
  for(int i = x; i <= y; i++){
    string s = to_string(i);
    //找第一次出现的位置 
    int a = s.find('2');
    if(a == -1) continue;
    //从a+1位置开始截取到结尾 
    s = s.substr(a + 1);
    a = s.find('0');
    if(a == -1) continue;
    s = s.substr(a + 1);
    a = s.find('2');
    if(a == -1) continue;
    s = s.substr(a + 1);
    a = s.find('3');
    if(a == -1) continue;
    ans++;
  }
  ans = y - x + 1 - ans;
  cout<<ans;
  return 0;
}

18.有奖问答

在这里插入图片描述

//dfs
#include <iostream>
using namespace std;
int ans = 0;

void dfs(int u, int sum){
  if(u > 30 || sum == 100) return;
  if(sum == 70) ans++;

  //错了 
  dfs(u + 1, 0);
  //对了 
  dfs(u + 1, sum + 10);
}

int main()
{
  //一开始可以选答或不答 
  dfs(0, 0);
  cout<<ans;
  return 0;
}

//dp
#include <iostream>
using namespace std;
int f[40][110]; //f[i][j]: 做了i题，获得了j分的方案数
int res;

int main()
{
  f[1][0] = f[1][10] = 1;
  for(int i = 2; i <= 30; i++){
    for(int j = 0; j <= 100; j += 10){
      //如果没有分了，说明之前错了一题或者没做
      if(!j)
        for(int k = 0; k <= 90; k += 10)
          f[i][j] += f[i - 1][k];
      else
        f[i][j] = f[i - 1][j - 10];
      //如果已经有70分，那就累加所有情况
      if(j == 70) res += f[i][j];
    }
  }
  cout<<res;
  return 0;
}

19.01串的熵

在这里插入图片描述

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

int main()
{
  int n = 23333333, ans;
  for(int i = 0; i <= n; i++){
    double a = i, b = n - i; 
    double sum = -1 * a / n * log2(a / n) * a - 1 * b / n * log2(b / n) * b;
    if(abs(sum - 11625907.5798) < 0.0001) ans = min(a, b);
  }
  cout<<ans;
  return 0;
}

20.幸运数字

在这里插入图片描述

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

int f(int x, int z){
  vector<int> v;
  int sum = 0, t = x;
  while(t){
    v.push_back(t % z);
    t /= z;
  }
  for(int i = 0; i < v.size(); i++) sum += v[i];
  if(x % sum == 0) return 1;
  else return 0;
}

int main()
{
  int res = 0, x = 0;
  while(res != 2023){
    x++;
    if(f(x, 2) && f(x, 10) && f(x, 8) && f(x, 16)) res++;
  }
  cout<<x;
  return 0;
}

21.阶乘求和

在这里插入图片描述
1到50阶乘列表

格式：⾃然数，值位数，值

1 ,1 ,1

2 ,1 ,2

3 ,1 ,6

4 ,2 ,24

5 ,3 ,120

6 ,3 ,720

7 ,4 ,5040

8 ,5 ,40320

9 ,6 ,362880

10 ,7 ,3628800

11 ,8 ,39916800

12 ,9 ,479001600

13 ,10 ,6227020800

14 ,11 ,87178291200

15 ,13 ,130********00

16 ,14 ,20922789888000

17 ,15 ,355687428096000

18 ,16 ,6402373705728000

19 ,18 ,121645*********000

20 ,19 ,2432902008176640000

21 ,20 ,51090942171709440000

22 ,22 ,1124000727777607680000

23 ,23 ,25852016738884976640000

24 ,24 ,620448401733239439360000

25 ,26 ,155********330985984000000

26 ,27 ,403291461126605635584000000

27 ,29 ,10888869450418352160768000000

28 ,30 ,304888344611713860501504000000

29 ,31 ,8841761993739701954543616000000

30 ,33 ,265252859812191058636308480000000

31 ,34 ,8222838654177922817725562880000000

32 ,36 ,263130836933693530167218012160000000

33 ,37 ,8683317618811886495518194401280000000

34 ,39 ,295232799039604140847618609643520000000

35 ,41 ,10333147966386144929666651337523200000000

36 ,42 ,371993326789901217467999448150835200000000

37 ,44 ,137********226345046315979581580902400000000

38 ,45 ,523022617466601111760007224100074291200000000

39 ,47 ,20397882081197443358640281739902897356800000000

40 ,48 ,815915283247897734345611269596115894272000000000

41 ,50 ,33452526613163807108170062053440751665152000000000

42 ,52 ,1405006117752879898543142606244511569936384000000000

43 ,53 ,60415263063373835637355132068513997507264512000000000

44 ,55 ,2658271574788448768043625811014615890319638528000000000

45 ,57 ,119622220865480194561963161495657715064383733760000000000

46 ,58 ,5502622159812088949850305428800254892961651752960000000000

47 ,60 ,258623241511168180642964355153611979969197632389120000000000

48 ,62 ,12413915592536072670862289047373375038521486354677760000000000

49 ,63 ,608281864034267560872252163321295376887552831379210240000000000

50 ,65 ,30414093201713378043612608166064768844377641568960512000000000000

//前面40!已经有9个零了，里面包含9个2 * 5，所以只用计算到40！
#include <iostream>
using namespace std;
const int mod = 1e9;

int main()
{
  long long sum = 0, res = 1;
  for(int i = 1; i <= 40; i++){
    res = res * i % mod;
    sum = (sum + res) % mod;
  }
  cout<<sum;
  return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【MySQL】—— 学习日期函数计算员工入职时间并进行倒排

【MySQL】—— 学习日期函数计算员工入职时间并进行倒排

&#x1f308;个人主页: Aileen_0v0 &#x1f525;热门专栏: 华为鸿蒙系统学习|计算机网络|数据结构与算法 ​&#x1f4ab;个人格言:“没有罗马,那就自己创造罗马~” #mermaid-svg-Rry9CmFGqnDVdoiQ {font-family:"trebuchet ms",verdana,arial,sans-serif;font-siz…
阅读更多...
vue之elementUi的el-select同时获取value和label的两种方法

vue之elementUi的el-select同时获取value和label的两种方法

一、通过ref的形式&#xff08;推荐&#xff09; <template><div class"root"><el-selectref"optionRef"v-model"value"placeholder"请选择"style"width: 250px"><el-optionv-for"item in optio…
阅读更多...
Java：集合以及集合进阶 --黑马笔记

Java：集合以及集合进阶 --黑马笔记

一、集合概述和分类 1.1 集合的分类 除了ArrayList集合&#xff0c;Java还提供了很多种其他的集合&#xff0c;如下图所示&#xff1a; 我想你的第一感觉是这些集合好多呀&#xff01;但是&#xff0c;我们学习时会对这些集合进行分类学习&#xff0c;如下图所示&#xff1a;…
阅读更多...
Spring AI - 使用向量数据库实现检索式AI对话

Spring AI - 使用向量数据库实现检索式AI对话

Spring AI - 使用向量数据库实现检索式AI对话 Spring AI 并不仅限于针对大语言模型对话API进行了统一封装&#xff0c;它还可以通过简单的方式实现LangChain的一些功能。本篇将带领读者实现一个简单的检索式AI对话接口。 一、需求背景 在一些场景下&#xff0c;我们想让AI根据…
阅读更多...
【python】网络爬虫与信息提取--requests库

【python】网络爬虫与信息提取--requests库

导学 当一个软件想获得数据&#xff0c;那么我们只有把网站当成api就可以 requests库:自动爬取HTML页面&#xff0c;自动网络请求提交 robots协议&#xff1a;网络爬虫排除标准&#xff08;网络爬虫的规则&#xff09; beautiful soup库&#xff1a;解析HTML页面 工具&…
阅读更多...
【安装记录】安装 netperf 和 perf

【安装记录】安装 netperf 和 perf

这是一篇发疯随笔X.X 我的环境是虚拟机debian12&#xff0c;出于种种原因&#xff0c;之前直接使用apt-get install netperf apt-get install perf指令直接安装&#xff0c;报错找不到包 然后上网搜了一堆教程&#xff0c;有说下载netperf源码编译的&#xff0c;那些教程里面有…
阅读更多...
SPSS双变量相关分析

SPSS双变量相关分析

双变量相关分析通过计算皮尔逊简单相关系数、斯皮尔曼等级相关系数、肯德尔等级相关系数及其显著性水平展开。其中皮尔逊简单相关系数是一种线性关联度量&#xff0c;适用于变量为定量连续变量且服从正态分布、相关关系为线性时的情形。如果变量不是正态分布的&#xff0c;或具…
阅读更多...
Windows安全中心显示页面不可用

Windows安全中心显示页面不可用

2024年2月过年当天重装电脑之后&#xff0c;第二天&#xff08;还是第三天&#xff09;安全中心开始提示如标题所示的问题。 问题环境 Windows 11 家庭中文版23H2安装日期2024/‎2/‎10 我解决之前没有截图&#xff0c;所以此处放一个别人的图做示例。 实际解决方式 搜索了…
阅读更多...
假期刷题打卡--Day29

假期刷题打卡--Day29

1、MT1224棋盘 求一个N*N棋盘中的方块总数。 格式 输入格式&#xff1a; 输入整型N 输出格式&#xff1a; 输出整型 样例 1 输入&#xff1a; 2输出&#xff1a; 5备注 考虑到取值范围&#xff0c;可用long整型定义变量 分析过程 这个题目的意思是&#xff0c;在这…
阅读更多...
失去中国市场的三星仍是全球第一，但中国手机无法失去海外市场

失去中国市场的三星仍是全球第一，但中国手机无法失去海外市场

随着2023年分析机构公布全球手机市场和中国手机市场的数据&#xff0c;业界终于看清中国市场早已没有以前那么重要&#xff0c;三星、苹果这些国际品牌对中国市场的依赖没有他们想象的那么严重&#xff0c;相反中国手机对海外市场比以往任何时候都要更依赖了。 三星在2023年被苹…
阅读更多...
【Linux】模块参数

【Linux】模块参数

&#x1f525;博客主页&#xff1a;PannLZ &#x1f38b;系列专栏&#xff1a;《Linux系统之路》 &#x1f94a;不要让自己再留有遗憾&#xff0c;加油吧&#xff01; 模块参数 像用户程序一样&#xff0c;内核模块也可以接受命令行参数。首先应该声明用于保存命令行参数值的变…
阅读更多...
Spring Native 解放 JVM

Spring Native 解放 JVM

一、Spring Native 是什么 Spring Native可以通过GraalVM将Spring应用程序编译成原生镜像&#xff0c;提供了一种新的方式来部署Spring应用。与Java虚拟机相比&#xff0c;原生镜像可以在许多场景下降低工作负载&#xff0c;包括微服务&#xff0c;函数式服务&#xff0c;非常…
阅读更多...
一、西瓜书——绪论

一、西瓜书——绪论

第一章 绪论 1.独立同分布 通常 假设 样本空间 中 全 体样 本 服 从 一 个 未 知 “ 分 布 ” ( d i s t r i b u t i o n ) D , 我们获得的每个样本都是独立地从这个分布上采样获得的&#xff0c; 即 “ 独 立同 分布 ” ( i n d e p e n d e n t a n d i d e n t ic a …
阅读更多...
配置VMware实现从服务器到虚拟机的一键启动脚本

配置VMware实现从服务器到虚拟机的一键启动脚本

正文共&#xff1a;1666 字 15 图&#xff0c;预估阅读时间&#xff1a;2 分钟 首先祝大家新年快乐&#xff01;略备薄礼&#xff0c;18000个红包封面来讨个开年好彩头&#xff01; 虽然之前将服务器放到了公网&#xff08;成本增加了100块&#xff0c;内网服务器上公网解决方案…
阅读更多...
二叉树和堆（优先队列）

二叉树和堆（优先队列）

前言&#xff1a; 本章会讲解二叉树及其一些相关练习题&#xff0c;和堆是什么。 二叉树&#xff1a; 二叉树的一些概念&#xff1a; 一棵二叉树是有限节点的集合&#xff0c;该集合可能为空。二叉树的特点是每一个节点最多有两个子树&#xff0c;即二叉树不存在度大于2的节点…
阅读更多...
红包封面的流量是真的大啊

红包封面的流量是真的大啊

你好&#xff0c;我是小生&#xff0c;一个程序员转型做自媒体副业中~ 昨天&#xff0c;是农历 2023 年最后一天&#xff0c;到下午饭后的时候&#xff0c;红包封面流量推上了高峰期&#xff0c;非常的狂暴&#xff0c;有要烟花封面的、有要金龙封面的、有要表白封面的等等。 小…
阅读更多...
在计算机/移动设备上恢复已删除视频的 10 个数据恢复工具

在计算机/移动设备上恢复已删除视频的 10 个数据恢复工具

视频在网上疯传&#xff0c;我们都观看或创建视频&#xff0c;并将我们最喜欢的视频保存在硬盘上。如果我们丢失了一些重要的视频&#xff0c;那将是非常令人心碎的。但是今天&#xff0c;恢复已删除的视频变得更加容易。删除的视频在被新数据覆盖之前并没有真正从您的存储驱动…
阅读更多...
单片机在物联网中的应用

单片机在物联网中的应用

单片机&#xff0c;这个小巧的电子设备&#xff0c;可能听起来有点技术性&#xff0c;但它实际上是物联网世界中的一个超级英雄。简单来说&#xff0c;单片机就像是各种智能设备的大脑&#xff0c;它能让设备“思考”和“行动”。由于其体积小、成本低、功耗低、易于编程等特点…
阅读更多...
Web前端-移动web开发_rem布局

Web前端-移动web开发_rem布局

文章目录 移动web开发之rem布局1.0 rem基础1.1 rem单位(重点)1.2 em单位(了解)1.3 媒体查询什么是媒体查询媒体查询语法规范 1.4 less 基础维护css弊端Less 介绍Less安装Less 使用之变量使用node编译less的指令Less 编译 vocode Less 插件Less 嵌套Less 运算Less中的Mixin混入L…
阅读更多...
使用 MinIO 超级充电 TileDB 引擎

使用 MinIO 超级充电 TileDB 引擎

MinIO 是一个强大的主要 TileDB 后端&#xff0c;因为两者都是为性能和规模而构建的。MinIO 是一个单一的 Go 二进制文件&#xff0c;可以在许多不同类型的云和本地环境中启动。它非常轻量级&#xff0c;但也具有复制和加密等功能&#xff0c;并且提供与各种应用程序的集成。Mi…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站