纯小白蓝桥杯备赛笔记--DAY5（竞赛常用库函数）

最新推荐文章于 2024-11-18 22:10:24 发布
最新推荐文章于 2024-11-18 22:10:24 发布
阅读量1.2k 收藏 8
点赞数 13
分类专栏： 蓝桥杯备赛 文章标签： 蓝桥杯 笔记 职场和发展 c++ 算法 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yhvaely/article/details/137168897
版权

文章目录

大小写转换

islower和isupper：检查一个字符是否是小写或者大写。

  • islower：检查小写。
  • isupper：检查大写。
  • 函数的返回值为bool类型。
  • 头文件：或者是<bits/stdc++.h>

Tolower和toupper函数：

  • tolower（char ch）将ch转换为小写字母，大写不转换。
  • toupper同理。

ASCII码：

  • 大写字母的范围：65~90
  • 小写字母的范围：97~122
    大写转小写：
    ch1=ch+32;//不推荐
    ch1=ch-‘A’+‘a’;//减去大写的那一列，从小写的那一列开始
    实现：小写转大写
#include<bits/stdc++.h>
using namespace std;
char coverch(char ch)
{
        if(islower(ch))ch=toupper(ch);
        else if(isupper(ch))ch=tolower(ch);
        return ch;
}
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        string s;
        getline(cin,s);
        for(auto &i:s)
        {
                i=coverch(i);
        }
        cout<<s<<"\n";        
}

二分查找

二分查找的前提：库函数只能对数组进行二分查找，且数组中的元素是单调的。

  • 一般为单调不减，当然如果是单调不增也可以（需要修改比较函数sort）

binary_search函数：

  • 用法：已排序的序列中查找特定元素。
  • 通过二分查找算法来确定列中是否存在目标元素。
  • 函数返回值是bool类型。
  • 获取找到元素的位置使用lower_bound函数或upper_bound函数。
#include<bits/stdc++.h>
int main()
{
        using namespace std;
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        vector<int>numbers={1,3,5,7,9};
        int target=5;
        bool found=binary_search(numbers.begin(),numbers.end(),target);
        if(found)
        cout<<target<<" "<<"is found"<<endl;
        else
        cout<<target<<"is not found"<<endl;
        return 0;
 }

lower_bound和upper_bound函数

  • lower_bound(start,end,target)返回地址[start,end)中第一个大于等于x的元素的地址。（注：下标=地址-首地址）
  • upper_bound(start,end,target)返回地址[start,end)中第一个大于 x的元素的地址。（注意是左闭右开的区间）
  • 如果不存在则返回最后一个元素的下一个位置，在vector中即end（）。
  • 实现
#include<bits/stdc++.h>
using namespace std;
int main()
{
        vector<int> s={5,1,7,3,10,18,9};
        sort(s.begin(),s.end());
        for(auto &i:s)
        cout<<i<<' ';
        cout<<"\n";
        //找到数组中第一个大于等于8的元素的地址
        cout<<(lower_bound(s.begin(),s.end(),8)-s.begin())<<"\n";
        return 0; 
}
  • 例题：蓝桥1389二分查找数组
#include<bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        int data[200];
        for(int i = 0 ; i < 200 ; i ++)
        data[i] = 4 * i + 6;
        int target;
        cin>>target;
        cout<<lower_bound(data,data+200,target)-data<<"\n";
        return 0;
}

注：不是容器（例如：vector和list）对象的不能用begin（）函数。修改如下：

#include<bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        vector<int>data(200);
        for(int i = 0 ; i < 200 ; i ++)
        data[i] = 4 * i + 6;
        int target;
        cin>>target;
        cout<<lower_bound(data.begin(),data.end(),target)-data.begin()<<"\n";
        return 0;
}

最值查找

Min和max函数：

  • 时间复杂度为O（1），传入参数为数组（用{}）的时候时间复杂度为O（n），n为数组大小。

