- 卉图编程暑假集训班-7.7-方老师の热辣♂比拼 第一回
卉图编程暑假集训班-7.7-方老师の热辣♂比拼 I ——赛后讨论
-
CCCCrack_
@
2023-7-7 17:48:43
此为7.7下午测试赛的赛后讨论，同学们可以在这里交流代码和解题思路，有能力的同学也可以写写题解。 另外，少整活。
——Mr.Fang
6 条评论
-
zoudonghan @ 2023-7-10 17:18:48
1
11 型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout< ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s## 标准数据类型： ——————————————————————————————- | 数据类型 | 自定义识符 | 占字节 | 数值范围 | ————————————————————————------------- |短整型 | short[int] | 2(16位) | -32768~32767 | |整型 | [long]int | 4(32位) | -2147483648~2147483647| |单精度实型 | float | 4(32位) | -3.4E+38~3.4E+38 |
计算ASCII码值； //在ASCII编码中，A=65 #include #include using namespace std; int main() { int b="A"; b*=2; printf("%d",b); return 0; } 结果：130
计算球的体积： #include #include using namespace std; double r; int main(){ scanf("%lf",&r); printf("%2lf",4/33.14rrr); return 0;
等差数列末项计算： #include using namespace std; int main(){ int a1,a2,n; cin>>a1>>a2>>n; cout<<(a2-a1)*(n-1)+a1<<endl; return 0;
}
判断偶数： #include using namespace std; int main() { int a; cin>>a; if (a%2==0) cout<<"偶数"<
判断奇数： #include using namespace std; int main() { int a; cin>>a; if (a%2==1) cout<<"奇数"< 判断大于1，小于100的数 #include using namespace std; int main() { int a; cin>>a; if (a<1 && a>100) cout<<"yes"< __------------------------------------------------------- 输入3个数，大到小排序： #include using namespace std; int main() { int a,b,c,temp; cin>>a>>b>>c>>temp; if(a if(a if(b cout<
判断数正负： #include using namespace std; int main(){ long n; scanf("%ld",&n); if (n>0)printf("psoitive"); else if (n=0)printf("zero"); else printf("negative"); return 0; }
swiach语句： #include using namespace std; main int (){ char a; cin>>a; switch(表达式){ case 常量表达式： //case后不需要{} //case没有顺序 a++; break;//跳出，否则会往下继续执行剩下的case case "b": b++; break; case 3; //代码块 default://所有case都不满足，会执行default//case后的值不能相同，否则会报错 } }
1.case语句后的各常量表达式的值不能相同
1.语句的选择： 基本if选择：处理单一或组合条件的情况 if-else选择：处理简单的条件分支情况 多重if选择：处理复杂的条件分支情况 嵌套if选择：用于单一或组合条件的情况 表达式的结果是boolean布尔类型（常用于区间判断）
2.switch语句的选择： 多重分支并且条件判断的情况，表达式的类型不能是boolean类型！可能是byte,int,char,string举例（常用于等值判断）
能用switch语句实现的就一定可以使用if来实现，但是反之不一定，如果是区间范围就采用if，如果是等值判断请使用switch ———————————————————————————————————————————— 格式化输入输出： #include #include //c语言 std标准 io输入输出 using namespace std; int main(){ int n,m; //格式化输入输出 //格式化输入 scanf("%d-%d",&n,&m); //""里的内容是需要输入的内容，包括格式 //%d 占地符 //& 取地址符 //scanf使用时一定要用取地址+变量名
// 格式化输出 printf("我今年%d岁，身高是%d厘米",n,m); //""里原封不动输出 //printf后的变量名前面没有取地址符 //占位符 //%d int //%f float //%lf double //%c char //%s string //占位符在输入时的应用 //%2d 在读取时，只读取两个字符宽度 //占位符在输出时的应用 //%.2f 输出时，保留2位小数 //%4d 输出时，输出4个字符宽度（右对齐） //%-4d 输出时，左对齐 //%4.3f 输出时，保留3位小数，并且，占四个字符宽度 //转义字符（一般用在printf中） printf("我今年的年龄是%d\n",a); // 斜杠（/） // 反斜杠（\） // 转义字符（\+字符）一般用在格式化输出 // (\')输出文本意义的’ // (\")输出文本意义的" // (\\)输出文本意义的\ // (\n)换行 // (\t)制表符 // (\b)退格（backsapce） // (\r)回车 // (\0)空字符}
//勾股定理：任意直角三角形两条直角边的平方和等于斜边的平方———————————————————————————————————————— 海伦公式： （在不知道三角形高的情况下，只需知道三角形的三条边即可算出三角形面积）
①p=(a+b+c)/2
②s=根号[p*(p-a)*(p-b)*(p-c)] ———————————————————————— 开根号： （必须使用cmath数学库） sqrt(需要开跟数、变量……) ———————————————————————————— for语句： for(控制变量初始化表达式（条件循环开始时）；条件表达式（循环能够进行的条件）；增量表达式（每一次循环结束后执行的事）) { 语句1； 语句2； …… }
万能模块： #include<bits/stdc++.h>
while语句：
格式1： while(条件表达式) 语句1； 说明：语句1是while循环语句的循环体，它将在满足条件的情况下被重复执行
格式2： while(条件表达式){ 语句1； 语句2； …… } 说明：循环体部分由多个语句构成，应由一对花括号（{}）括起来，构成一个语句块的形式。 —————————————————————————— (n!)阶乘： 例： #include using namespace std; int main(){ int n; cin>>n; int sum=1; for(int a=1;a<=n;a++){ sum=sum*a; } cout<<sum<<endl; return 0; } ——————————————————————— 勾股定理：
口诀：勾三股四弦五
常用勾股数： 3 4 5 5 12 13 ——----—————————————————————————— 快速排序： #include #include//常用库函数头文件 //sort() 快速排序 using namespace std; bool cmp(int a,int b) { return a > b; } int main() { int a[10]={1,7,2,5,9,10,66,6}; //sort(需要排序的数组名+开始的位置，数值名+结束的位置，排序的顺序)； sort(a + 0;i<=7;i++) { cout< }
数组：
类型标识符 数组名[常量表达式] 说明： ①数组名的命名规则与变量名的命名规则一致。 ②常量表达式表示数组元素的个数，可以是常量和符号常量但不能是变量。
数组名[下标] 例： a[5] a[i+j] a[i++] 说明： ①下标可以是任意值为整型的表达式，该表达式里可以包含变量和函数调用。 ②数组的精妙在于下标可以是变量，通过对下标变量值的灵活控制，达到灵活处理数组元素的目的。 ③C++语言只能逐个引用数组元素，而不能一次引用整个数组。 ④数组元素可以向同类型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout< ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s## 标准数据类型： ——————————————————————————————- | 数据类型 | 自定义识符 | 占字节 | 数值范围 | ————————————————————————------------- |短整型 | short[int] | 2(16位) | -32768~32767 | |整型 | [long]int | 4(32位) | -2147483648~2147483647| |单精度实型 | float | 4(32位) | -3.4E+38~3.4E+38 |
计算ASCII码值； //在ASCII编码中，A=65 #include #include using namespace std; int main() { int b="A"; b*=2; printf("%d",b); return 0; } 结果：130
计算球的体积： #include #include using namespace std; double r; int main(){ scanf("%lf",&r); printf("%2lf",4/33.14rrr); return 0;
等差数列末项计算： #include using namespace std; int main(){ int a1,a2,n; cin>>a1>>a2>>n; cout<<(a2-a1)*(n-1)+a1<<endl; return 0;
}
判断偶数： #include using namespace std; int main() { int a; cin>>a; if (a%2==0) cout<<"偶数"<
判断奇数： #include using namespace std; int main() { int a; cin>>a; if (a%2==1) cout<<"奇数"< 判断大于1，小于100的数 #include using namespace std; int main() { int a; cin>>a; if (a<1 && a>100) cout<<"yes"< __------------------------------------------------------- 输入3个数，大到小排序： #include using namespace std; int main() { int a,b,c,temp; cin>>a>>b>>c>>temp; if(a if(a if(b cout<
判断数正负： #include using namespace std; int main(){ long n; scanf("%ld",&n); if (n>0)printf("psoitive"); else if (n=0)printf("zero"); else printf("negative"); return 0; }
swiach语句： #include using namespace std; main int (){ char a; cin>>a; switch(表达式){ case 常量表达式： //case后不需要{} //case没有顺序 a++; break;//跳出，否则会往下继续执行剩下的case case "b": b++; break; case 3; //代码块 default://所有case都不满足，会执行default//case后的值不能相同，否则会报错 } }
1.case语句后的各常量表达式的值不能相同
1.语句的选择： 基本if选择：处理单一或组合条件的情况 if-else选择：处理简单的条件分支情况 多重if选择：处理复杂的条件分支情况 嵌套if选择：用于单一或组合条件的情况 表达式的结果是boolean布尔类型（常用于区间判断）
2.switch语句的选择： 多重分支并且条件判断的情况，表达式的类型不能是boolean类型！可能是byte,int,char,string举例（常用于等值判断）
能用switch语句实现的就一定可以使用if来实现，但是反之不一定，如果是区间范围就采用if，如果是等值判断请使用switch ———————————————————————————————————————————— 格式化输入输出： #include #include //c语言 std标准 io输入输出 using namespace std; int main(){ int n,m; //格式化输入输出 //格式化输入 scanf("%d-%d",&n,&m); //""里的内容是需要输入的内容，包括格式 //%d 占地符 //& 取地址符 //scanf使用时一定要用取地址+变量名
// 格式化输出 printf("我今年%d岁，身高是%d厘米",n,m); //""里原封不动输出 //printf后的变量名前面没有取地址符 //占位符 //%d int //%f float //%lf double //%c char //%s string //占位符在输入时的应用 //%2d 在读取时，只读取两个字符宽度 //占位符在输出时的应用 //%.2f 输出时，保留2位小数 //%4d 输出时，输出4个字符宽度（右对齐） //%-4d 输出时，左对齐 //%4.3f 输出时，保留3位小数，并且，占四个字符宽度 //转义字符（一般用在printf中） printf("我今年的年龄是%d\n",a); // 斜杠（/） // 反斜杠（\） // 转义字符（\+字符）一般用在格式化输出 // (\')输出文本意义的’ // (\")输出文本意义的" // (\\)输出文本意义的\ // (\n)换行 // (\t)制表符 // (\b)退格（backsapce） // (\r)回车 // (\0)空字符}
//勾股定理：任意直角三角形两条直角边的平方和等于斜边的平方———————————————————————————————————————— 海伦公式： （在不知道三角形高的情况下，只需知道三角形的三条边即可算出三角形面积）
①p=(a+b+c)/2
②s=根号[p*(p-a)*(p-b)*(p-c)] ———————————————————————— 开根号： （必须使用cmath数学库） sqrt(需要开跟数、变量……) ———————————————————————————— for语句： for(控制变量初始化表达式（条件循环开始时）；条件表达式（循环能够进行的条件）；增量表达式（每一次循环结束后执行的事）) { 语句1； 语句2； …… }
万能模块： #include<bits/stdc++.h>
while语句：
格式1： while(条件表达式) 语句1； 说明：语句1是while循环语句的循环体，它将在满足条件的情况下被重复执行
格式2： while(条件表达式){ 语句1； 语句2； …… } 说明：循环体部分由多个语句构成，应由一对花括号（{}）括起来，构成一个语句块的形式。 —————————————————————————— (n!)阶乘： 例： #include using namespace std; int main(){ int n; cin>>n; int sum=1; for(int a=1;a<=n;a++){ sum=sum*a; } cout<<sum<<endl; return 0; } ——————————————————————— 勾股定理：
口诀：勾三股四弦五
常用勾股数： 3 4 5 5 12 13 ——----—————————————————————————— 快速排序： #include #include//常用库函数头文件 //sort() 快速排序 using namespace std; bool cmp(int a,int b) { return a > b; } int main() { int a[10]={1,7,2,5,9,10,66,6}; //sort(需要排序的数组名+开始的位置，数值名+结束的位置，排序的顺序)； sort(a + 0;i<=7;i++) { cout< }
数组：
类型标识符 数组名[常量表达式] 说明： ①数组名的命名规则与变量名的命名规则一致。 ②常量表达式表示数组元素的个数，可以是常量和符号常量但不能是变量。
数组名[下标] 例： a[5] a[i+j] a[i++] 说明： ①下标可以是任意值为整型的表达式，该表达式里可以包含变量和函数调用。 ②数组的精妙在于下标可以是变量，通过对下标变量值的灵活控制，达到灵活处理数组元素的目的。 ③C++语言只能逐个引用数组元素，而不能一次引用整个数组。 ④数组元素可以向同类型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout< ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s## 标准数据类型： ——————————————————————————————- | 数据类型 | 自定义识符 | 占字节 | 数值范围 | ————————————————————————------------- |短整型 | short[int] | 2(16位) | -32768~32767 | |整型 | [long]int | 4(32位) | -2147483648~2147483647| |单精度实型 | float | 4(32位) | -3.4E+38~3.4E+38 |
计算ASCII码值； //在ASCII编码中，A=65 #include #include using namespace std; int main() { int b="A"; b*=2; printf("%d",b); return 0; } 结果：130
计算球的体积： #include #include using namespace std; double r; int main(){ scanf("%lf",&r); printf("%2lf",4/33.14rrr); return 0;
等差数列末项计算： #include using namespace std; int main(){ int a1,a2,n; cin>>a1>>a2>>n; cout<<(a2-a1)*(n-1)+a1<<endl; return 0;
}
判断偶数： #include using namespace std; int main() { int a; cin>>a; if (a%2==0) cout<<"偶数"<
判断奇数： #include using namespace std; int main() { int a; cin>>a; if (a%2==1) cout<<"奇数"< 判断大于1，小于100的数 #include using namespace std; int main() { int a; cin>>a; if (a<1 && a>100) cout<<"yes"< __------------------------------------------------------- 输入3个数，大到小排序： #include using namespace std; int main() { int a,b,c,temp; cin>>a>>b>>c>>temp; if(a if(a if(b cout<
判断数正负： #include using namespace std; int main(){ long n; scanf("%ld",&n); if (n>0)printf("psoitive"); else if (n=0)printf("zero"); else printf("negative"); return 0; }
swiach语句： #include using namespace std; main int (){ char a; cin>>a; switch(表达式){ case 常量表达式： //case后不需要{} //case没有顺序 a++; break;//跳出，否则会往下继续执行剩下的case case "b": b++; break; case 3; //代码块 default://所有case都不满足，会执行default//case后的值不能相同，否则会报错 } }
1.case语句后的各常量表达式的值不能相同
1.语句的选择： 基本if选择：处理单一或组合条件的情况 if-else选择：处理简单的条件分支情况 多重if选择：处理复杂的条件分支情况 嵌套if选择：用于单一或组合条件的情况 表达式的结果是boolean布尔类型（常用于区间判断）
2.switch语句的选择： 多重分支并且条件判断的情况，表达式的类型不能是boolean类型！可能是byte,int,char,string举例（常用于等值判断）
能用switch语句实现的就一定可以使用if来实现，但是反之不一定，如果是区间范围就采用if，如果是等值判断请使用switch ———————————————————————————————————————————— 格式化输入输出： #include #include //c语言 std标准 io输入输出 using namespace std; int main(){ int n,m; //格式化输入输出 //格式化输入 scanf("%d-%d",&n,&m); //""里的内容是需要输入的内容，包括格式 //%d 占地符 //& 取地址符 //scanf使用时一定要用取地址+变量名
// 格式化输出 printf("我今年%d岁，身高是%d厘米",n,m); //""里原封不动输出 //printf后的变量名前面没有取地址符 //占位符 //%d int //%f float //%lf double //%c char //%s string //占位符在输入时的应用 //%2d 在读取时，只读取两个字符宽度 //占位符在输出时的应用 //%.2f 输出时，保留2位小数 //%4d 输出时，输出4个字符宽度（右对齐） //%-4d 输出时，左对齐 //%4.3f 输出时，保留3位小数，并且，占四个字符宽度 //转义字符（一般用在printf中） printf("我今年的年龄是%d\n",a); // 斜杠（/） // 反斜杠（\） // 转义字符（\+字符）一般用在格式化输出 // (\')输出文本意义的’ // (\")输出文本意义的" // (\\)输出文本意义的\ // (\n)换行 // (\t)制表符 // (\b)退格（backsapce） // (\r)回车 // (\0)空字符}
//勾股定理：任意直角三角形两条直角边的平方和等于斜边的平方———————————————————————————————————————— 海伦公式： （在不知道三角形高的情况下，只需知道三角形的三条边即可算出三角形面积）
①p=(a+b+c)/2
②s=根号[p*(p-a)*(p-b)*(p-c)] ———————————————————————— 开根号： （必须使用cmath数学库） sqrt(需要开跟数、变量……) ———————————————————————————— for语句： for(控制变量初始化表达式（条件循环开始时）；条件表达式（循环能够进行的条件）；增量表达式（每一次循环结束后执行的事）) { 语句1； 语句2； …… }
万能模块： #include<bits/stdc++.h>
while语句：
格式1： while(条件表达式) 语句1； 说明：语句1是while循环语句的循环体，它将在满足条件的情况下被重复执行
格式2： while(条件表达式){ 语句1； 语句2； …… } 说明：循环体部分由多个语句构成，应由一对花括号（{}）括起来，构成一个语句块的形式。 —————————————————————————— (n!)阶乘： 例： #include using namespace std; int main(){ int n; cin>>n; int sum=1; for(int a=1;a<=n;a++){ sum=sum*a; } cout<<sum<<endl; return 0; } ——————————————————————— 勾股定理：
口诀：勾三股四弦五
常用勾股数： 3 4 5 5 12 13 ——----—————————————————————————— 快速排序： #include #include//常用库函数头文件 //sort() 快速排序 using namespace std; bool cmp(int a,int b) { return a > b; } int main() { int a[10]={1,7,2,5,9,10,66,6}; //sort(需要排序的数组名+开始的位置，数值名+结束的位置，排序的顺序)； sort(a + 0;i<=7;i++) { cout< }
数组：
类型标识符 数组名[常量表达式] 说明： ①数组名的命名规则与变量名的命名规则一致。 ②常量表达式表示数组元素的个数，可以是常量和符号常量但不能是变量。
数组名[下标] 例： a[5] a[i+j] a[i++] 说明： ①下标可以是任意值为整型的表达式，该表达式里可以包含变量和函数调用。 ②数组的精妙在于下标可以是变量，通过对下标变量值的灵活控制，达到灵活处理数组元素的目的。 ③C++语言只能逐个引用数组元素，而不能一次引用整个数组。 ④数组元素可以向同类型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout< ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s## 标准数据类型： ——————————————————————————————- | 数据类型 | 自定义识符 | 占字节 | 数值范围 | ————————————————————————------------- |短整型 | short[int] | 2(16位) | -32768~32767 | |整型 | [long]int | 4(32位) | -2147483648~2147483647| |单精度实型 | float | 4(32位) | -3.4E+38~3.4E+38 |
计算ASCII码值； //在ASCII编码中，A=65 #include #include using namespace std; int main() { int b="A"; b*=2; printf("%d",b); return 0; } 结果：130
计算球的体积： #include #include using namespace std; double r; int main(){ scanf("%lf",&r); printf("%2lf",4/33.14rrr); return 0;
等差数列末项计算： #include using namespace std; int main(){ int a1,a2,n; cin>>a1>>a2>>n; cout<<(a2-a1)*(n-1)+a1<<endl; return 0;
}
判断偶数： #include using namespace std; int main() { int a; cin>>a; if (a%2==0) cout<<"偶数"<
判断奇数： #include using namespace std; int main() { int a; cin>>a; if (a%2==1) cout<<"奇数"< 判断大于1，小于100的数 #include using namespace std; int main() { int a; cin>>a; if (a<1 && a>100) cout<<"yes"< __------------------------------------------------------- 输入3个数，大到小排序： #include using namespace std; int main() { int a,b,c,temp; cin>>a>>b>>c>>temp; if(a if(a if(b cout<
判断数正负： #include using namespace std; int main(){ long n; scanf("%ld",&n); if (n>0)printf("psoitive"); else if (n=0)printf("zero"); else printf("negative"); return 0; }
swiach语句： #include using namespace std; main int (){ char a; cin>>a; switch(表达式){ case 常量表达式： //case后不需要{} //case没有顺序 a++; break;//跳出，否则会往下继续执行剩下的case case "b": b++; break; case 3; //代码块 default://所有case都不满足，会执行default//case后的值不能相同，否则会报错 } }
1.case语句后的各常量表达式的值不能相同
1.语句的选择： 基本if选择：处理单一或组合条件的情况 if-else选择：处理简单的条件分支情况 多重if选择：处理复杂的条件分支情况 嵌套if选择：用于单一或组合条件的情况 表达式的结果是boolean布尔类型（常用于区间判断）
2.switch语句的选择： 多重分支并且条件判断的情况，表达式的类型不能是boolean类型！可能是byte,int,char,string举例（常用于等值判断）
能用switch语句实现的就一定可以使用if来实现，但是反之不一定，如果是区间范围就采用if，如果是等值判断请使用switch ———————————————————————————————————————————— 格式化输入输出： #include #include //c语言 std标准 io输入输出 using namespace std; int main(){ int n,m; //格式化输入输出 //格式化输入 scanf("%d-%d",&n,&m); //""里的内容是需要输入的内容，包括格式 //%d 占地符 //& 取地址符 //scanf使用时一定要用取地址+变量名
// 格式化输出 printf("我今年%d岁，身高是%d厘米",n,m); //""里原封不动输出 //printf后的变量名前面没有取地址符 //占位符 //%d int //%f float //%lf double //%c char //%s string //占位符在输入时的应用 //%2d 在读取时，只读取两个字符宽度 //占位符在输出时的应用 //%.2f 输出时，保留2位小数 //%4d 输出时，输出4个字符宽度（右对齐） //%-4d 输出时，左对齐 //%4.3f 输出时，保留3位小数，并且，占四个字符宽度 //转义字符（一般用在printf中） printf("我今年的年龄是%d\n",a); // 斜杠（/） // 反斜杠（\） // 转义字符（\+字符）一般用在格式化输出 // (\')输出文本意义的’ // (\")输出文本意义的" // (\\)输出文本意义的\ // (\n)换行 // (\t)制表符 // (\b)退格（backsapce） // (\r)回车 // (\0)空字符}
//勾股定理：任意直角三角形两条直角边的平方和等于斜边的平方———————————————————————————————————————— 海伦公式： （在不知道三角形高的情况下，只需知道三角形的三条边即可算出三角形面积）
①p=(a+b+c)/2
②s=根号[p*(p-a)*(p-b)*(p-c)] ———————————————————————— 开根号： （必须使用cmath数学库） sqrt(需要开跟数、变量……) ———————————————————————————— for语句： for(控制变量初始化表达式（条件循环开始时）；条件表达式（循环能够进行的条件）；增量表达式（每一次循环结束后执行的事）) { 语句1； 语句2； …… }
万能模块： #include<bits/stdc++.h>
while语句：
格式1： while(条件表达式) 语句1； 说明：语句1是while循环语句的循环体，它将在满足条件的情况下被重复执行
格式2： while(条件表达式){ 语句1； 语句2； …… } 说明：循环体部分由多个语句构成，应由一对花括号（{}）括起来，构成一个语句块的形式。 —————————————————————————— (n!)阶乘： 例： #include using namespace std; int main(){ int n; cin>>n; int sum=1; for(int a=1;a<=n;a++){ sum=sum*a; } cout<<sum<<endl; return 0; } ——————————————————————— 勾股定理：
口诀：勾三股四弦五
常用勾股数： 3 4 5 5 12 13 ——----—————————————————————————— 快速排序： #include #include//常用库函数头文件 //sort() 快速排序 using namespace std; bool cmp(int a,int b) { return a > b; } int main() { int a[10]={1,7,2,5,9,10,66,6}; //sort(需要排序的数组名+开始的位置，数值名+结束的位置，排序的顺序)； sort(a + 0;i<=7;i++) { cout< }
数组：
类型标识符 数组名[常量表达式] 说明： ①数组名的命名规则与变量名的命名规则一致。 ②常量表达式表示数组元素的个数，可以是常量和符号常量但不能是变量。
数组名[下标] 例： a[5] a[i+j] a[i++] 说明： ①下标可以是任意值为整型的表达式，该表达式里可以包含变量和函数调用。 ②数组的精妙在于下标可以是变量，通过对下标变量值的灵活控制，达到灵活处理数组元素的目的。 ③C++语言只能逐个引用数组元素，而不能一次引用整个数组。 ④数组元素可以向同类型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout< ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s## 标准数据类型： ——————————————————————————————- | 数据类型 | 自定义识符 | 占字节 | 数值范围 | ————————————————————————------------- |短整型 | short[int] | 2(16位) | -32768~32767 | |整型 | [long]int | 4(32位) | -2147483648~2147483647| |单精度实型 | float | 4(32位) | -3.4E+38~3.4E+38 |
计算ASCII码值； //在ASCII编码中，A=65 #include #include using namespace std; int main() { int b="A"; b*=2; printf("%d",b); return 0; } 结果：130
计算球的体积： #include #include using namespace std; double r; int main(){ scanf("%lf",&r); printf("%2lf",4/33.14rrr); return 0;
等差数列末项计算： #include using namespace std; int main(){ int a1,a2,n; cin>>a1>>a2>>n; cout<<(a2-a1)*(n-1)+a1<<endl; return 0;
}
判断偶数： #include using namespace std; int main() { int a; cin>>a; if (a%2==0) cout<<"偶数"<
判断奇数： #include using namespace std; int main() { int a; cin>>a; if (a%2==1) cout<<"奇数"< 判断大于1，小于100的数 #include using namespace std; int main() { int a; cin>>a; if (a<1 && a>100) cout<<"yes"< __------------------------------------------------------- 输入3个数，大到小排序： #include using namespace std; int main() { int a,b,c,temp; cin>>a>>b>>c>>temp; if(a if(a if(b cout<
判断数正负： #include using namespace std; int main(){ long n; scanf("%ld",&n); if (n>0)printf("psoitive"); else if (n=0)printf("zero"); else printf("negative"); return 0; }
swiach语句： #include using namespace std; main int (){ char a; cin>>a; switch(表达式){ case 常量表达式： //case后不需要{} //case没有顺序 a++; break;//跳出，否则会往下继续执行剩下的case case "b": b++; break; case 3; //代码块 default://所有case都不满足，会执行default//case后的值不能相同，否则会报错 } }
1.case语句后的各常量表达式的值不能相同
1.语句的选择： 基本if选择：处理单一或组合条件的情况 if-else选择：处理简单的条件分支情况 多重if选择：处理复杂的条件分支情况 嵌套if选择：用于单一或组合条件的情况 表达式的结果是boolean布尔类型（常用于区间判断）
2.switch语句的选择： 多重分支并且条件判断的情况，表达式的类型不能是boolean类型！可能是byte,int,char,string举例（常用于等值判断）
能用switch语句实现的就一定可以使用if来实现，但是反之不一定，如果是区间范围就采用if，如果是等值判断请使用switch ———————————————————————————————————————————— 格式化输入输出： #include #include //c语言 std标准 io输入输出 using namespace std; int main(){ int n,m; //格式化输入输出 //格式化输入 scanf("%d-%d",&n,&m); //""里的内容是需要输入的内容，包括格式 //%d 占地符 //& 取地址符 //scanf使用时一定要用取地址+变量名
// 格式化输出 printf("我今年%d岁，身高是%d厘米",n,m); //""里原封不动输出 //printf后的变量名前面没有取地址符 //占位符 //%d int //%f float //%lf double //%c char //%s string //占位符在输入时的应用 //%2d 在读取时，只读取两个字符宽度 //占位符在输出时的应用 //%.2f 输出时，保留2位小数 //%4d 输出时，输出4个字符宽度（右对齐） //%-4d 输出时，左对齐 //%4.3f 输出时，保留3位小数，并且，占四个字符宽度 //转义字符（一般用在printf中） printf("我今年的年龄是%d\n",a); // 斜杠（/） // 反斜杠（\） // 转义字符（\+字符）一般用在格式化输出 // (\')输出文本意义的’ // (\")输出文本意义的" // (\\)输出文本意义的\ // (\n)换行 // (\t)制表符 // (\b)退格（backsapce） // (\r)回车 // (\0)空字符}
//勾股定理：任意直角三角形两条直角边的平方和等于斜边的平方———————————————————————————————————————— 海伦公式： （在不知道三角形高的情况下，只需知道三角形的三条边即可算出三角形面积）
①p=(a+b+c)/2
②s=根号[p*(p-a)*(p-b)*(p-c)] ———————————————————————— 开根号： （必须使用cmath数学库） sqrt(需要开跟数、变量……) ———————————————————————————— for语句： for(控制变量初始化表达式（条件循环开始时）；条件表达式（循环能够进行的条件）；增量表达式（每一次循环结束后执行的事）) { 语句1； 语句2； …… }
万能模块： #include<bits/stdc++.h>
while语句：
格式1： while(条件表达式) 语句1； 说明：语句1是while循环语句的循环体，它将在满足条件的情况下被重复执行
格式2： while(条件表达式){ 语句1； 语句2； …… } 说明：循环体部分由多个语句构成，应由一对花括号（{}）括起来，构成一个语句块的形式。 —————————————————————————— (n!)阶乘： 例： #include using namespace std; int main(){ int n; cin>>n; int sum=1; for(int a=1;a<=n;a++){ sum=sum*a; } cout<<sum<<endl; return 0; } ——————————————————————— 勾股定理：
口诀：勾三股四弦五
常用勾股数： 3 4 5 5 12 13 ——----—————————————————————————— 快速排序： #include #include//常用库函数头文件 //sort() 快速排序 using namespace std; bool cmp(int a,int b) { return a > b; } int main() { int a[10]={1,7,2,5,9,10,66,6}; //sort(需要排序的数组名+开始的位置，数值名+结束的位置，排序的顺序)； sort(a + 0;i<=7;i++) { cout< }
数组：
类型标识符 数组名[常量表达式] 说明： ①数组名的命名规则与变量名的命名规则一致。 ②常量表达式表示数组元素的个数，可以是常量和符号常量但不能是变量。
数组名[下标] 例： a[5] a[i+j] a[i++] 说明： ①下标可以是任意值为整型的表达式，该表达式里可以包含变量和函数调用。 ②数组的精妙在于下标可以是变量，通过对下标变量值的灵活控制，达到灵活处理数组元素的目的。 ③C++语言只能逐个引用数组元素，而不能一次引用整个数组。 ④数组元素可以向同类型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout< ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s## 标准数据类型： ——————————————————————————————- | 数据类型 | 自定义识符 | 占字节 | 数值范围 | ————————————————————————------------- |短整型 | short[int] | 2(16位) | -32768~32767 | |整型 | [long]int | 4(32位) | -2147483648~2147483647| |单精度实型 | float | 4(32位) | -3.4E+38~3.4E+38 |
计算ASCII码值； //在ASCII编码中，A=65 #include #include using namespace std; int main() { int b="A"; b*=2; printf("%d",b); return 0; } 结果：130
计算球的体积： #include #include using namespace std; double r; int main(){ scanf("%lf",&r); printf("%2lf",4/33.14rrr); return 0;
等差数列末项计算： #include using namespace std; int main(){ int a1,a2,n; cin>>a1>>a2>>n; cout<<(a2-a1)*(n-1)+a1<<endl; return 0;
}
判断偶数： #include using namespace std; int main() { int a; cin>>a; if (a%2==0) cout<<"偶数"<
判断奇数： #include using namespace std; int main() { int a; cin>>a; if (a%2==1) cout<<"奇数"< 判断大于1，小于100的数 #include using namespace std; int main() { int a; cin>>a; if (a<1 && a>100) cout<<"yes"< __------------------------------------------------------- 输入3个数，大到小排序： #include using namespace std; int main() { int a,b,c,temp; cin>>a>>b>>c>>temp; if(a if(a if(b cout<
判断数正负： #include using namespace std; int main(){ long n; scanf("%ld",&n); if (n>0)printf("psoitive"); else if (n=0)printf("zero"); else printf("negative"); return 0; }
swiach语句： #include using namespace std; main int (){ char a; cin>>a; switch(表达式){ case 常量表达式： //case后不需要{} //case没有顺序 a++; break;//跳出，否则会往下继续执行剩下的case case "b": b++; break; case 3; //代码块 default://所有case都不满足，会执行default//case后的值不能相同，否则会报错 } }
1.case语句后的各常量表达式的值不能相同
1.语句的选择： 基本if选择：处理单一或组合条件的情况 if-else选择：处理简单的条件分支情况 多重if选择：处理复杂的条件分支情况 嵌套if选择：用于单一或组合条件的情况 表达式的结果是boolean布尔类型（常用于区间判断）
2.switch语句的选择： 多重分支并且条件判断的情况，表达式的类型不能是boolean类型！可能是byte,int,char,string举例（常用于等值判断）
能用switch语句实现的就一定可以使用if来实现，但是反之不一定，如果是区间范围就采用if，如果是等值判断请使用switch ———————————————————————————————————————————— 格式化输入输出： #include #include //c语言 std标准 io输入输出 using namespace std; int main(){ int n,m; //格式化输入输出 //格式化输入 scanf("%d-%d",&n,&m); //""里的内容是需要输入的内容，包括格式 //%d 占地符 //& 取地址符 //scanf使用时一定要用取地址+变量名
// 格式化输出 printf("我今年%d岁，身高是%d厘米",n,m); //""里原封不动输出 //printf后的变量名前面没有取地址符 //占位符 //%d int //%f float //%lf double //%c char //%s string //占位符在输入时的应用 //%2d 在读取时，只读取两个字符宽度 //占位符在输出时的应用 //%.2f 输出时，保留2位小数 //%4d 输出时，输出4个字符宽度（右对齐） //%-4d 输出时，左对齐 //%4.3f 输出时，保留3位小数，并且，占四个字符宽度 //转义字符（一般用在printf中） printf("我今年的年龄是%d\n",a); // 斜杠（/） // 反斜杠（\） // 转义字符（\+字符）一般用在格式化输出 // (\')输出文本意义的’ // (\")输出文本意义的" // (\\)输出文本意义的\ // (\n)换行 // (\t)制表符 // (\b)退格（backsapce） // (\r)回车 // (\0)空字符}
//勾股定理：任意直角三角形两条直角边的平方和等于斜边的平方———————————————————————————————————————— 海伦公式： （在不知道三角形高的情况下，只需知道三角形的三条边即可算出三角形面积）
①p=(a+b+c)/2
②s=根号[p*(p-a)*(p-b)*(p-c)] ———————————————————————— 开根号： （必须使用cmath数学库） sqrt(需要开跟数、变量……) ———————————————————————————— for语句： for(控制变量初始化表达式（条件循环开始时）；条件表达式（循环能够进行的条件）；增量表达式（每一次循环结束后执行的事）) { 语句1； 语句2； …… }
万能模块： #include<bits/stdc++.h>
while语句：
格式1： while(条件表达式) 语句1； 说明：语句1是while循环语句的循环体，它将在满足条件的情况下被重复执行
格式2： while(条件表达式){ 语句1； 语句2； …… } 说明：循环体部分由多个语句构成，应由一对花括号（{}）括起来，构成一个语句块的形式。 —————————————————————————— (n!)阶乘： 例： #include using namespace std; int main(){ int n; cin>>n; int sum=1; for(int a=1;a<=n;a++){ sum=sum*a; } cout<<sum<<endl; return 0; } ——————————————————————— 勾股定理：
口诀：勾三股四弦五
常用勾股数： 3 4 5 5 12 13 ——----—————————————————————————— 快速排序： #include #include//常用库函数头文件 //sort() 快速排序 using namespace std; bool cmp(int a,int b) { return a > b; } int main() { int a[10]={1,7,2,5,9,10,66,6}; //sort(需要排序的数组名+开始的位置，数值名+结束的位置，排序的顺序)； sort(a + 0;i<=7;i++) { cout< }
数组：
类型标识符 数组名[常量表达式] 说明： ①数组名的命名规则与变量名的命名规则一致。 ②常量表达式表示数组元素的个数，可以是常量和符号常量但不能是变量。
数组名[下标] 例： a[5] a[i+j] a[i++] 说明： ①下标可以是任意值为整型的表达式，该表达式里可以包含变量和函数调用。 ②数组的精妙在于下标可以是变量，通过对下标变量值的灵活控制，达到灵活处理数组元素的目的。 ③C++语言只能逐个引用数组元素，而不能一次引用整个数组。 ④数组元素可以向同类型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout< ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s
👍 2 -
@ 2023-7-8 14:11:39
合并果子
//p1090 合并果子 #include<bits/stdc++.h> using namespace std; int a[100000]; int main(){ int n,sum=0; cin>>n; for(int i=1;i<=n;i++){ cin>>a[i]; } sort(a+1,a+n+1); // ,7,7,9 while(1){ if(1==n) break; else { a[1]+=a[2]; sum+=a[1]; for(int l=2;l<n;l++){ a[l]=a[l+1]; } n--; } for(int l=1;l<n;l++){ if(a[l]>a[l+1]){ swap(a[l],a[l+1]); } } } cout<<sum; return 0; } -
@ 2023-7-7 18:59:46#P1803. 凌乱的yyy / 线段
仅供参考
#include<bits/stdc++.h> using namespace std; struct xhd{ int begin,end; }xht[1000005]; bool cmp(xhd a,xhd b){ return a.end<b.end; } int main(){ int n,s,flag=1; cin>>n; for(int i = 1;i<=n;i++){ cin>>xht[i].begin>>xht[i].end; } sort(xht,xht+n+1,cmp); s = xht[1].end; for(int t=0;t<=n;t++){ if(s<=xht[t].begin){ s = xht[t].end; flag++; } } cout<<flag; return 0; }-
@ 2023-7-8 9:44:41
感谢
-
-
@ 2023-7-7 17:59:45车厢重组：
#include<iostream> using namespace std; int main(){ int a[10000]={0}; int b,c=0,q; cin>>b; for(int i=1;i<=b;i++){ cin>>a[i]; } for(int i=1;i<=b;i++){ for(int j=1;i<=b-j;j++){ if(a[j]>a[j+1]){ q=a[j]; a[j]=a[j+1]; a[j+1]=q; c+=1; } } } cout<<c<<endl; return 0; } -
@ 2023-7-7 17:53:10
TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！ TM孔柘淇大扇贝！！！！
-
@ 2023-7-7 17:53:47
对不起
-
-
@ 2023-7-7 17:50:14
标准数据类型： ——————————————————————————————- | 数据类型 | 自定义识符 | 占字节 | 数值范围 | ————————————————————————------------- |短整型 | short[int] | 2(16位) | -32768~32767 | |整型 | [long]int | 4(32位) | -2147483648~2147483647| |单精度实型 | float | 4(32位) | -3.4E+38~3.4E+38 |
计算ASCII码值； //在ASCII编码中，A=65 #include #include using namespace std; int main() { int b="A"; b*=2; printf("%d",b); return 0; } 结果：130
计算球的体积： #include #include using namespace std; double r; int main(){ scanf("%lf",&r); printf("%2lf",4/33.14rrr); return 0;
等差数列末项计算： #include using namespace std; int main(){ int a1,a2,n; cin>>a1>>a2>>n; cout<<(a2-a1)*(n-1)+a1<<endl; return 0;
}
判断偶数： #include using namespace std; int main() { int a; cin>>a; if (a%2==0) cout<<"偶数"<
判断奇数： #include using namespace std; int main() { int a; cin>>a; if (a%2==1) cout<<"奇数"< 判断大于1，小于100的数 #include using namespace std; int main() { int a; cin>>a; if (a<1 && a>100) cout<<"yes"< __------------------------------------------------------- 输入3个数，大到小排序： #include using namespace std; int main() { int a,b,c,temp; cin>>a>>b>>c>>temp; if(a if(a<c) { temp=a;a=c;c=temp; } if(b<c) { temp=b;b=c;c=temp; } cout<<a<<" "<<" "<<endl; return 0; }
判断数正负： #include using namespace std; int main(){ long n; scanf("%ld",&n); if (n>0)printf("psoitive"); else if (n=0)printf("zero"); else printf("negative"); return 0; }
swiach语句： #include using namespace std; main int (){ char a; cin>>a; switch(表达式){ case 常量表达式： //case后不需要{} //case没有顺序 a++; break;//跳出，否则会往下继续执行剩下的case case "b": b++; break; case 3; //代码块 default://所有case都不满足，会执行default//case后的值不能相同，否则会报错 } }
1.case语句后的各常量表达式的值不能相同
1.语句的选择： 基本if选择：处理单一或组合条件的情况 if-else选择：处理简单的条件分支情况 多重if选择：处理复杂的条件分支情况 嵌套if选择：用于单一或组合条件的情况 表达式的结果是boolean布尔类型（常用于区间判断）
2.switch语句的选择： 多重分支并且条件判断的情况，表达式的类型不能是boolean类型！可能是byte,int,char,string举例（常用于等值判断）
能用switch语句实现的就一定可以使用if来实现，但是反之不一定，如果是区间范围就采用if，如果是等值判断请使用switch ———————————————————————————————————————————— 格式化输入输出： #include #include //c语言 std标准 io输入输出 using namespace std; int main(){ int n,m; //格式化输入输出 //格式化输入 scanf("%d-%d",&n,&m); //""里的内容是需要输入的内容，包括格式 //%d 占地符 //& 取地址符 //scanf使用时一定要用取地址+变量名
// 格式化输出 printf("我今年%d岁，身高是%d厘米",n,m); //""里原封不动输出 //printf后的变量名前面没有取地址符 //占位符 //%d int //%f float //%lf double //%c char //%s string //占位符在输入时的应用 //%2d 在读取时，只读取两个字符宽度 //占位符在输出时的应用 //%.2f 输出时，保留2位小数 //%4d 输出时，输出4个字符宽度（右对齐） //%-4d 输出时，左对齐 //%4.3f 输出时，保留3位小数，并且，占四个字符宽度 //转义字符（一般用在printf中） printf("我今年的年龄是%d\n",a); // 斜杠（/） // 反斜杠（\） // 转义字符（\+字符）一般用在格式化输出 // (\')输出文本意义的’ // (\")输出文本意义的" // (\\)输出文本意义的\ // (\n)换行 // (\t)制表符 // (\b)退格（backsapce） // (\r)回车 // (\0)空字符}
//勾股定理：任意直角三角形两条直角边的平方和等于斜边的平方———————————————————————————————————————— 海伦公式： （在不知道三角形高的情况下，只需知道三角形的三条边即可算出三角形面积）
①p=(a+b+c)/2
②s=根号[p*(p-a)(p-b)(p-c)] ———————————————————————— 开根号： （必须使用cmath数学库） sqrt(需要开跟数、变量……) ———————————————————————————— for语句： for(控制变量初始化表达式（条件循环开始时）；条件表达式（循环能够进行的条件）；增量表达式（每一次循环结束后执行的事）) { 语句1； 语句2； …… }
万能模块： #include<bits/stdc++.h>
while语句：
格式1： while(条件表达式) 语句1； 说明：语句1是while循环语句的循环体，它将在满足条件的情况下被重复执行
格式2： while(条件表达式){ 语句1； 语句2； …… } 说明：循环体部分由多个语句构成，应由一对花括号（{}）括起来，构成一个语句块的形式。 —————————————————————————— (n!)阶乘： 例： #include using namespace std; int main(){ int n; cin>>n; int sum=1; for(int a=1;a<=n;a++){ sum=sum*a; } cout<<sum<<endl; return 0; } ——————————————————————— 勾股定理：
口诀：勾三股四弦五
常用勾股数： 3 4 5 5 12 13 ——----—————————————————————————— 快速排序： #include #include//常用库函数头文件 //sort() 快速排序 using namespace std; bool cmp(int a,int b) { return a > b; } int main() { int a[10]={1,7,2,5,9,10,66,6}; //sort(需要排序的数组名+开始的位置，数值名+结束的位置，排序的顺序)； sort(a + 0;i<=7;i++) { cout< }
数组：
类型标识符 数组名[常量表达式] 说明： ①数组名的命名规则与变量名的命名规则一致。 ②常量表达式表示数组元素的个数，可以是常量和符号常量但不能是变量。
数组名[下标] 例： a[5] a[i+j] a[i++] 说明： ①下标可以是任意值为整型的表达式，该表达式里可以包含变量和函数调用。 ②数组的精妙在于下标可以是变量，通过对下标变量值的灵活控制，达到灵活处理数组元素的目的。 ③C++语言只能逐个引用数组元素，而不能一次引用整个数组。 ④数组元素可以向同类型的普通变量那样使用，对其进行赋值和运算操作，和普通变量完全相同。
类型标识符 数组名[常量表达式] = {值1，值2，…} 例： int a[5]={1,2,3,4,5} 说明： ①在初值列表中可以全部元素的值，也可以写出部分。 例： int x[10]={0,1,2,3,4} 该方法一次仅对数组的前五个元素依次进行初始化。
memset(数组名，初始化数值，sizeof(数组名))；//数组化数组 sizeof()求数组的字节大小
数组平移： #include using namespace std; int main() { int a,b[10]; for(int c=0;c<10;c++){ cin>>b[c]; } a=b[0]; for(int c=0;c<9;c++) { b[c]=b[c+1]; } b[9]=a; for(int c=0;c<10;c++) { cout< cout<<endl; return 0; } ———————————————————— 循环输入： int x=0,a[10000] while(cin>>a[x]) { } while(~scanf("%d",&a[x])) { } //ctrl+c结束循环输入
桶排序： int a[10]= {2,4,6,8,3,45,23,12,56,7}; int b[100]= {0}; //一定要将b的下标 for(int i=0;i<10;i++) { b[a[i]]++;//将a中的数字映射到b的下标 } for(int i=0;i<100;i++) { if(b[i]!=0){ //按顺序输出b的下标就是排序结果 cout< }
冒泡排序； for(int i=1;i<n;i++){ for(int j=1;j<n-i;j++){ if(a[j]>a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } }
插入排序： #include #include using namespace std;
void print_array(int a[],int n){ //作用是打印一遍数列 for (int i = 0; i < n;i++){ //循环遍历数列 printf("%d ", a[i]); //打印 } printf("\n"); //换行 }
void insertion_sort(int a[],int n){ //作用是排序，主要函数 print_array(a, n); //排序之前先打印一遍 ///7, 8, 10, 11, 4, 12, 9, 6, 5,3 for (int i = 1; i < n;i++){ //循环遍历数列 int key = a[i]; //将循环到的数存进变量key int j = i - 1; //将j定义为i前面的一个数，往前找 while(j >= 0 && a[j] > key){ //直到找到一个比当前key值大的数为止 a[j + 1] = a[j]; //把大的数都往前移一位，留出空位 j--; //循环条件 } a[j + 1] = key; //将循环数放入空位，类似打扑克抓牌 print_array(a,n); //再打印一边，看排序步骤 } }
int main(){ //主程序 int a[] = {10, 8, 11, 7, 4, 12, 9, 6, 5,3}; //定义数组 insertion_sort(a, 10); //将数组和数组长度传入函数，开始运算 return 0; } —————————————————————————————————————— 字符常量和字符串常量的区别：
①两者的定界符不同，字符常量由单引号括起来，字符串常量由双引号括起来。 ②字符常量只能是单个字符，字符串常量则可以是多个字符。 ③可以把一个字符常量赋给一个字符变量，但不能把一个字符串常量赋给一个字符变量。 ④字符常量占一个字节，而字符串常量占用字节数等于字符串的字节数加1，增加的一个字节中存放字符串结束标志（\0）。 ———————————————————————————————————————————————————————— 函数：
①格式： 函数类型 函数名（）{
} ②函数类型： 可以分成两大类，有返回值（int、float……）和无返回值（void）。{库函数、主函数、自定义函数} ③返回值： 返回值类型必须与函数类型相等（否则可能会出现问题）。 ④函数分为：传值调用、传址调用 ———————————————————————————————————— 结构体：
结构体变量的定义有两种形式： ①定义结构体类型的时候同时定义变量 struct 结构体类型名{ //其中 struct 是关键字 成员表； //可以有多个成员 成员函数； //可以有多个成员函数，也可以没有 }结构体变量表； //可以同时定义多个结构体变量，用“，”隔开 ②先定义结构体再定义结构体变量 struct 结构体类型名{ 成员表； 成员函数； }； 结构体名 结构体变量表； //同样可以同时定义多个结构体变量 ———————————————————————————————————— 用递归解决斐波那契数列问题：
//fib是一个求第n项用的函数 int fib(int n){ if(n == 1 || n == 2){ return 1; }else{ return fib(n - 1) + fib(n - 2); } } //递归：在函数里面调用自己 int x; cin>>x; cout<<fib(x)<<endl; ———————————————————————————————————— 树： 1.在二叉树的第i层最多有2^{i-1}个节点（i>=1）。 2.深度为k的二叉树最多有2{k-1}个节点（k>=1）。 3.具有n个节点的完全二叉树的高度为[㏒n]+1。 4.对于一棵n个节点的完全二叉树，对任一个节点（编号为i），有： ①如果i=1，则节点i为根，无父节点；如果i>1，则其父节点编号为i/2。如果2i>n，则节点i无左孩子（当然也无右孩子）；否则左孩子编号为2i。 ②如果2i+1>n,则节点i无右孩子；否则右孩子编号为2i+1。 5.对任意一棵二叉树，如果其叶节点数为n0，度为2的节点数为n2，则一定满足：n0=n2+n1。 —————————————————————————————————————— 指针： 指针是内存单元的代号，只有地址确定，就一定能找到内存位置。 ①指针变量（和int一样是一种数据类型） ②int *p; 定义了一个名叫p的指针变量 ③指针变量定义后，一定要赋值，不能在不赋值的情况下运行程序 ④空指针：int *p = NULL ⑤野指针：没有具体指向的指针 —————————————————————————————————————— 搜索： ①深度优先搜索（DFS）
②广度优先搜索（BFS） ———————————————————————————————————— IP专业术语、竞赛知识、项目历史
计算机文化
计算机硬件
低级编程语言：汇编语言（涉及到硬件层面的编程）
高级编程语言：C++、Python、Java（能够使用自然语言进行编程）
面向过程C、面向对象Python、C++、Java
面向对象的特征是“对象”/“类”class
编译器：将高级编程语言翻译成机器码的软件G++、clang、GCC、masm、gdb
编辑器：记事本（编写代码的工具（码字的））记事本、VScode、sublime
解释器：功能和编译器类似，有的语言既有编译器又有解释器 Python（解释性语言） C++(编译性语言)
IDE：集成开发环境
信息学奥林匹克竞赛
CSP-J 非专业级别编程能力认证考试
X-小学组（山东独有）：小学生参加，初赛题目和初中一样，但是分数低 复赛单独命题，简单，但是没有证书
J-入门级（普及组）初中生
S-提高组、高中生
NOIP - 全国信息学奥林匹克竞赛-联赛
省选夏令营 - 50人 - 5人 - 省队
NOI - 全国信息学奥林匹克竞赛
国赛夏令营 - 3人 - 国家队
IOI - 国际信息学奥林匹克竞赛 —————————————————————————————————————————————————— 计算机：windows、linux、macOS、unix
手机：ios、android
TCP/IP：一种联网协议 IPv4、IPv6
FTP：文件传输协议
HTTP：超文本传输协议（网页）
局域网LAN（Local本地的）、广域网WAN
无线局域网WLAN
网速的单位 100mbps（带宽） —————————————————————————————————————————————————— ip地址的分类：A类、B类、C类、D类
—————————————————- |类型| 范围 | —————————————————- | A | 0.0.0.0 到 127.255.255.255 | | B |128.0.0.0 到 191.255.255.255 | | C |192.0.0.0 到 223.255.255.255 | | D |224.0.0.0 到 239.255.255.255 | | E |240.0.0.0 到 247.255.255.255 | —————————————————- ip地址是由四个三位数组成，中间用.分割，比如：127.0.0.1
ip地址开头第一个数，最大不能超过247（包括247） ip地址最后一个数，不能超过255（包括255） —————————————————————————————————————————————————— 机器码（0正 1负）：
原码：机器码，其中，第一位是符号位 比如：0 1010 → +10
反码：正数的反码是它本身，负数的反码是符号位不变，然后其余位数取反 比如 01010 → 01010 11010 → 10101
补码：正数的补码是本身，负数的补码是反码+1 比如：01010 → 01010 11010 → 10110 —————————————————————————————————————————————————————— 精选题目：
#P118A. String Task Description Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it:
deletes all the vowels, inserts a character "." before each consonant, replaces all uppercase consonants with corresponding lowercase ones. Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.
Help Petya cope with this easy task.
The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Print the resulting string. It is guaranteed that this string is not empty.
Input The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.
Output Print the resulting string. It is guaranteed that this string is not empty.
Samples 输入数据 1 输出数据 1 tour .t.r
输入数据 2 输出数据 2 Codeforces .c.d.f.r.c.s
输入数据 3 输出数据 3 aBAcAba .b.c.b
👍 2
- 1