min_element和max_element函数：

  • min_element(start,end)返回地址[start,end)中的最小的那个值的地址（迭代器），传入参数为两个地址或迭代器。
  • Max_element(start,end)返回地址[start,end)中的最大的那个值的地址（迭代器），传入参数为两个地址或迭代器。
  • 时间复杂度为O（n），n为数组大小
  • 返回值是具体的数字，而不是一个地址
#include<bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        vector<int>v={5,1,3,9,11};
        cout<<*min_element(v.begin(),v.end())<<"\n";
        return 0;
}

注：这段代码中的星号（*）表示解引用，即通过地址（迭代器）得到值。

  • nth_element()函数
    • 格式：nth_element(start,k,end)
    • 用途，找出第k大个元素，则该元素的位置属于正确位置，其他元素的位置虽然是任意的，但是前面的都比它小，后面的都比它大。
    • 返回值为void()
    • 时间复杂度为O（n）
#include<bits/stdc++.h>
using namespace std;
int main()
{
        vector<int>v={5,1,7,3,10,18,9};
        nth_element(v.begin(),v.begin()+3,v.end());//返回值为空，说明这条语句不能输出
        for(auto &i:v)
        cout<<i<<"\n";
        return 0; 
}
  • 例题：497求最高分，最低分和平均分。（两种方法）
#include<bits/stdc++.h>
using namespace std;
using ll=long long;//数组记得开long long
const int N=10001;
int a[N];
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        int n;cin>>n;
        ll sum=0;
        for(int i=1;i<=n;i++)
        {
        cin>>a[i];
                sum+=a[i];        
                }
        cout<<*max_element(a+1,a+n+1)<<"\n";//定义的是数组时使用数组名，定义的是容器时使用begin函数 
                cout<<*min_element(a+1,a+n+1)<<"\n";
                cout<<fixed<<setprecision(2)<<1.0*sum/n<<"\n";
                return 0;          
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        int n;
        int s[10001];
        int maxa=0;int mina=100;double sum=0;
        double c=0;
        cin>>n;
        for(int i=0;i<n;i++)
        {
                cin>>s[i];
                maxa=max(maxa,s[i]);
                mina=min(mina,s[i]);
                sum+=s[i];
         } 
         c=sum/double(n);
         cout<<maxa<<endl;
         cout<<mina<<endl;
         printf("%.2lf",c);
         return 0;
}

注：c++如何保留小数：

#include <iostream>
#include <iomanip>

int main() {
    double num = 3.14159;
    std::cout << std::fixed << std::setprecision(2) << num << std::endl;
    return 0;
}

使用std::fixed和std::setprecision(2)设置输出保留两位小数。

排序

sort简介：

  • sort函数包含在头文件中。
  • 在使用前需要#include或者使用万能头文件。
  • 用途：指定范围内的元素进行排序。
  • sort算法使用的是快速排序（QuickSort）或者类似快速排序的改进算法，时间复杂度为O（nlogn）。
  • 用法：sort(起始地址，结束地址的下一位，*比较函数)
 #include<bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        int a[100];
        int n;
        cin>>n;
        for(int i=1;i<=n;i++)
        cin>>a[i];
        //对数组进行排序
        sort(a+1,a+n+1);
        //输出
        for(int i=1;i<=n;i++)cout<<a[i]<<' ';
        return 0; 
 } 

#include<bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        vector<int>a={5,1,3,9,11};
        //对数组进行排序
        sort(a.begin(),a.end());
        //输出
        for(auto i:a)cout<<i<<' ';
        return 0; 
 }

自定义比较函数：

  • 在sort函数末尾传入第三个表达式，这个表达式可以是函数也可以是lambda表达式。
    • 函数：
#include<bits/stdc++.h>
using namespace std;
bool cmp(const int &u,const int &v)
{
        return u>v;
}
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        vector<int>a={5,1,3,9,11};
        //对数组进行排序
        sort(a.begin(),a.end(),cmp);
        //输出
        for(int i=0;i<a.size();i++)cout<<a[i]<<' ';
        return 0; 
 }

lambda表达式：（匿名函数，一般用在只在程序中用一下，其他地方用不到的情况）

#include<bits/stdc++.h>
using namespace std;
int main()
{
        ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
        vector<int>a={5,1,3,9,11};
        //对数组进行排序
        sort(a.begin(),a.end(),[](const int &u,const int &v)//方括号内也可以放&表示引用 
        {
                return u>v;
        });
        //输出
        for(int i=0;i<a.size();i++)cout<<a[i]<<' ';
        return 0; 
 }
  • 也可以用在结构体中，其中函数的参数只有一个。
 struct Node
 {
         int u,v;
         bool operator < (const Node &m)const//这里可以把perator < 整体看做一个函数名 
         {
                 return u==m.u?v<m.v:u<m.u;//以u为第一关键字，v为第二关键字 
         }
  }
  • 例题：1265:对一个数组分别实现由小到大和由大到小输出
#include<bits/stdc++.h>
using namespace std;
const int N=5e5+3;
int a[N];
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  int n;
  cin>>n;
  for(int i=1;i<=n;++i)cin>>a[i];
  sort(a+1,a+n+1);
  for(int i=1;i<=n;++i)cout<<a[i]<<" \n"[i==n];//到第n个的时候输出一个换行
  for(int i=n;i>=1;--i)cout<<a[i]<<" \n"[i==1];//当i等于1的时候跟上一个回车
  return 0;
}

注：12,13行后面的字符判断"\n"之前有一个空格一定要记得打上。

#include<bits/stdc++.h>
using namespace std;
const int N=5e5+3;
int a[N];
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  int n;
  cin>>n;
  for(int i=1;i<=n;++i)cin>>a[i];
  sort(a+1,a+n+1);
  for(int i=1;i<=n;++i)cout<<a[i]<<" \n"[i==n];//到第n个的时候输出一个换行
  //当i等于1的时候跟上一个回车
  sort(a+1,a+n+1,[](const int &u,const int &v)
  {
          return u>v;
  });
  for(int i=1;i<=n;++i)cout<<a[i]<<" \n"[i==n];
  return 0;
}
  • 第二种方法
#include<bits/stdc++.h>
using namespace std;
const int N=5e5+3;
int a[N];
bool cmp(const int &u,const int &v)
{
        return u>v;
}
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  int n;
  cin>>n;
  for(int i=1;i<=n;++i)cin>>a[i];
  sort(a+1,a+n+1);
  for(int i=1;i<=n;++i)cout<<a[i]<<" \n"[i==n];//到第n个的时候输出一个换行
  //当i等于1的时候跟上一个回车
  sort(a+1,a+n+1,cmp);
  for(int i=1;i<=n;++i)cout<<a[i]<<" \n"[i==n];
  return 0;
}

全排列

next_permutation函数

  • 该函数用于生成当前序列的下一个排列。它按照字典序对序列进行重新排序，如果存在下一个序列，则将当前序列更改为下一个排列，并返回true，如果当前序列已经是最后一个排列，则将序列更改为第一个排列，并返回false。
  • 如果想要输出全部的排列就要求定义的数组是最小的。
#include<bits/stdc++.h>
using namespace std;
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  vector<int>nums={1,2,3}; 
  cout<<"初始的数组：";
  for(int num:nums)
  {
          cout<<num<<" ";
  }
  cout<<endl;
  //生成下一个排列
  while(next_permutation(nums.begin(),nums.end())) 
  {
          cout<<"下一个排列是：";
          for(int num:nums)
          {
                  cout<<num<<" ";
           } 
           cout<<endl;
  }
  return 0;
}

prev_permutation()函数：

  • 生成当前序列的上一个排列。同样，要想生成全排列要求第一个是最大的数组。
#include<bits/stdc++.h>
using namespace std;
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  vector<int>nums={3,2,1}; 
  cout<<"初始的数组：";
  for(int num:nums)
  {
          cout<<num<<" ";
  }
  cout<<endl;
  //生成下一个排列
  while(prev_permutation(nums.begin(),nums.end())) 
  {
          cout<<"下一个排列是：";
          for(int num:nums)
          {
                  cout<<num<<" ";
           } 
           cout<<endl;
  }
  return 0;
}

补充：全排列一般使用搜索（dfs）
应用：

#include<bits/stdc++.h>
using namespace std;
int a[10];
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  for(int i=1;i<=4;++i)
  a[i]=i;
  bool tag=true;
  while(tag)
  {
          for(int i=1;i<=4;++i)cout<<a[i]<<' ';
          cout<<'\n';
          tag=next_permutation(a+1,a+1+4);
  }
  return 0;
}

注：next_permutation 函数用于生成给定范围内的下一个排列。如果成功生成了下一个排列，则返回 true，并将数组 a 更新为新的排列；否则，如果没有更多的排列可用，则返回 false。由此tag实现对循环的控制。

其他库函数

memset（）函数：

  • 用途：设置内存块值。
  • 原型定义在头文件中。
  • 函数声明：void* memset(void* ptr,int value,size_t num);分别是：指针、值、重置的大小。
  • 详解：
    • ptr:指向要设置值的内存块的地址（数组一般是数组名）
    • value：要设置的值，通常是一个整数。
    • num:要设置的字节数。
    • 就是说，将ptr指向的内存块的前num个字节设置为value的值。它返回一个指向ptr的指针。
    • memset（）通常用于初始化内存块，将其设置为特定的值。
  • 注：memset（）函数对于非字符类型的数组可能会产生未定义行为（每一个字节赋值为1）
#include<bits/stdc++.h>
using namespace std;
int a[10];
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  int a[5];
  memset(a,1,sizeof(a));//设置成0和-1没有影响
  //-1的补码是全1的。
  for(int i=0;i<5;++i)cout<<bitset<32>(a[i])<<'\n';//产看a[i]的二进制 
  return 0;
}

swap()函数：

  • 用法：swap(T &a,T &b);函数接受两个参数进行交换。

reverse（）函数：

  • 用于反转容器中元素顺序的函数。
  • 原型定义在头文件中，函数的声明如下：
  • reverse（first，last）函数接受两个参数：将[first,last)范围内的元素顺序进行反转。
  • reverse可翻转各种类型的容器，如数组、向量、链表等。
#include<bits/stdc++.h>
using namespace std;
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  vector<int>vec={1,2,3,4,5};
  reverse(vec.begin(),vec.end()) ;
  for(int num:vec)
  cout<<num<<" ";
  cout<<endl;
  return 0;
}

unique（）函数

  • unique（first，last）将[first,last)范围内的相邻重复元素去除，并返回一个指向去重后范围的尾后迭代器。去重后的范围中只保留第一个出现的元素，后续重复的元素都被移除。
  • 时间复杂度为O（n），但是使用之前一般要排序，此时时间复杂度为sort(nlogn)。
#include<bits/stdc++.h>
using namespace std;
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  vector<int>vec={1,1,2,2,3,3,4,4,5,5};
  auto it=unique(vec.begin(),vec.end());//unique 函数会将相邻的重复元素移动到向量的末尾，并返回一个指向去重后最后一个元素的下一个位置的迭代器。
  vec.erase(it,vec.end());//vec.erase(it,vec.end()); 这行代码的作用是删除从迭代器 it 开始到向量 vec 末尾的所有元素。
  for(int num:vec)
  {
          cout<<num<<" ";
  }
  cout<<endl;
  return 0;
}

//定义数组的形式：

#include<bits/stdc++.h>
using namespace std;
int main()
{
  ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
  int vec[]={1,1,2,2,3,3,4,4,5,5};
  int n=unique(vec,vec+10)-vec;//减去a最后得到的是下标
  for(int i=0;i<n;i++)
  cout<<vec[i]<<' '; 
  return 0;
}

未完待续，大家一起加油啊！！！

晏南午
关注
专栏目录
蓝桥杯嵌入式F103库函数-模板.7z
08-02
【标题】"蓝桥杯嵌入式F103库函数-模板.7z" 提供的资源主要针对的是在蓝桥杯竞赛中使用的STM32F103系列微控制器的库函数模板，用于LCD显示相关的编程。蓝桥杯是一项针对IT和电子工程学生的专业竞赛，旨在提升参赛者...
蓝桥杯大赛13-17年省赛真题，C/C++和Java，本科A、B组和高职高专组
08-08
1. 全面复习：首先，考生应系统复习C/C++和Java的基本语法和常用库函数，确保理论基础扎实。 2. 题型专项训练：针对不同题型进行针对性训练，如排序算法、搜索算法、图论问题等。 3. 模拟实战：利用历年真题进行模拟...
蓝桥杯Java算法常用类方法
weixin_47174945的博客
04-16 676
#常用函数 int length() 返回字符串的长度 int compareTo(String anotherString) 比较两个字符串的大小 //注：相比较的String位数相等则返回askII码差值。相比较的String位数不等则返回位数差值 int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引 int indexOf(String str, int fromIndex) 返回从指定的索引开始，指定子字符串在此字符串中第一次出现处的索引 int .
蓝桥杯Java组常用算法与技巧
qq_50665031的博客
05-02 6110
蓝桥杯Java组常用算法与技巧 基本准备与注意 考试时长：4小时 证件准备：身份证和准考证 设置Eclipse的字体大小Windows-preferences–搜索font–双击Colors and Fonts 的Basic的text font-输入15号字体 为Eclipse绑定源码：随便进入一个系统类–attach source–关联外部文件（一般为C:\Program Files\Java\jdk1.8.0_261\src.zip） Excel的使用：主要就是使用里面的函数：1.先
蓝桥杯---STL常用库函数(算法笔记4）
Edwinwzy的博客
01-15 1278
下面是STL中几大常用的库函数 sort 两种定义方式 区间左闭右开，从第一个数到倒数第二个数。 下面是排列组合函数，在这之前先分清楚什么叫字典序 也就是从以a,b,c~z这样的顺序进行排序。 那么接下来就是对于处理排序问题的库函数 next_permutation 同样的，排列区间也是左闭右开。 下面例子是对于序列a,b,c求除去abc以外的全排列，用next_permutation库函数实现就简单很多。 那么知道了next_permutati...
【蓝桥杯备赛Java组】语言基础|竞赛常用库函数|输入输出|String的使用|常见的数学方法|大小写转换
qq_73017178的博客
01-18 2530
本篇文章主要讲解了【蓝桥杯备赛Java组】语言基础：蓝桥杯Java 语言开发环境，java方法（gcd，lcm，判断素数)；输入Sannner以及三种输出；String的使用：StringBuilder类和String类的区别和使用；竞赛常用库函数：常见的数学Math方法，大小写转换的两种方法
Java在算法竞赛中的技巧（蓝桥杯备赛总结）
weixin_52161359的博客
05-29 8392
前言：笔者在这段时间准备蓝桥杯竞赛，由于个人原因选择Java作为语言，刷题中也是不断感到Java有些语法还是不够方便（非常羡慕隔壁C++的STL…），不过有些常见的技巧/方法/模板，也是自己做了些总结，十分之不全面，比完赛会继续完善… ！！！！！提交结果时记得检查有无不该加的头文件，主类名是否为Main！！！！！！ 2.优化输入输出时间（快速IO模板）： import java.io.*; import java.math.BigDecimal; import java.math.BigInteger
蓝桥杯学习资料大全-题目参考代码-带分数.zip
05-25
蓝桥杯是一项全国性的编程竞赛，旨在提升大学生的计算机科学技能，特别是算法设计和编程能力。这个压缩包中包含了历年来蓝桥杯比赛的部分题目及其对应的参考代码，帮助参赛者理解和解决竞赛中遇到的问题。 首先，...
纯小白蓝桥杯备赛笔记--DAY7（竞赛必备基础算法）
Yhvaely的博客
03-26 1201
每条边的权值为边所连接的两个节点的编号和，使得的最长边和最短边之间的差值小于等于3。在解决构造题时，以下几点思考是很重要的：观察问题规模的增长：了解问题随着规模的增大，答案的变化趋势。等差数列的最小间隔（实际上不是公差），例如{2,5,7}，最小的间隔是2，但公差不是2，是1。按位左移（
STM32F4开发指南-库函数版本_V1_STM32F4开发指南_STM32F4开发手册_stmf4库函数_stm32f4库函数
09-10
"STM32F4开发指南-库函数版本_V1" 提供了详细的库函数使用说明，这是STM32F4开发中的关键资源。库函数是预编写好的代码模块，它们封装了底层硬件操作，使得开发者可以更高效、更便捷地控制STM32F4的各个功能。库函数...
纯小白蓝桥杯备赛笔记--DAY9（搜索）
Yhvaely的博客
04-01 901
其实就是将搜索过程当中一些不必要的部分直接别除掉，因为搜索过程构成了一棵树，别除不必要的部分，就像是在树上将树枝剪掉，故名剪枝。剪枝是回溯法的一种重要优化手段，方法往往先写一个暴力搜索，然后找到某些特殊的数学关系，或者逻辑关系，通过它们的约束让搜索树尽可能浅而小，从而达到降低时间复杂度的目的。一般来说，剪枝的复杂度难以计算。进入例题提示：如果理解不了的同学建议先看第二部分DFS回溯。
STM32F1开发指南-库函数版本_V3.1 .pdf
10-01
STM32F1开发指南-库函数版本_V3.1 STM32F1开发指南-库函数版本
蓝桥杯——杨辉三角
bengbeng2345的博客
11-14 1549
i内层，j外层核心：每个位置的值为(i-1,j)位置的值加(i-1,j-1)位置的值。
蓝桥杯每日真题 - 第13天
weixin_74066588的博客
11-14 973
该算法适用于解决无向图中的割边问题，并且能高效计算分割后的连通分量权值差。Tarjan算法在一次深度优先搜索中找出割边，提高了效率，是处理连通分量问题的有效工具。代码逻辑较为复杂，尤其是在low和dfn数组的更新上，需要对图的割边和强连通分量有较好理解。
蓝桥杯——数组
bengbeng2345的博客
11-14 1467
eclipse常用快捷键。alt+/ ：常用方法。ctrl+1：补全代码。
(蓝桥杯C/C++)——动态规划(DP)
2402_82385099的博客
11-09 1974
DP(动态规划)全称DynamicProgramming，是运筹学的一个分支，是一种将复杂问题分解成很多重叠的子问题，并通过子问题的解得到整个问题的解的算法。在动态规划中有一些概念:状态:就是形如dp[il[il=val的取值，其中i，i为下标，也是用于描述、确定状态所需的变量,val为状态值。状态与状态之间的转移关系，一般可以表示为一个数学表达式，转移方向决迭代或递归方向。也就是题目所求的状态，最后的答案。
蓝桥杯某例题的解决方案和拓展（完全能解决例题本身）
最新发布
St_Ludwig的博客
11-18 295
蓝桥杯某个题的解法，并且拓展了一下，以应对更广泛的情况。
蓝桥杯-洛谷刷题-day3（C++）
sjj_1234567的博客
11-15 1834
int n;cin >> n;int a[n];上文代码会报错，这种常规数组定义在编译阶段就完成了创建（上文数组大小需要在运行阶段才能确定，这是矛盾的）， [] 内只能是常数。要实现上文这种，在运行后确立数组大小的形式，就是建立动态数组。· 法一----使用vectorint n;cin >> n;· 法二----new关键字（不如法一安全）delete[] a;
蓝桥杯第22场小白入门赛
2302_79372568的博客
11-18 389
刚好牛客周赛和蓝桥杯周赛时间撞了，于是毅然决然选择了打牛客，结局是本蒟蒻被牛客薄纱/(ㄒoㄒ)/~~好吧，然后第二天就来水一水蓝桥杯了（bushi)，小白入门赛和前几次一样，6道题只能写5道（什么时候能让我AK，AK了我就不是小白了）相信大家闭着眼睛也能写出来 /(ㄒoㄒ)/~~
蓝桥杯介绍
Runner__Binger的博客
11-15 1681
蓝桥杯设有多个奖项，包括一等奖、二等奖、三等奖及优秀奖等，各奖项的获奖比例根据组别和赛项有所不同。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值