c语言

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
 
   int area;  
  
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);
 
   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>
double cylinder(double r,double h);/*cylinder:圆柱体*/
int main(void){

double height,radius,volume;/*radius：半径，height：高度，volume：体积*/

    printf("Enter radius and height:");
    scanf("%lf %lf",&radius,&height);
    volume=cylinder(radius,height);
    printf("volume=%.3f\n",volume);

    return 0;

}
double cylinder(double r,double h){
    double result;
    result=3.1415926*r*r*h;
    return result;

}

“the area of the Pentagon is -nan (ind)” 这句话表示 “五边形的面积为 -nan (ind)”，这是一个异常的计算结果，并非合理的面积数值。
其中，“nan” 是 “Not a Number” 的缩写，在编程、数学计算场景中常用来表示 “非数字”，特指因数据错误、公式误用等导致无法定义或无法表示的数值；“ind” 通常是 “indeterminate” 的缩写，意为 “不确定的”，整体 “-nan (ind)” 即 “不确定的非数字”，说明面积计算过程出现了问题，而非五边形存在一个 “-nan (ind)” 这样的面积。
为什么会出现这种结果？
可能导致该异常的常见原因包括：
输入数据错误：比如计算时输入的五边形参数（如边长、apothem（边心距）、外接圆半径等）为负数、空值，或与公式要求的参数类型不匹配（例如用文本代替数字）。
公式使用不当：例如计算正五边形面积时，误用了仅适用于不规则五边形的拆分公式，或公式中出现分母为 0、根号下为负数等数学上无意义的运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stdio.h>
#include<math.h>
int main(){
    double a1,a2,a3,a4,a5,a6,a7,s;
    double area(double x,double y,double z);
    printf("Please input the lengths in the order a1 to a7:\n");/*order:次序     */
    scanf("%lf%lf%lf%lf%lf%lf%lf",&a1,&a2,&a3,&a4,&a5,&a6,&a7);
    s=area(a1,a5,a6)+area(a6,a7,a4)+area(a2,a7,a3);
    printf("the area of the Pentagon is %.2f\n",s);/*pentagon:五边形*/

    return 0;
}
double area(double x,double y,double z){
    double p=(x+y+z)/2;
    return sqrt(p*(p-x)*(p-y)*(p-z));

}

  • 解三角形面积函数模板
1
2
3
4
double area(double x,double y,double z){
   double p=(x+y+z)/2;
   return sqrt(p*(p-x)*(p-y)*(p-z));
}

判断完全平方数：从1开始的连续奇数的和，是一个完全平方数

三元运算符的语法
condition ? expression1 : expression2
条件 ？ 表达式1：表达式2
如果条件为真，则执行表达式1，并返回表达式1的结果，如果为假就执行并返回表达式2的结果

configure:配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<stdio.h>
int IsSquare(int n){
    if(n<0){
        return 0;
    }
    int i=1;
    while(n>0){
        n-=i;/*n循环遍历减1*/
        i+=2;/*i循环遍历加2*/
    }
    return n==0?1:0;/*如果n最后等于0则是完全平方数*/
}
int main(){
    int num;
    printf("Enter a integer:\n");/*integer:整数*/
    scanf("%d",&num);
    if (IsSquare(num)){/*()里判断条件真假，而1是真，2是假*/
        printf("%d is a square",num);
    }else{
        printf("%d is not a square",num);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
int gcd(int m,int n){
    int r,temp;/*temp:临时变量*/
    if(m<n){
        temp=m;m=n;n=temp;

    }
r=m%n;
while(r!=0){
    m=n;
    n=r;
    r=m%n;
}
return n;
}
int main(){
    int mm,nn,gg;
    scanf("%d%d",&mm,&nn);
    printf("gcd=%d",gg=gcd(mm,nn));
}

辗转相除法求最大公约数，数学定理gcd（m，n）=gcd（n，r）

模板:

1
2
3
4
5
6
7
r=m%n;
while(r!=0){
    m=n;/*倒着赋值*/
    n=r;
    r=m%n;
}
return n;

r是remainder（余数）的缩写，m是大数，n是小数，后续充当被除数和除数的角色
while既充当判断又充当循环，当r=0的时候n就是m和n的最大公约数，当余数不为零的时候，n变成m，r变成n（倒着赋值），再次取模进行循环，最终返回n

判断素数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<stdio.h>
#include<math.h> 
int prime(int m){
    int i,limit;
    if(m<=1){
        return 0;
    }else if(m==2){
        return 1;
    }else{
        limit=sqrt(m)+1;
        for(i=2;i<=limit;i++){
            if(m%i==0){
                return 0;
            }
        }
        return 1;
    }
}
int main(){
    int mm,nn;
    printf("Enter a intger:\n");
    scanf("%d",&mm);
    
    if(prime(mm)){
        printf("%d is a prime\n",mm);
    }else{
        printf("%d is not a prime\n",mm);
    }
    return 0;
}

判断素数首先分类讨论1（不是素数），2（是素数）的特殊情况，然后找一个循环遍历的限制limit是m的开方再加1，用i到limit的数字开始遍历取模m，每取模一次，进行依次if判断，如果正好被整除，说明不是素数，如果不被整除，说明是素数
模板

1
2
3
4
5
6
7
8
9
10
11
12
13
int m,i,limit;
if(m<=1){
    return 0;
}else if(m==2){
    return 1;
}else{
    limit=sqrt(m)+1;
    for(i=1;i<=limit;i++){
        if(m%i==0){
            return 0;
        }
    }
}

数字金字塔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include<stdio.h>
int main(){
    int n;
    void pyramid(int n);/*声明一个无返回值的函数*/
    printf("Enter n\n");
    scanf("%d",&n);
    pyramid(n);
    return 0;
}
void pyramid(int n){
    int i,j;
    for(i=1;i<=n;i++){
        for(j=1;j<=n-i;j++){
            printf(" ");
        }
        for(j=1;j<=i;j++){
            printf("%d",i);
            printf(" ");
        }
        putchar('\n');
        
    }
}

数字金字塔先从每一行循环开始，一行循环中又分为两个循环递归，一个是空格循环，另一个是数字循环，空格循环是逐级递减的，所以要从n-i开始，其他条件不变（这里理解不了的话直接记模板：for(j=1;j<=n-i;j++)），数字循环是递增，注意递增也分为逐行递增和奇数个数式递增
不用记模板，我现在又理解了，先执行完空格循环，再开始执行数字循环，也就是说，j的开始是一个空格，打出一个空格后进行下一个循环，此时j递增为2，再打出一个空格，也就是说，一连串打出了n-i个空格，当n=5，i=1时，j=4，所以打出了4个空格
所以说并列的循环是先执行完整第一个循环，第一个循环结束后再执行第二个循环，而嵌套的循环是交叉的，假设嵌套两个循环，第一个循环执行一次，开始执行第二个循环，第二个循环完整执行结束后再开始执行第一个循环第二次

逐行递增

首先要注意逐行递增是随行数递增，所以是从i开始，边界值不要带成n，这里的边界值也是递增的，当i=1的时候，循环只进行一次就结束了，然后一个大循环完整执行一次，进入下一个大循环也就是i=2，在轮到数字循环时循环了两次，所以打了两个数字，以此类推
alt text
alt text

奇数式循环

也就是把空格替换成数字，就用奇数递推表达式i*2-1,这样就可以居中对齐了
alt text

计算复数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include<stdio.h>
double result_real,result_imag;/*result_real:实部结果，result_imag:虚部结果*/
int main(){
    double imag1,imag2,real1,real2;
    void complex_prod(double real1,double imag1,double real2,double imag2);/*complex product”（复数乘积）*/
    void complex_add(double real1,double imag1,double real2,double imag2);/*声明一个求和函数*/

    printf("Enter 1st complex number(real and imaginary):");
    scanf("%lf%lf",&real1,&imag1);
    printf("Enter 2st complex number(real and imaginary):");
    scanf("%lf%lf",&real2,&imag2);

    complex_add(real1,imag1,real2,imag2);
    printf("addition of complex is %f+%fi\n",result_real,result_imag);
    complex_prod(real1,imag1,real2,imag2);
    printf("product of complex is %f+%fi\n",result_real,result_imag);

    return 0;
}
void complex_add(double real1,double imag1,double real2,double imag2){
    result_real=real1+real2;
    result_imag=imag1+imag2;
}
void conplex_prod(double real1,double imag1,double real2,double imag2){
    result_real=real1*
}

记账

安装MYSY2

mysy2是
我的mysy2安装路径E:\msys64

C语言函数只能返回一个值。你需要通过指针参数来“返回”多个值，或者使用结构体。

&表示接收变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include<stdio.h>
#include<math.h>
void count(int a, int b, int c, double *area, double *peri) {
    double s = (a + b + c) / 2.0; // 注意：除以2.0保证浮点数运算
    *area = sqrt(s * (s - a) * (s - b) * (s - c));
    *peri = a + b + c;
}

int main(){
    int a,b,c;
    double peri,area;
    printf("Enter a,b,c:\n");
    scanf("%d%d%d",&a,&b,&c);
    if(a+b>c&&a+c>b&&b+c>a){
        count(a,b,c,&area,&peri);
        printf("area = %.2f; perimeter = %.2f",area,peri);
    }else{
        printf("These sides do not correspond to a valid triangle");
    }
    return 0;
}

#include <stdio.h>
#include <math.h>

void count(int a, int b, int c, double *area, double *peri) {
    double s = (a + b + c) / 2.0; // 使用 2.0 确保浮点运算
    *area = sqrt(s * (s - a) * (s - b) * (s - c));
    *peri = a + b + c;
}

int main() {
    int a, b, c;
    double area, peri;

    // 注意：题目没有要求输出提示，所以不要有 "Enter a,b,c:\n"
    scanf("%d %d %d", &a, &b, &c);

    if (a + b > c && a + c > b && b + c > a) {
        count(a, b, c, &area, &peri);
        // ✅ 输出格式严格匹配：area = %.2f; perimeter = %.2f\n
        printf("area = %.2f; perimeter = %.2f\n", area, peri);
    } else {
        // ✅ 输出格式严格匹配
        printf("These sides do not correspond to a valid triangle\n");
    }

    return 0;
}

统计字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<stdio.h>
int main(){
    int N,i;
    scanf("%d",&N);
    getchar();
    int letter=0,blank=0,digit=0,other=0;
    for(i=1;i<=N;i++){
    char c=getchar();
    if(c>='a'&&c<='z'||c>='A'&&c<='Z'){
    letter++;
    }else if(c==' '||c=='\n'){
    blank++;
    }else if(c>='0'&&c<='9'){
    digit++;
    }else{
    other++;
    }
    }
    printf("letter = %d, blank = %d, digit = %d, other = %d\n",letter,blank,digit,other);
return 0;
}

获取字符串用getchar（），用for循环读取的时候用char c容器来承载

阶乘计算e

我写的多函数调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<stdio.h>


double fact(int n){
    int i;
    double factoral=1;
    for(i=1;i<=n;i++){
        factoral*=i;
        
    }
    return factoral;
}
double sum(int n){
    int i;
    double sum=1;
    for(i=1;i<=n;i++){
        sum+=1.0/fact(i);
       
    }
     return sum;
}
int main(){
    int n;
    scanf("%d",&n);
    printf("%.8f",sum(n));
    return 0;
}

简化模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>

int main(){
    int n;
    scanf("%d", &n);
    
    double sum = 1.0;      // 第一项是1 (1/0! = 1)
    double factorial = 1.0; // 当前项的阶乘值
    
    for(int i = 1; i <= n; i++){
        factorial *= i;    // 计算i!
        sum += 1.0 / factorial;  // 加上1/i!
    }
    
    printf("%.8f\n", sum);
    return 0;
}

factorial:阶乘
累成或累加时记得初始化一个值，这个值对应i=0时的计算（我习惯以i=1作为循环的开始）注意在sum()中调用fact（）函数时输入的值是i不是n，这样fact才能随着sum里循环的进行而同步进行，相当于复合函数

字母金字塔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>
int main(){
    int n,i,j;
    scanf("%d",&n);
    char c='A';
    for(i=1;i<=n;i++){
        for(j=1;j<=n-i+1;j++){
            printf("%c ",c);
            c++;
        }
        printf("\n");
    }
    return 0;
}

哥德巴赫猜想

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <stdbool.h>


bool is_prime(long long n) {
    if (n < 2) return false;
    if (n == 2) return true;
    if (n % 2 == 0) return false;
    
    for (long long i = 3; i * i <= n; i += 2) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    long long n;
    scanf("%lld", &n);
    

    for (long long p = 2; p <= n / 2; p++) {
        if (is_prime(p)) {
            long long q = n - p;
            if (is_prime(q)) {
                printf("%lld = %lld + %lld\n", n, p, q);
                break;
            }
        }
    }
    
    return 0;
}

拉丁循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
int main(){
    int n,i,j;
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        for(j=i;j<=n;j++){
        printf("%d",j);
        }
    for(j=1;j<=i-1;j++){
        printf("%d",j);
    }
    printf("\n");4
}
    return 0;
}


回文序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
int ispalindrome(int n){
    if(n<0){
        return 0;
    }
    int temp = n;
    int reverse = 0;
    while(temp!=0){
        reverse = reverse*10+temp%10;
        temp/=10;
    }
    return(reverse == n)?1:0;
}
int main(){
    int num;
    printf("Enter num:");
    scanf("%d",&num);
    
    if(ispalindrome(num)){
        printf("yes");
    }else{
        printf("no");
    }
    return 0;
}


char s[10001]; // 因为n最大为10^4，所以数组大小设为10001（包含结束符’\0’）

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <string.h>

int main() {
    char s[10001]; // 因为n最大为10^4，所以数组大小设为10001（包含结束符'\0'）
    scanf("%s", s);
    printf("%s\n", s);
    return 0;
}

输入一个小写字母：scanf(" %c",&d);
数据类型选择：因为输入的c和d范围到10^9，所以用long long类型存储，避免整数溢出。计算死亡率时，将其中一个数转换为double类型（如(double)d），保证浮点运算的精度。
输入处理：使用scanf(“%lld %lld”, &c, &d)读取一行中的两个整数。
输出格式：死亡率需要保留三位小数并以百分数形式输出，所以用%.3f%%的格式，其中%.3f控制小数位数，%%用于输出百分号本身
在 C 语言中不建议使用 char d[1000000001]（即 10 亿个字符的数组），核心原因是内存超限，具体分析如下：

  1. 内存占用过大，超出实际可用范围
    每个 char 类型在 C 语言中占 1 字节，char d[1000000001] 需占用约 1GB 内存（10 亿字节 ≈ 953.7MB，接近 1GB）。
    而 C 语言中局部变量（如在 main 函数内定义的数组）默认存储在 栈内存 中，栈的大小通常非常有限（Windows 系统默认栈大小约 1MB~8MB，Linux 约 8MB），1GB 远超栈的承载能力，会直接导致 栈溢出（stack overflow），程序崩溃。
  2. 即使改为全局变量 / 静态变量，仍不实用
    若将数组定义为全局变量（如 char d[1000000001]; 放在 main 函数外）或静态变量（static char d[1000000001];），其存储位置会变为 全局 / 静态存储区（该区域空间较大，通常能容纳 GB 级数据）。
    但这种做法仍不推荐：
    浪费内存：大多数场景下，不需要 10 亿个字符的存储空间（比如存储普通输入的字符串，几百、几千字节已足够），过大的数组会长期占用大量内存，降低程序运行效率。
    兼容性问题：部分嵌入式系统、小型设备的内存总量可能不足 1GB，此时程序会因内存不足无法运行。
  3. 实际场景的替代方案
    若需存储超长字符串（如大文件内容），更合理的做法是：
    先预估实际需要的最大长度，定义合适大小的数组（如 char d[10001] 对应 1 万个字符，足够应对绝大多数输入场景）；
    若长度不确定，使用 动态内存分配（malloc/realloc），根据实际需求申请内存，用完后释放（避免内存浪费）；
    对于超大文件（GB 级），采用 “分块读取” 的方式，无需一次性存储全部内容。
    double rate = (double)d / c * 100;
    double rate：定义一个 double 类型（双精度浮点数）变量 rate，用于存储最终的百分数结果（支持小数，比如 3.14%）。
    (double)d：将变量 d 强制转换为 double 类型（浮点数）。
    关键原因：C 语言中，若两个整数（如 int/long long 类型的 d 和 c）直接相除，结果会自动 “取整”（丢弃小数部分，比如 3/2=1 而非 1.5）。
    强制转换 d 为 double 后，后续运算会自动按 “浮点数规则” 计算，保留小数精度（比如 3.0/2=1.5）。
    / c：用转换后的浮点数 d 除以变量 c，得到 “占比小数”（比如 d=3、c=10 时，3.0/10=0.3，即 30% 的小数形式）。
  • 100：将 “占比小数” 乘以 100，转换为百分数形式（比如 0.3*100=30.0，即 30.0%）

#include <stdio.h>

int main() {
long long c,d;
scanf(“%lld %lld”,&c,&d);
double rate = (double)d/c *100;
printf(“%.3%%\n”,rate);
return 0;
}
#include <stdio.h>

int main() {
long long c, d;
scanf(“%lld %lld”, &c, &d);
double rate = (double)d / c * 100;
printf(“%.3f%%\n”, rate);
return 0;
}

一个整数对 10 取余，结果就是它的个位数字。例如，114 % 10 = 4
取绝对值：通过abs函数获取a的绝对值abs_a，确保后续计算不受符号影响。注意前面要声明#include<stdolib.h>

int 表示有符号整数，既可以存储正整数，也可以存储负整数和零
fabs 函数：取差值的绝对值
double a = 80.0, b = 90.0, c = 85.0; // 假设输入的成绩
int s = a * 0.2 + b * 0.3 + c * 0.5;

int s不会把0.2那些强制转化为0吗

1
2
double a = 80.0, b = 90.0, c = 85.0;  // 假设输入的成绩
int s = a * 0.2 + b * 0.3 + c * 0.5;

第一步：计算各部分乘积
a * 0.2：a 是 double，0.2 是 double（C 语言中直接写的小数默认是 double），结果还是 double（如 80.0 * 0.2 = 16.0）；
b * 0.3：同理，90.0 * 0.3 = 27.0（double 类型）；
c * 0.5：85.0 * 0.5 = 42.5（double 类型）。
第二步：求和
三个 double 类型的结果相加：16.0 + 27.0 + 42.5 = 85.5（依然是 double 类型）。
第三步：赋值给 int 变量
只有这一步才发生类型转换：将 double 类型的 85.5 赋值给 int 类型的 s，C 语言会直接截断小数部分，得到 85（不是四舍五入）。
关键澄清：“0.2 被转化为 0” 的情况只在一种场景下发生
如果你的代码写成这样（把 0.2 当成整数处理），才会出现 0.2 被转化为 0 的情况：

1
2
int rate = 0.2;  // 错误写法：直接把小数赋值给 int
int s = a * rate;  // 此时 rate 是 0，导致结果为 0

这里的问题是：0.2 直接赋值给 int 变量 rate，会被截断为 0，后续计算自然出错。
但原代码中 0.2 是作为浮点数参与计算的，没有提前赋值给 int，所以不会有这个问题。

alt text

代码核心错误是 sum 未初始化，且循环内重复定义变量，导致结果异常（通常是随机垃圾值）。以下是详细分析和修正方案：
一、错误原因拆解
变量未初始化：long long sum 只在循环内定义，且定义时未赋初始值（C 语言中局部变量默认是随机值，不是 0）。更严重的是：循环内每次迭代都会重新创建 sum（之前的累加结果被销毁），循环结束后，printf 访问的是循环外未定义的 sum（编译可能警告，运行结果随机）。
循环内重复定义变量：把 long long sum 写在 for 循环内部，导致每次循环都生成一个新的 sum 变量，无法累积求和（相当于每次只加了当前 i，但下一次循环又重新开始）。
能被 400 整除的年份（如 2000 年、2400 年），一定是闰年；
能被 4 整除但不能被 100 整除的年份（如 2004 年、2020 年），是闰年；
其他情况（如 1900 年、2021 年），不是闰年

语法拆解
先明确核心语法：条件 ? 成立时的值 : 不成立时的值整行代码可拆分为 3 个关键部分：

1
2
3
4
printf("%c\n",  // 1. 输出部分：%c 表示输出单个字符，\n 换行
       a < b ? '<' :  // 2. 第一层三元运算符：判断 a 是否小于 b
       (a == b ? '=' : '>')  // 3. 第二层三元运算符（嵌套）：判断 a 是否等于 b
);

二、执行流程（从左到右，先判断再取值）
三元运算符是 “短路求值”：先判断条件，满足则直接取 “成立值”，不满足才继续判断后续逻辑。具体步骤：
先判断第一层条件 a < b：
若 a < b 为 真（比如 a=1, b=2）：直接取 ‘<’ 作为整个表达式的结果，后续嵌套的三元运算符不再执行；
若 a < b 为 假（比如 a=3, b=2 或 a=2, b=2）：进入第二层嵌套判断 a == b。
再判断第二层条件 a == b：
若 a == b 为 真（比如 a=2, b=2）：取 ‘=’ 作为表达式结果；
若 a == b 为 假（比如 a=3, b=2）：取 ‘>’ 作为表达式结果。
最后 printf 输出第二步得到的字符（<、= 或 >），并换行。

最大最小值

  • if后面不用{}吗
    在 C 语言中，if 后面的 {} 不是必须的，但用法有严格规则，核心取决于 if 要控制的代码行数 —— 这也是新手容易出错的点，结合你的代码和常见场景详细说明：
    一、核心规则：{} 的作用是 “代码块”
    {} 用于将多条语句包裹成一个 “代码块”，让 if（或 else、循环等）能控制整个代码块。如果 if 后面只有一条语句，{} 可以省略；如果有多条语句，{} 必须加，否则 if 只能控制第一条语句，后续语句会不受条件影响直接执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    
    // 求最大值
    int max = a;
    if (b > max) max = b;//注意把b与max比较，而不是a，这里max是一个更新迭代的值，用来储存最大值，所以后面赋值也是把b赋给max，注意顺序
    if (c > max) max = c;
    
    // 求最小值
    int min = a;
    if (b < min) min = b;
    if (c < min) min = c;
    
    printf("The maximum number is : %d\n", max);
    printf("The minimum number is : %d\n", min);
    return 0;
}

提取数字后两位用n%100
用循环之前一定要初始化变量为一个定值

1
2
3
4
5
6
7
for(a=2;a<=limit;a++){
    if(n%i==0){ // 假设条件为真
        isprime=0;
        break; // 这个 break 属于 if 语句块
    }
    break; // ❗️ 这个 break 在 if 语句块**外面**
}

关键在于 break 的位置

第一个 break：if 语句块内部的 break;。这个 break 只有在 if 条件为真时才会执行。如果 n%i==0，则执行 isprime=0; 和这个 break;，循环结束。
第二个 break：if 语句块外部的 break;。这个 break 无论 if 条件是真是假，都会在 if 语句块执行完后立即执行。

最大的差

第一行输入一个整数 nn（2≦n≦1052≦n≦105）。

第二行输入 nn 个整数 a1,a2,…,ana1​,a2​,…,an​，每个整数满足 −105≦ai≦105−105≦ai​≦105，用空格隔开。
输出描述：
输出一个整数 SS，表示所能获得的最大差值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <limits.h>

int main() {
    int n;
    scanf("%d", &n);
    int max = INT_MIN, min = INT_MAX, num;
    for (int i = 0; i < n; i++) {
        scanf("%d", &num);
        if (num > max) {
            max = num;
        }
        if (num < min) {
            min = num;
        }
    }
    printf("%d\n", max - min);
    return 0;
}

这样声明和初始化变量的核心目的是确保第一次读取的整数能正确更新 max 和 min，同时让代码逻辑严谨、无遗漏，具体原因如下：

  1. 为什么 max 要初始化为 INT_MIN（整型最小值）？
    max 的作用是记录所有输入整数中的 “最大值”，需要通过逐一比较来更新。
    若初始化为 0 或其他固定数值：
    假设输入的所有整数都小于这个初始值（比如输入 -5, -3, -1），那么 max 会一直保持初始值（比如 0），而不会更新为真正的最大值（-1），导致结果错误。
    初始化为 INT_MIN（比如 32 位系统中是 -2147483648）：
    这是 C 语言中整型能表示的最小可能值，任何输入的整数（只要是合法的 int 类型）都会大于或等于它。
    因此，第一次读取的整数必然会满足 num > max，从而将 max 正确更新为第一个数；后续读取的数再与当前 max 比较，逐步找到真正的最大值。
  2. 为什么 min 要初始化为 INT_MAX（整型最大值）？
    min 的作用是记录所有输入整数中的 “最小值”，逻辑与 max 相反，同样需要通过逐一比较更新。
    若初始化为 0 或其他固定数值：
    假设输入的所有整数都大于这个初始值（比如输入 2, 4, 6），那么 min 会一直保持初始值（比如 0），而不会更新为真正的最小值（2），导致结果错误。
    初始化为 INT_MAX（比如 32 位系统中是 2147483647）：
    这是 C 语言中整型能表示的最大可能值，任何输入的整数（只要是合法的 int 类型）都会小于或等于它。
    因此，第一次读取的整数必然会满足 num < min，从而将 min 正确更新为第一个数；后续读取的数再与当前 min 比较，逐步找到真正的最小值。
  3. 为什么要声明 num 作为临时变量？
    每次循环需要读取一个整数，不能直接将读取的数与 max/min 比较（scanf 需要一个变量的地址来存储输入值）。
    num 作为 “中转站”，先存储当前读取的整数，再用它来更新 max 和 min，避免重复读取输入（重复读取会导致跳过部分输入值）。
    示例逻辑：
    读取第一个数 → 存入 num → 用 num 更新 max 和 min → 读取第二个数 → 覆盖 num → 再用新 num 比较更新 max/min → 循环直至读完所有数。

% 运算符只能用于整数类型。
题目要求处理的整数范围是 [-10^9, 10^9]。虽然 double 可以存储这个范围内的数值，但它是一种浮点数，在进行数学运算（如取模 % 和幂运算 pow）时，会因为精度丢失而产生错误。

使用 long long 确保能容纳 10^9

pow 函数的返回值是 double： 
    pow(10, i) 是 math.h 中的函数，它接受两个 double 类型的参数，并返回一个 double 类型的结果。
    即使你传入的是整数 10 和 i，它们也会被隐式转换为 double，函数返回值也是 double。


/ 和 % 运算符不能用于 double 和 int 的混合运算： 
    在 C 语言中，% (取模) 运算符只能用于整数类型 (int, long, long long 等)。
    / (除法) 运算符可以用于 double，但当你将 double 类型的 pow 结果与 long long 类型的 n 进行除法时，结果会变成 double。
    最后，你试图对这个 double 类型的结果进行 % 10 操作，这在 C 语言中是非法的，因为 % 不支持浮点数。


强制类型转换无法解决根本问题： 
    即使你在 n / pow(10, i) 前面加上 (long long) 强制转换，比如 (long long)(n / pow(10, i))，这在数学上可能成立，但在编程实践中非常危险。
    因为 pow(10, i) 返回的是 double，对于大数 i（例如 i=9），pow(10, 9) 可能无法精确表示为 double，会产生微小的误差。当这个有误差的 double 被强制转换为 long long 时，可能会向下取整，导致结果错误。
    例如，pow(10, 9) 理论上应该是 1000000000.0，但由于浮点数精度限制，它可能是 999999999.999999...，强制转换后就变成了 999999999，从而导致计算错误。

数位之和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main() {
    long long n;
    scanf("%lld",&n);
    if(n<0){
        n=abs(n);
    }
    int sum=0;
    while(n!=0){//终止操作
        int digit=n%10;//提取个位操作
        sum=sum+digit;//把提取的个位加进去
        n=n/10;//去掉个位操作
    }
    printf("%d",sum);
    return 0;
}

gitoskip

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);

    for(int i = 1; i <= n; i++) {
        // 检查是否包含数字4
        int temp = i;
        while(temp != 0) {
            int digit = temp % 10;
            if(digit == 4) {
                goto skip; // 跳过当前i
            }
            temp = temp / 10;
        }

        // 如果不包含数字4，并且不是4的倍数，则输出
        if(i % 4 != 0) {
            printf("%d\n", i);
        }

skip: ; // 标签，空语句
    }

    return 0;
}

二维斐波那契数列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#define MOD 1000000007
#define MAX 1005
int main() {
    int n,m;
    scanf("%d%d",&n,&m);
    int dp[MAX][MAX]={0};//二维数组初始化
    //作用：定义一个二维整型数组 dp，尺寸为 MAX × MAX（1005×1005），并将所有元素初始化为 0。核心用途：dp[i][j] 用于存储二维斐波那契数列中第 i 行第 j 列的值，是动态规划的核心存储容器。
    dp[1][1]=1;
    for(int i=2;i<=n;i++){
        dp[i][1]=dp[i-1][1]%MOD;
    }
    for(int j=2;j<=m;j++){
        dp[1][j]=dp[1][j-1]%MOD;
    }
    for(int i=2;i<=n;i++){
        for(int j=2;j<=m;j++){
            dp[i][j]=(dp[i-1][j]+dp[i][j-1])%MOD;
        }
    }
    printf("%d\n",dp[n][m]%MOD);
    return 0;
}

循环存值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>

int main() {
    int arr[100];//作用：定义一个一维整型数组 arr，数组长度为 100（最多可存储 100 个整数）。
//用途：用于存储用户输入的、除 0 以外的所有整数（题目要求输入以 0 结尾，0 作为终止符不存储）。
//注意：数组下标从 0 开始，可访问的范围是 arr[0] 到 arr[99]，足够满足题目 “最多输入 100 个整数” 的需求。
    int count=0;//作用：定义一个整型变量 count，并初始化为 0。
//用途：作为数组的 “元素计数器”，记录当前数组中已存储的非 0 整数的个数（同时也是下一个元素的存储下标）。
    int num;

    while(1){//作用：创建一个 “无限循环”（while (1) 中的 1 表示逻辑真，循环会一直执行，除非遇到 break 终止）。
//用途：持续读取用户输入的整数，直到读取到 0 为止。
        scanf("%d",&num);
        if(num==0){
            break;
        }
    arr[count++]=num;//作用：将当前读取到的非 0 整数 num 存入数组 arr 中，并更新计数器 count。
//语法解析：
//arr[count]：表示数组 arr 的第 count 个下标位置（初始为 arr[0]）；
//count++：是 “后置自增” 操作，先使用 count 的当前值（如 0）完成赋值，再将 count 加 1（赋值后变为 1）；
//示例：第一次存入时 count=0，执行后 arr[0] = num，count 变为 1；第二次存入时 arr[1] = num，count 变为 2，以此类推。
//效果：实现 “输入一个非 0 数，就存入数组，同时记录存储个数”。
    }
    for(int i =count - 1;i>=0;i--){//count - 1（数组最后一个元素的下标，因为数组从 0 开始，存储了 count 个元素，最后一个元素下标是 count-1）
    //循环条件：i >= 0：只要 i 大于等于 0（未遍历到数组第一个元素 arr[0]），就继续循环；
    printf("%d",arr[i]);
    if(i>0){
        printf(" ");
    }
   
    }
     printf("\n");
    return 0;
}

左侧严格小于计数（一个数的左侧有几个数小于它）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>

int main() {
    int n;
    scanf("%d",&n);
    int a[100];
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);//若输入 5 1 2 3 4 5，则 n=5，循环执行 5 次，a[0]=1、a[1]=2、a[2]=3、a[3]=4、a[4]=5。
    }
    for(int i=0;i<n;i++){
        int count = 0;
        for(int j = 0;j<i;j++){
            if(a[j]<a[i]){
                count++;
            }
           
        }
         printf("%d",count);
            if(i<n-1){
                printf(" ");//作用：控制元素间的空格分隔，避免最后一个元素后多输出空格（符合常规输出格式）。
//逻辑：i < n - 1 表示 “当前元素不是最后一个元素”（因为最后一个元素的下标是 n-1），此时输出一个空格；最后一个元素不输出空格。
//示例：n=5 时，i=0~3 会输出空格，i=4（最后一个元素）不输出，最终结果格式为 0 1 2 3 4。
            }
    }
    printf("\n");
    return 0;
}

上端代码有个错误
为什么错了？

在 C 语言中，数组的索引是从 0 开始的。
你声明了 int a[100];，这意味着你可以安全访问的索引是 a[0], a[1], ..., a[99]。
在 for 循环中，你从 i = 1 开始，一直循环到 i = n。
当 n = 5 时，你会访问 a[1], a[2], a[3], a[4], a[5]。
问题来了：a[5] 是一个非法的索引！ 因为你的数组只有 100 个元素，最大合法索引是 99。访问 a[5] 会写入到不属于 a 数组的内存区域，这会导致：
    未定义行为 (Undefined Behavior)：程序可能崩溃、输出错误结果，或者看起来正常运行但实际上已经破坏了内存。
    在示例2中导致错误输出：输入 3 和 1 6 6，你的程序实际读取的是 a[1]=1, a[2]=6, a[3]=6。但在计算 b[3]（即 a[3] 左侧小于它的数）时，它会去检查 a[0], a[1], a[2]。然而，由于你没有初始化 a[0]，它的值是随机的（垃圾值）。如果这个垃圾值恰好小于 6，就会被错误地计入 count，导致最终输出错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>

int main() {
    int n;
    scanf("%d",&n);
    int a[100];
    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);//若输入 5 1 2 3 4 5，则 n=5，循环执行 5 次，a[0]=1、a[1]=2、a[2]=3、a[3]=4、a[4]=5。
    }
    for(int i=0;i<n;i++){
        int count = 0;
        for(int j = 0;j<i;j++){
            if(a[j]<a[i]){
                count++;
            }
           
        }
         printf("%d",count);
            if(i<n-1){
                printf(" ");//作用：控制元素间的空格分隔，避免最后一个元素后多输出空格（符合常规输出格式）。
//逻辑：i < n - 1 表示 “当前元素不是最后一个元素”（因为最后一个元素的下标是 n-1），此时输出一个空格；最后一个元素不输出空格。
//示例：n=5 时，i=0~3 会输出空格，i=4（最后一个元素）不输出，最终结果格式为 0 1 2 3 4。
            }
    }
    printf("\n");
    return 0;
}

一处错误 (ave = sum / n;)：

sum 是 long long，n 是 int。
sum / n 是一个整数除法！即使你把它赋值给 double ave，这个除法操作本身也是先进行整数运算，再将结果转换为 double。
例如，sum=5, n=2，sum/n 的结果是 2（整数除法），然后 ave 会变成 2.0，而不是正确的 2.5。
修正：必须强制转换其中一个操作数为 double，例如 double ave = (double)sum / n;。

long long max = INT_MIN, min = INT_MAX;
问题分析：

你声明了 max 和 min 为 long long 类型，这是正确的。
但你用 INT_MIN 和 INT_MAX 来初始化它们。INT_MIN 和 INT_MAX 是 int 类型的宏常量。
虽然 C 语言会将 int 自动转换为 long long，但这在逻辑上是不严谨的。更重要的是，INT_MIN 的值是 -2147483648，而 INT_MAX 的值是 2147483647。
如果数组中的所有元素都大于 INT_MAX（例如，全是 3000000000），那么 max 的初始值 INT_MIN 会小于所有元素，所以 max 最终会被正确更新为 3000000000。
但是，如果数组中的所有元素都小于 INT_MIN 呢？ 比如全是 -3000000000。由于 INT_MIN 是 -2147483648，它比 -3000000000 大，所以 if (max <= a[i1]) 这个条件永远不会成立，导致 max 一直保持为 INT_MIN，而不是真正的最大值 -3000000000。这会导致极差计算完全错误。
同理，对于 min，如果所有元素都大于 INT_MAX，也会出错。

printf(“%d”, count); // ❌ 这里使用了 count，但之前没有声明它
但在 for 循环内部，你虽然写了 int c = i % 10, count = 0;，但这行代码是在 while 循环内部的。

这意味着 count 变量的作用域（Scope）仅限于 while 循环内部。当 while 循环结束时，count 变量就“消失”了，不能再在循环外部访问。

✅ 解决方法

你需要将 count 变量的声明移到 for 循环内部、while 循环外部，这样它才能在 printf 中被访问。

计数问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>

int main() {
    int n,count=0;
    long long x;
    scanf("%d%lld",&n,&x);
    for(int i=0;i<=n;i++){//注意这里要算=n
        int temp=i;//注意保护循环变量
        //保护变量常用在循环嵌套时
        while(temp!=0){
        int c=temp%10;
        
        if(c==x){
            count++;
        }
        temp=temp/10;
        }
    }
    printf("%d",count);
    return 0;
}

约瑟夫环报数出队问题

1

函数返回值的类型是由函数定义时指定的类型决定的。例如，若函数定义为int func()，则无论return语句中表达式的类型如何，返回值最终都会被转换为int类型。
选项 B 错误，return语句中的表达式类型会被隐式转换为函数定义时指定的返回类型。

在 C 语言中，static 是一个存储类修饰符，用于改变变量的存储位置和生命周期，核心特点是「一次初始化、全程持久化」，且访问范围受定义位置限制。

一、static 变量的核心特性

1. 存储位置与生命周期

  • 普通局部变量（无 static）：存储在「栈区」，生命周期仅限于函数调用期间——函数进入时创建，函数返回时销毁，每次调用都会重新初始化。
  • static 变量（局部/全局）：存储在「静态数据区」，生命周期与程序一致——程序启动时分配内存，程序结束时才释放，仅在第一次初始化时赋值一次，后续调用/使用会保留上次的值。

2. 初始化规则

  • 若未显式赋值，会被编译器自动初始化为 0（普通局部变量未初始化时是随机垃圾值）。
  • 初始化表达式必须是「编译期常量」（如 static int a = 10; 合法，static int a = rand(); 非法，因为 rand() 是运行时结果）。

3. 访问范围（作用域）

  • static 局部变量：作用域仅限于定义它的函数/代码块内（和普通局部变量一样），但生命周期是全局的（保留值）。
  • static 全局变量：作用域仅限于当前源文件（.c 文件），其他源文件无法通过 extern 访问（普通全局变量默认是跨文件可见的）。

二、static 局部变量（最常用场景）

结合你之前代码中可能遇到的函数调用场景，用例子理解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>

int test() {
    // static 局部变量：仅第一次调用时初始化为 0，后续保留上次值
    static int count = 0; 
    count++; // 每次调用自增 1
    return count;
}

int main() {
    printf("%d\n", test()); // 第一次调用：count=0→1，输出 1
    printf("%d\n", test()); // 第二次调用：count=1→2，输出 2
    printf("%d\n", test()); // 第三次调用：count=2→3，输出 3
    return 0;
}
  • 输出结果：1 2 3
  • 关键：count 是 static 局部变量，第一次调用时初始化 count=0，之后每次调用都保留上次自增后的值，不会重新初始化。

如果去掉 static（普通局部变量）：

1
2
3
4
5
int test() {
    int count = 0; // 每次调用都重新初始化为 0
    count++;
    return count;
}
  • 输出结果：1 1 1（每次调用 count 都是新的 0，自增后为 1）。

三、static 全局变量（跨文件场景）

假设有两个源文件：a.c 和 b.c：

1. a.c（定义 static 全局变量）

1
static int num = 100; // static 全局变量：仅 a.c 可见

2. b.c（尝试访问 num）

1
2
3
4
5
extern int num; // 试图声明并访问 a.c 的 num
int main() {
    printf("%d\n", num); // 编译报错：未定义的引用（num 是 a.c 的 static 全局变量，b.c 不可见）
    return 0;
}
  • 作用：static 修饰全局变量时，用于「隐藏变量」，避免跨文件命名冲突（普通全局变量若多个文件同名，会导致链接错误）。

四、和你之前代码的关联

你之前的代码中没有使用 static 变量，但如果需要优化（比如减少重复计算），可以用 static 局部变量。例如，优化 IsSquare 函数（缓存常用平方数判断结果）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int IsSquare(int n) {
    if (n < 0) return 0;
    static int max_sqrt = 0; // 缓存已计算过的最大平方根
    static int max_square = 0; // 缓存对应的最大平方数
    // 若 n 小于已缓存的最大平方数，直接判断（简化逻辑，仅示例）
    if (n == max_square) return 1;
    // 继续原逻辑...
    int i = 1;
    int temp = n;
    while (temp > 0) {
        temp -= i;
        i += 2;
    }
    // 缓存结果
    if (temp == 0) {
        max_sqrt = (i-2)/2; // 平方数的平方根 = (最后一个奇数 - 1)/2
        max_square = n;
        return 1;
    }
    return 0;
}

这里 static 变量 max_sqrt 和 max_square 会保留上次计算的结果，避免重复计算相同的平方数判断。

总结 static 变量的核心记忆点

特性 static 局部变量 static 全局变量 普通局部变量 普通全局变量
存储位置 静态数据区 静态数据区 栈区 静态数据区
生命周期 程序全程 程序全程 函数调用期间 程序全程
初始化 默认 0，仅初始化一次 默认 0，仅初始化一次 随机值，每次调用初始化 默认 0，仅初始化一次
作用域 所在函数/代码块 所在源文件 所在函数/代码块 所有源文件（extern可见）

简单说：static 局部变量是「函数内的全局值」（保留状态），static 全局变量是「文件内的私有值」（隐藏跨文件访问）。

注意for,if,while有无花括号，没有就循环或判断一条代码

static就是可以保存函数里面的值，在再次调用时使用上一次调用保存下来的值
static int i = 0;：只在第一次调用函数时初始化为 0，之后的调用会保留上一次的值。
int s = 0;：每次调用函数时都会重置为 0。
循环条件是 i <= m，循环体是 s += i;，然后 i++。

若函数类型未显式说明，其隐含类型为int。例如，函数fun() { return 10; }会被默认视为返回int类型的函数。

函数调用中，实参的数量由逗号分隔的参数个数决定，与参数是否为表达式无关。在Func(exp1, exp2+exp3, exp4exp5)中，三个参数分别是exp1、exp2+exp3、exp4exp5，因此实参数量为 3

// 全局变量（整个程序可见）
int x = 5;
int y = 6;

// incxy() 函数：无参数，直接操作全局变量
void incxy() {
x++; // 直接访问全局变量x，自增
y++; // 直接访问全局变量y，自增
}

int main() {
int x = 3; // 局部变量x（仅main函数内可见）
incxy(); // 调用函数时无需传参，函数内部操作的是全局x、y
printf(“%d,%d”, x, y); // 输出局部x=3，全局y=7
return 0;
}

局变量x未显式初始化，默认值为0

#include <stdio.h>
int x; // 全局变量，初始值为 0（未显式初始化）
int f(); // 函数声明
int main(void)
{
int a = 1; // 局部变量 a，初始值为 1

x = a;       // 全局变量 x 被赋值为 1
a = f();     // 调用函数 f()，将返回值赋给局部变量 a

{            // 新的作用域块
    int b = 2;
    b = a + b;   // b = a + 2
    x = x + b;   // 全局变量 x = x + b
}

printf("%d %d", a, x);  // 输出 a 和 x
return 0;

}

int f()
{
int x = 4; // 局部变量 x（与全局 x 不同）
return x; // 返回 4
}

if (m % i == 0) return 0;
return 1;
若能则返回 0（不是质数），否则返回 1（是质数）。

int fun (int m)
{
int cur_digit, old_digit = 10;

if (m < 0){
    m = -m;
}
do{
    cur_digit = m % 10;
    if( cur_digit >= old_digit){
        return 0;
    }
    old_digit = cur_digit

;
m/=10

;
}while (m != 0);

return 1;

}
初始化值不是0或一的函数

res[idx++] = i; // 28. 把当前整数i存入结果数组，并更新索引
res[idx] = i：将 i 存入数组 res 的第 idx 个位置（比如 idx=0 时，存入 res[0]）。
idx++：存入后，idx 加 1（准备存储下一个符合条件的整数，比如下次存入 res[1]）。

整数的持续性

从任一给定的正整数 n 出发，将其每一位数字相乘，记得到的乘积为 n1​。以此类推，令 ni+1​ 为 ni​ 的各位数字的乘积，直到最后得到一个个位数 nm​，则 m 就称为 n 的持续性。例如 679 的持续性就是 5，因为我们从 679 开始，得到 6×7×9=378，随后得到 3×7×8=168、1×6×8=48、4×8=32，最后得到 3×2=6，一共用了 5 步。
本题就请你编写程序，找出任一给定区间内持续性最长的整数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include<stdio.h>
int getPersistence(long long n){
    int count=0;
    while(n>=10){
        long long product=1;
        long long temp = n;
        while(temp!=0){
            product*=temp%10;
            temp/=10;
        }
        n=product;
        count++;
    }
    return count;
}
int main(){
    long long a,b,i;
    scanf("%lld%lld",&a,&b);
    int maxPers=-1;
    int res[1000]={0};
    int idx=0;
    for(i=a;i<=b;i++){
        int pers=getPersistence(i);
        if(pers>maxPers){
            maxPers=pers;
            idx=0;
            res[idx++]=i;
        }else if(pers==maxPers){
            res[idx++]=i;
        }
    }
    printf("%d\n",maxPers);
       for(int j = 0; j < idx; j++){
        if(j == 0)
            printf("%lld", res[j]);
        else
            printf(" %lld", res[j]);
    }
    printf("\n");  // 最后换行
    
    return 0;
}

校门外的树

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
int main() {
    int L, M;
    scanf("%d %d", &L, &M);
    int tree[10001] = {0}; // 初始化所有树为存在，0表示存在，1表示移走
    for (int i = 0; i < M; i++) {
        int l, r;
        scanf("%d %d", &l, &r);
        for (int j = l; j <= r; j++) {
            tree[j] = 1; // 标记该区域内的树为移走
        }
    }
    int count = 0;
    for (int i = 0; i <= L; i++) {
        if (tree[i] == 0) {
            count++; // 统计剩余的树
        }
    }
    printf("%d\n", count);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdio.h>

int main() {
    int l,m;
    scanf("%d%d",&l,&m);
    int tree[100001]={0};//移除问题用0，1标记
    for(int i=0;i<m;i++){
        int a,b;
        scanf("%d%d",&a,&b);//循环嵌套，输入完两个就开始计算
        for(int j=a;j<=b;j++){//循环内的循环题参数要保持不同//这里写着写着j就变成i了
            tree[j]=1;//可以避免重复计算
        }
    }
    //在循环m次后再统计总数
    int count=0;
    for(int i=0;i<=l;i++){//这段代码在统计tree==0的数量时，只会计算 “0 到 L” 这个范围内的元素，并不会把tree[10001]数组的所有 10001 个元素都算进去
        if(tree[i]==0){
            count++;
        }
    }//并列循环可以引用相同参数
    printf("%d\n",count);
    return 0;
}

二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>

int main() {
    int m,n;
    long long num;
    scanf("%d%d",&m,&n);
    long long total=0;//直接放在两个循环外，可以记录二维数组所有元素之和
    for(int i=1;i<=n;i++){
        
        for(int j=0;j<m;j++){
            scanf("%lld",&num);
            total+=num;
        }
    
    }
    printf("%lld",total);
    return 0;
}

判断上三角矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>

int main() {
    int n;
    scanf("%d",&n);
    int matrix[10][10];//matrix:矩阵
    int isUpper=1;//标记是否为上三角矩阵，初始为是
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            scanf("%d",&matrix[i][j]);
            if(i>j&&matrix[i][j]!=0){//(i>j)是主对角线下方的元素
                isUpper=0;
                break;
            }
                if(!isUpper){break;}//如果已经确定 “不是上三角矩阵”，就直接跳出当前的外层循环，不用再继续判断了—— 本质是 “提前终止无效判断”，节省不必要的循环开销。
        }

    }
    printf("%s\n",isUpper?"YES":"NO");

    //先输入，再统一判断，因为是数组，会有序存储
    //为什么不把if判断直接放到第一个嵌套循环下，而是要重新写一个循环
    //问了发现可以

    return 0;
}

矩阵转置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>

int main() {
    int m, n;
    long long matrix[10][10];
    scanf("%d%d", &n, &m);

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%lld",&matrix[i][j]);
        }
    }//固定输入模板
    //开始输出转置
    for (int i = 0; i < m; i++) {//注意循环次数也会变
        for (int j = 0; j < n; j++) {    
            printf("%lld ",matrix[j][i]);//位置改变很容易，只需换中括号里面的数字即可
    
        }
        printf("\n");
    }
    return 0;
}

杨辉三角

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>

int main() {
    int n;
    long long m[34][34]={0};
    scanf("%d",&n);
    long long son=1,mum=1;
    for(int i=0;i<n;i++){
        m[i][0]=1;//每行第一个元素为1；
        m[i][i]=1;//每行最后一个元素为1；
        for(int j=1;j<i;j++){//如果引入数组的话，最好找多个数组之间的位置关系，不要找前后的数值关系或找表达通式
            m[i][j]=m[i-1][j-1]+m[i-1][j];//中间元素有上一行两个元素相加得到

        }
        //转换成功，开始输出
        for(int j=0;j<=i;j++){
            printf("%lld ",m[i][j]);
        }
        printf("\n");
    }
    return 0;
}

扫雷

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <stdio.h>
#define MAX 1005//定义宏为1005，作为矩阵的最大尺寸

int main() {
    int n,m;
    char grid[MAX][MAX];
    scanf("%d%d",&n,&m);
   
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            scanf(" %c",&grid[i][j]);
        }

    }//输入完毕，开始下一步
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){   //注意是j<m,已经连续打错两次了 
    if(grid[i][j]=='*'){
        printf("*");
    }else{
        int count=0;
        //一旦出现需要数数或统计时就引入计数器count=0，注意在for的外层，从0开始
        for(int dx=-1;dx<=1;dx++){
            for(int dy=-1;dy<=1;dy++){//dx，dy相当于步长
                int x=i+dx;//x，y相当于跨一步后的坐标，i，j是原坐标
                int y=j+dy;
                if(x>=0&&x<n&&y>=0&&y<m){
                    //边界判断，避免数组越界
                    if(grid[x][y]=='*'){//注意符号用‘’包裹
                    //开始统计雷的数量
                    count++;}
                }
            }
            //遍历当前格子的八个方向
        }

         
       printf("%d",count);
    }

        }
            printf("\n");
    }
    return 0;
}

替换工具

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>

int main() {
    char s[1000001];
    scanf("%s",&s);
    for(int i=0;s[i]!='\0';i++){
        if(s[i]=='5'){
            s[i]='*';
        }
    }
    printf("%s\n",s);
    return 0;
}

strcmp 函数: 这是 C 语言中用于比较两个字符串是否相等的函数。如果两个字符串相等，它返回 0。

比如数组 digit 存了 3 个元素 [‘3’,‘2’,‘1’]，它们的索引分别是 0（存 ‘3’）、1（存 ‘2’）、2（存 ‘1’）。也就是说：数组的 “最后一个有效元素的索引” = 有效元素个数 - 1。

添加逗号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
#include<string.h>
int main() {
    long long n;
    scanf("%lld",&n);
    if(n==0){
        printf("%lld\n",n);
        return 0;
    }
    char digit[20];//存储各位数字
    int len=0;//与长度有关就设置长度记录器
    while(n!=0){
        digit[len++]=n%10+'0';//提取n的最低位数字，并将其转换为对应的字符形式，存入digit中，并更新数组有效长度索引
        n/=10;

    }
    //输入模板准备完毕，开始输出
    for(int i=len-1;i>=0;i--){
        printf("%c",digit[i]);
        if(i%3==0&&i!=0){//每三位插入逗号，且不是最后一位//这里可以直接if判断后print打出，因为不会改变顺序
            printf(",");
        }
    }
printf("\n");
    return 0;
}

查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <string.h>//用到了strlen函数
#include <ctype.h>//用到了tolower函数
int main() {
    char s[101];
    scanf("%s",&s);
    int len=strlen(s);//计算s的有效长度
    for(int i=0;i<=len-3;i++){//如果len=8，那么要检查5次就可以全部遍历是否有bob//可选，多差几次不会报错
        if(tolower(s[i])=='b'&&tolower(s[i+1])=='o'&&tolower(s[i+2])=='b'){//不区分大小写
            printf("%d\n",i);
            return 0;
        }
    }
    printf("-1\n");
    return 0;
}

scanf(“%s”, s) 是「读整串不含空白的字符」，getchar() 是「读单个字符（包括空白字符）」

凯撒密码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <string.h>
int main(){
    int n;
    scanf("%d",&n);
    char s[1001];
    scanf("%s",&s);
    int len=strlen(s);//注意不要在变量上加双引号
    for(int i=0;i<len;i++){//c语言中字符的本质是ascll码（'a'=97）//注意这里不能是i=1和<=
        s[i]=(s[i]-'a'+n)%26+'a';//利用 'a' 的 ASCII 码（97）作为基准，将小写字母映射到 0-25 的连续整数（a=0、b=1、…、z=25），方便后续计算移位
    }
    printf("%s\n",s);
    return 0;
}

阶乘计算cos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include<stdio.h>
#include<math.h>

double funcos(double e, double x);

int main(){
        double e,x;

        scanf("%lf %lf",&e,&x);
        printf("cos(%.2f)=%.6f\n",x,funcos(e,x));

        return 0;
}    
double funcos(double e,double x){
    double term=1.0;//循环前先初始化第一项//这是第一项的值
    double result=term;//这是最终结果，目前初始化为第一项
    int count =0;
    double numerator = 1.0;
    double denominator=1.0;
    int sign=1;

    while(term>=e||term<=-e){  //实现最后一项的绝对值小于e
        count+=2; //每一项次数加2，阶乘加2
        sign=-sign;  //从第二项开始递推，这里把第一项的值全部赋成第二项的值，然后推广到第n+1项
        numerator*=x*x;  //分子是每项多 乘 个x平方//乘就在等号左边加星号表示累乘，等号右边是变化的项
        denominator*=(count-1)*count;  //实现n！
        term=sign*numerator/denominator;
        result+=term;
    }

    return result;
}

理解函数接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<stdio.h>
int CountDigit(int number,int digit);//声明一个函数
int main(){
    int number,digit;

    scanf("%d %d",&number,&digit);
    printf("Number of digit %d in %d:%d\n",digit,number,CountDigit(number,digit));//带入前面main里面声明的值

    return 0;
}
int CountDigit(int number,int digit){//在新的函数中重新声明两个变量，方便后续使用
    int count=0;
    if(number==0&&digit==0){
        return 1;
    }
    number<0?-number:number;
    while(number>0){
        int n=number%10;
        if(n==digit){
            count++;
        }
        number/=10;
    }
    return count;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <stdio.h>

int fib( int n );
void PrintFN( int m, int n );
    
int main()
{
    int m, n, t;

    scanf("%d %d %d", &m, &n, &t);
    printf("fib(%d) = %d\n", t, fib(t));
    PrintFN(m, n);

    return 0;
}

int fib(int n){
    if(n==1||n==2){
        return 1;
    }
    int i,a=1,b=1,res=0;//初始化第一项，第二项和第n（3）项的值
    for(i=3;i<=n;i++){//初始化到哪一项就从其后一项开始循环
        res=a+b;//直接开始计算第三项
        a=b;
        b=res;//完成递增
    }
    return res;
}
void PrintFN(int m,int n){
    int count=0;
    int i=1;//初始化第一项，从第一项开始查找
    while(1){//无限循环
        int f=fib(i);//赋值调用函数
        if(f>n){
            break;//直接结束当前while循环
        }
        if(f>m&&f<=n){
            if(count>0){
                printf(" ");//如果判断成功，输出数字前先判断一下格式，第二个位置应该是空格
            }
            printf("%d",f);
            count++;
        }

        i++;
    }
    if(count==0){
        printf("No Fibonacci number");
    }
    printf("\n");
}

数组名tab是地址常量，不能直接赋值

二维数组的下标从 0 开始，所以数组中[2][3]其实是第三行第字符串"China"包含 5 个字符（‘C’、‘h’、‘i’、‘n’、‘a’），加上自动添加的'\0'，共 6 个字符；

不要算上双引号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<stdio.h>
int main(){
    int n,m;
    scanf("%d %d",&n,&m);

    int grid[100][100] = {0};
    for(int k=0;k<m;k++){
        int x1,y1,x2,y2;
        scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
        x1--;
        y1--;
        x2--;
        y2--;
        for(int i=x1;i<=x2;i++){
            for(int j=y1;j<=y2;j++){
                grid[i][j]++;
            }
        }
    }
for(int i=0;i<n;i++){
    for(int j=0;j<n;j++){
        printf("%d",grid[i][j]);
    }
    printf("\n");

}
return 0;
}
1
2
3
4
5
6
7
8
9
5 3
1 1 3 3
2 2 4 4
1 2 2 4
12210
13320
12210
01110
00000

简化的插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include<stdio.h>
int main(){
    int n,i,j,k,f;
    scanf("%d",&n);
    int arr[10];
    for(i=0;i<n;i++){
        scanf("%d",&arr[i]);
    }//通过数组连续输入数字
    int x;
    scanf("%d",&x);
    int pos=n;//和位置有关，循环前标志位置
    for(j=0;j<n;j++){
        if(arr[j]>x){
            pos=j;//判断并标记位置
            break;
        }
    }
    //开始插入·新加的数字
    for(k=0;k<pos;k++){
        printf("%d ",arr[k]);
        
    }
    printf("%d ",x);//新思路，要想插入直接检索出要插入的位置，然后把循环打印根据标记好的插入位置分成两半
    for(f=pos;f<n;f++){
        printf("%d ",arr[f]);
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <stdio.h>
#define MAX_SIZE 20

int isInArray(int num,int arr[],int len){//判断元素是否是共有元素

    int i;    
    for(i=0;i<len;i++){//循环元素的个数次
        if(arr[i]==num){
            return 1;
        }//这段是固定模板，为遍历读取数组中每个数字
    }//并且检查一个数字num是否在目标数组中
    return 0;
}
int isDuplicate(int num,int res[],int reslen){//判断元素是否已经再结果中重复
    int k;
    for(k=0;k<reslen;k++){
        if(res[k]==num){
            return 1;
        }
    }
    return 0;
}
int main(){
    int n1,n2;
    int arr1[MAX_SIZE],arr2[MAX_SIZE];//不用赋值，因为后面scanf会赋给它输入的值
    //确保每个声明的变量在最后等号右面都有值
    int result[40];//存储非公有元素，最大为两个数组长度之和
    int reslen = 0;

    scanf("%d",&n1);
    int i,j,k;
    for(i=0;i<n1;i++){
        scanf("%d",&arr1[i]);
    }

    scanf("%d",&n2);

    for(k=0;k<n2;k++){
        scanf("%d",&arr2[k]);
    }


    for (k=0;k<n1;k++){
        if(!isInArray(arr1[k],arr2,n2) && !isDuplicate(arr1[k],result,reslen) ){//Duplicate：重复
//注意定义函数的时候第一个是数字，第二个是数组，相当于把整个数组都打包输入了
//也就是说从第一个数组中找出不在第二个数组中，并且在第一个数组中找出不在结果数组中的数·
            result[reslen++]=arr1[k];//先加入结果，然后有效长度加一
            //筛选提取模板
        }
    }

    // 处理第二个数组：找出不在第一个数组中的元素（去重）
    for (j = 0; j < n2; j++) {
    if (!isInArray(arr2[j], arr1, n1) && !isDuplicate(arr2[j], result, reslen)) {
        result[reslen++] = arr2[j]; // 加入结果，有效长度+1
    }
}
    int l;
// 输出结果（行末无多余空格）
for (l = 0; i < reslen; i++) {
    if (i > 0) { // 不是第一个元素，先输出空格
        printf(" ");
    }
    printf("%d", result[i])
    }
}


发现没排序，改进版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>
#define MAX_SIZE 20

int isInArray(int num, int arr[], int len) {
    int i;
    for (i = 0; i < len; i++) {
        if (arr[i] == num) {
            return 1;
        }
    }
    return 0;
}

int isDuplicate(int num, int res[], int reslen) {
    int k;
    for (k = 0; k < reslen; k++) {
        if (res[k] == num) {
            return 1;
        }
    }
    return 0;
}

// 简单冒泡排序（升序）
void sortArray(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int n1, n2;
    int arr1[MAX_SIZE], arr2[MAX_SIZE];
    int result[40];
    int reslen = 0;
    int i, j, k;

    // 读入第一个数组
    scanf("%d", &n1);
    for (i = 0; i < n1; i++) {
        scanf("%d", &arr1[i]);
    }

    // 读入第二个数组
    scanf("%d", &n2);
    for (k = 0; k < n2; k++) {
        scanf("%d", &arr2[k]);
    }

    // 从 arr1 中找不在 arr2 的元素（去重）
    for (k = 0; k < n1; k++) {
        if (!isInArray(arr1[k], arr2, n2) && !isDuplicate(arr1[k], result, reslen)) {
            result[reslen++] = arr1[k];
        }
    }

    // 从 arr2 中找不在 arr1 的元素（去重）
    for (j = 0; j < n2; j++) {
        if (!isInArray(arr2[j], arr1, n1) && !isDuplicate(arr2[j], result, reslen)) {
            result[reslen++] = arr2[j];
        }
    }

    // ✅ 关键修复：对结果数组排序（升序）
    sortArray(result, reslen);

    // 输出结果（行末无多余空格）
    for (i = 0; i < reslen; i++) {
        if (i > 0) {
            printf(" ");
        }
        printf("%d", result[i]);
    }

    return 0;
}

寻找鞍点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include<stdio.h>

int main(){
//声明变量准备
    int n;
    scanf("%d",&n);
    int m[6][6];//二维矩阵，所以设置二维数组
    
//双层循环开始读入
    int i,j;
    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            scanf("%d",&m[i][j]);
        }
    }
//找到每一行的最大值
    for(int i=0;i<n;i++){
        int row_max = m[i][0];//遍历每一行
        //row_max代表每一行的第一个数
        for(int j = 1;j<n;j++){
            //假设i=0，表示从第一行的第二个数字开始循环
            if(m[i][j]>row_max){
                row_max=m[i][j];
            }
        }
        //找到每一行的最大值的方法：挑取第一个数字作为基准，从第二个数字开始比较
        //检查该行中每个row_max的元素
        for(int j = 0;j<n;j++){
            if(m[i][j] == row_max){
                int col_min=m[0][j];
                    //检查是否是第j列的最小值
                    for(int k=1;k<n;k++){
                        if(m[k][j]<col_min){
                            col_min = m[k][j];
                        }
                    }
                if(m[i][j]==col_min){
                    printf("%d %d",i ,j);
                    return 0;
                }
            }
        }
    }
    //如果没有找到暗点
    printf("NONE\n");
    return 0;
}

螺旋方阵

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include<stdio.h>
//注意如果定义二维数组，那么数字在平面中的位置就可以任意更改
//这时候不要一心想着从左到右从上到下输出，要通过循环和边界值的设置改变数组中括号里面的值，即改变他们的输出位置
int main(){
    int n;
    scanf("%d",&n);
    int m[10][10]={0};//由于只输入一个n，所以给所有数组初始化变量
    int num = 1;
    //定义要填入的第一个数字
    int top =0,bottom=n-1;
    int left =0,right=n-1;
    //初始化四个边界，因为数组是从零开始递增的，所以边界固定模板就是n-1；

    //开始填充
    while(num <= n* n){
    for(int j=left;j<=right&&num<=n*n;j++){
        //从左到右填充top行
        m[top][j]=num++;//注意如果填充一行的数字，那么他的坐标变量是列，边界值也是列
        
    }
    top++;//填完这一行后，上边界下移一行，下一次不在填写这一行

    for(int i=top;i<=bottom&&num<=n*n;i++){
        //以及top++了，所以从第二行最后一个数字开始填写，从上往下
        m[i][right]=num++;//num和i同时递增，记为模板
        
    }
    right--;//每填完一列，对应边界向内收缩，这里数据化为加和减
    for(int j=right;j>=left&&num<=n*n;j--){
        //总结模板：从左到右从上到下就是加，逆序就是减
        m[bottom][j]=num++;
        
    }
    bottom--;
    for(int i=bottom;i>=top&&num<=n*n;i--){
        //注意循环是减号的时候边界和比较大小的方向也变了
        m[i][left]=num++;
    }
    left++;
}
    //开始输出
    for(int i=0;i<n;i++){
        //i的作用范围在for循环的大括号里，并列循环关系可以随便声明
        for(int j=0;j<n;j++){
            printf("%3d",m[i][j]);
            //printf("%3d", ...)：每个数字占 3 个字符宽度，右对齐
        }
        printf("\n");
    }
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include<ctype.h>//引入字符处理头文件（toupper,isalpha）
int main() {
    char ch;//声明字符型变量ch，用于存储每次读取的字符
    int is_first = 1;//是单词的首字母
    while((ch=getchar()) !=EOF){
        //getchar从标准输入读取一个字符，并返回该字符的ascll值
        //EOF表示输入结束
        if(is_first && isalpha(ch)){
            //isalpha 判断ch是否为字母，是就返回1
            putchar(toupper(ch));
            //putchar将传入的字符输出到标准输出
            //标准输出就是屏幕
            //标准输入就是键盘
            is_first = 0;
            //一旦找到并输出了单词首字母，就将判断设为零

        }else if(ch ==' '){
            is_first=1;
            //遇到空格后，下一个单词是首字母
        }
    }

    return 0;
}

为什么这里不用 getchar？

getchar() 的核心作用是「逐个读取单个字符」（包括空格、回车、制表符等空白字符），而我们的场景是「读取完整的选项字符串（无空格）」，用 scanf("%s") 更适配，具体原因分 3 点：

1. 需求匹配：scanf("%s") 天生适配 “无空格字符串” 读取

题目中每个选项是单个连续字符串（比如 "apple" "banana"），没有空格 / 回车分隔（输入时选项之间用空格 / 回车分隔）：

  • scanf("%s") 会自动跳过前置空白字符（空格、回车、制表符），读取到下一个空白字符为止，正好能 “精准读取单个选项字符串”；
  • 而 getchar() 是逐字符读，如果用它读取字符串，需要手动循环读字符、手动判断终止（遇到空白字符停止）、手动加 \0，代码会更繁琐。

比如用 getchar 实现读取一个选项的逻辑：

c

1
2
3
4
5
6
7
8
9
10
11
// 用getchar读取单个选项（替代scanf("%s", s[i])）
int j = 0;
char c;
// 跳过前置空白字符（比如上一个输入的回车/空格）
while ((c = getchar()) == ' ' || c == '\n');
// 读取有效字符直到遇到空白
while (c != ' ' && c != '\n' && j < 600) {
    s[i][j++] = c;
    c = getchar();
}
s[i][j] = '\0'; // 手动加字符串结束符

对比 scanf("%s", s[i])，代码简洁度差很多，完全没必要。

2. 避免 getchar 的 “残留字符坑”

如果混用 scanf（读数字 / 字符串）和 getchar，很容易遇到「缓冲区残留换行符」的问题：

比如先执行 scanf("%d", &T) 读取题目数量，输入 3 后按回车，缓冲区会残留 \n；如果紧接着用 getchar 读选项，第一个读到的会是 \n，而非选项字符，需要额外处理（比如手动清空缓冲区）。

而 scanf("%s", s[i]) 会自动跳过这些残留的空白字符，无需额外处理，更适合本题的输入流程。

3. 二维数组场景下，getchar 无优势

本题中二维数组的每个一维数组（s[0]/s[1]等）是独立的字符串存储区，scanf("%s") 能直接把字符串写入对应区域；而 getchar 只能逐字符写入，需要手动管理每个字符的下标，增加代码复杂度。

三、补充：scanf("%s") 的注意事项（为什么数组长度设为 601）

scanf("%s") 读取字符串时，会自动在末尾添加 \0（字符串结束符），因此：

  • 如果题目要求选项字符串最长 600 个字符，数组长度需要设为 601（600 个有效字符 + 1 个 \0），避免缓冲区溢出。

总结

问题 答案
二维数组为何不用 & s[i] 是一维数组名，本身就是地址，等价于 &s[i][0]，符合 scanf 要求
为什么不用 getchar 1. scanf (“% s”) 适配 “无空格字符串”，代码更简洁；2. 自动跳过空白字符，避免缓冲区坑；3. getchar 需手动循环 / 加 \0，无优势

简单来说：本题的输入场景（读取无空格的独立字符串）是 scanf("%s") 的 “最优解场景”，而 getchar 更适合「逐字符处理」「读取含空格的输入」等场景，因此这里完全不需要用 getchar。

一维字符数组（对应题目中 s[i]）

1
2
// 定义一维数组：存储"apple"（末尾自动加\0，共6个字符）
char str[10] = "apple";
  • str 是数组名，它等价于 &str[0]（str[0] 是数组第一个元素 'a'，&str[0] 是 'a' 的内存地址）；

考试口诀应用答案生成器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include <stdio.h>
#include<string.h>//提供strlen函数的声明
int main() {
    int t;
    scanf("%d", &t);
    while (t--) { //后置递减，先判断t是否大于0，再将t减一
        char s[4][601];//要读入四个字符串
        int len[4];//要计算字符串的长度，提前定义四个数组
        for (int i = 0; i < 4; i++) {
            scanf("%s",
                  s[i]); //只读取字符串，不读取空格，所已用scanf，不用getchar
            //s[i]相当于s[i][0]
            len[i] = strlen(s[i]);
        }

    //以上全是输入部分，以下开始比较
    int min_len = len[0], max_len =
                      len[0]; //以第一项作为标准，开始比较
    int min_cnt = 1, max_cnt = 1; //最小长度和最大长度出现次数
    for (int i = 1; i < 4; i++) {
        if (len[i] < min_len) {
            min_len = len[i];
            min_cnt = 1;
        } else if (len[i] == min_len) {
            min_cnt++;//选取最大数模板
        }
        if (len[i] > max_len) {
            max_len = len[i];
            max_cnt = 1;
        } else if (len[i] == max_len) {
            max_cnt++;
        }
    }

    //比较的是长度模块，但是没有记录对应字符串的数组次序，所以下面要根据长度检索数组
    char ans;//声明字符变量，存储要输出的ABCD
    if (min_cnt == 1 && max_cnt != 1) { //判断三场一段
        for (int i = 0; i < 4; i++) {
            if (len[i] == min_len) {
                ans = 'A' + i;
                break;
            }
        }
    }
     // 判断三短一长（max_cnt=1，min_cnt≠1）
        else if (max_cnt == 1 && min_cnt != 1) {
            for (int i = 0; i < 4; i++) {
                if (len[i] == max_len) {
                    ans = 'A' + i;
                    break;
                }
            }
        }
        // 参差不齐
        else {
            ans = 'C';
        }
        printf("%c\n", ans);
    }
return 0;
}

int l, r;直接在循环里面声明不会导致被覆盖吗，不用在循环外面用这种形式int l[100],r[100],c1[100],c2[100];声明吗

每次循环迭代都会重新创建局部变量，用完即销毁，不存在 “覆盖导致逻辑错误” 的问题。

1. 变量的 “作用域” 和 “生命周期” 是关键

  • 作用域：循环内声明的l、r、c1、c2，作用域仅限于当前这一次循环迭代（花括号{}内部）；
  • 生命周期：变量从本次迭代开始时创建，迭代结束时销毁（内存被释放）。

举个例子：

1
2
3
4
5
for (int i = 0; i < 2; i++) {
    int l, r; // 第1次循环：创建l1、r1；第2次循环：销毁l1/r1，再创建l2/r2
    scanf("%d %d", &l, &r);
    // 处理本次的l、r
}
  • 第 1 次循环：读取的l、r是 “本轮专属” 的变量，处理完就销毁；
  • 第 2 次循环：会重新创建一组全新的l、r，和上一轮的变量毫无关系，不存在 “覆盖上一轮值” 的问题（因为上一轮的变量已经没了）；
  • 我们的需求是 “读取一次操作参数，立即处理，处理完不需要留存”，所以根本不需要把所有操作的l、r都存起来。

2. 反过来说：循环内声明的优势

  • 节省内存：每次只用 4 个字节（int l/r）+ 2 个字节（char c1/c2），用完就释放；如果用数组存 100 个操作的参数，哪怕只执行 2 次操作，也会占用 100 组参数的内存，完全浪费；
  • 逻辑清晰：变量只在需要的时候创建，避免 “全局 / 外部变量被意外修改” 的风险；
  • 代码简洁：不需要额外维护数组下标（比如l[i]），直接用变量名即可，减少出错概率。

读取一次操作参数 → 立即执行替换 → 丢弃本次参数 → 处理下一次，全程不需要留存任何操作的参数，因此用数组存储完全是 “画蛇添足”。

三、对比两种写法的差异（更直观）

写法 适用场景 内存占用 逻辑复杂度
循环内声明 l、r、c1、c2 读取一次处理一次，无需留存参数 极小 低
数组 l [100]、r [100] 等 需要留存所有操作参数（验证 / 回显 较大 高，需要下标

要加下标的情况是

场景 1：先读取所有操作参数，验证合法性后，再统一执行替换

先把所有m次操作的参数全读进来存好 → 逐个检查参数是否合法 → 若全部合法，再执行所有替换；若有非法参数，直接报错，不执行任何替换。

举个具体例子

假设题目新增要求：

输入的操作参数必须满足 1≤l≤r≤n，否则判定为非法操作，直接输出 “error”，不修改原字符串。

这种情况下，必须先把所有操作参数存起来验证，而不能读一个执行一个 —— 比如：

  • 输入：n=5，m=2，字符串abcde
  • 操作 1：l=2, r=4, c1=b, c2=B（合法）
  • 操作 2：l=6, r=8, c1=d, c2=D（非法，因为 n=5，l=6 超出范围）

如果不存参数，直接执行：

  • 先执行操作 1，把abcde改成aBcde；
  • 再读操作 2，发现非法，此时字符串已经被改乱，无法恢复。

如果用数组存参数，就能先验证再执行：

  1. 把操作 1、操作 2 的参数全存到数组里；
  2. 检查操作 2 的 l=6>5，判定非法，直接输出 “error”，原字符串abcde完全没被修改。

场景 2：执行完所有替换后，回显所有操作的参数

为什么需要留存参数？

如果题目要求 “输出最终字符串的同时，列出所有执行过的操作”，比如：

输出格式：

最终字符串：gaaak

第 1 次操作：l=1, r=3, c1=g, c2=a

第 2 次操作：l=4, r=5, c1=k, c2=k

这种情况下，必须留存所有操作的参数—— 因为操作执行完后，原本读取的 l、r、c1、c2 已经被下一次循环的变量覆盖（如果是循环内声明的局部变量，甚至已经销毁），只有存在数组里，才能在最后遍历数组回显。

格式字符串中的空白字符作用

格式字符串里的空格、换行、制表符，会被scanf统一处理为：匹配输入流中任意数量的空白字符（0 个或多个）。

比如：

  • "%d %d %c %c" 和 "%d\n%d\t%c %c" 效果完全一样；

  • 但如果格式字符串是

    1
    "%d%d%c%c"

    （无空格），输入

    1
    2 5 a b

    时：

    • 第一个%d读2，第二个%d跳过空格读5（因为%d自动跳空白）；
    • 第一个%c会读5后的空格（而非a），第二个%c读a，导致结果错误。

坑 1：%c读取到空白字符

比如输入：

1
2
2 5
a b

执行scanf("%d %d %c %c", &l, &r, &c1, &c2);时：

  • %d读2，第二个%d跳过空格读5，然后格式字符串的空格匹配5后的换行符；
  • 但如果格式字符串是"%d %d%c %c"（少一个空格），%c会读取5后的换行符，而非a。

解决办法：

  • 方法 1：在%c前加空格，强制跳过空白："%d %d %c %c"（推荐）；

  • 方法 2：手动跳过空白，比如用

    1
    getchar()

    吃掉换行：

    1
    2
    3
    scanf("%d %d", &l, &r);
    getchar(); // 吃掉换行符
    scanf("%c %c", &c1, &c2);

坑 2：输入字符时包含特殊符号

比如输入2 5 a-b，第二个%c会读取-而非b，因为%c只读取单个字符，遇到非空白就停止。

替换字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>

int main() {
    int n,m;
    scanf("%d %d",&n,&m);
    char s[101];
    scanf("%s",s);//要读取字符串都用这个模板
    
    for(int i=0;i<m;i++){
        int l,r;
        char c1,c2;
        scanf("%d %d %c %c",&l,&r,&c1,&c2);
        for(int j=l-1;j<=r-1;j++){//挑取区间模板//替换字符串模板
            if(s[j]==c1){
                s[j]=c2;
            }
        
        }
    }
    printf("%s\n",s);
    return 0;
}

float 和double的区别

一、核心区别汇总表

特性 float（单精度） double（双精度）
内存占用 4 字节（32 位） 8 字节（64 位）
有效数字位数 6~7 位十进制有效数字 15~17 位十进制有效数字
取值范围 ±1.4×10⁻⁴⁵ ~ ±3.4×10³⁸ ±4.9×10⁻³²⁴ ~ ±1.8×10³⁰⁸
存储格式（IEEE 754） 符号位 (1) + 指数位 (8) + 尾数位 (23) 符号位 (1) + 指数位 (11) + 尾数位 (52)
运算速度 更快（硬件支持更基础） 稍慢（精度高，计算量略大）
默认浮点常量类型 不默认（如3.14是 double） 默认（3.14f才是 float）
适用场景 内存受限、精度要求低（如简单图形、传感器数据） 精度要求高（如科学计算、金融、工程计算）

二、关键特性通俗解释

1. 有效数字：最核心的差异（避坑重点）

“有效数字” 指能准确表示的数字位数，超出部分会被舍入（不是精确值）：

  • 1
    float

    ：只能精确到 6~7 位十进制数。

    例：

    1
    float f = 123456789.0f;

    → 实际存储的是近似值（因为 8 位有效数字超出了 float 的精度）；

  • 1
    double

    ：能精确到 15~17 位十进制数。

    例：

    1
    double d = 123456789012345.0;

    → 完全精确，无舍入误差。

2. 存储格式（IEEE 754 标准）

浮点型不是 “直接存储十进制数”，而是按 “符号 + 指数 + 尾数” 的科学计数法存储：

  • float：8 位指数位（能表示的指数范围更小）+ 23 位尾数位（精度低）；
  • double：11 位指数位（指数范围大）+ 52 位尾数位（精度高）。

简单理解：尾数位越多，精度越高；指数位越多，能表示的数的范围越大。

3. 浮点常量的默认类型

C 语言中，直接写的浮点常量（如3.14、10.0）默认是double类型；如果要表示float，必须加后缀f/F（如3.14f、10.0F）。

例：

1
2
float f = 3.14; // 实际是double转float，有微小精度损失
float f = 3.14f; // 直接存float，无转换损失

4. 运算精度与速度

  • 精度：double > float（几乎所有场景下，double 的精度都能满足需求）；
  • 速度：现代 CPU 对double的运算优化已很好，两者速度差异极小（仅在嵌入式 / 极端性能场景下需考虑 float）。

三、实战选择建议

  1. 优先用

    1
    double

    除非明确限制内存（如嵌入式系统中大量存储浮点数据），否则默认选

    1
    double

    —— 精度更高，且几乎无性能代价，能避免绝大多数精度问题；

  2. 用

    1
    float

    的场景：

    • 内存紧张（如数组存 100 万个浮点数据，float 比 double 省一半内存）；
    • 硬件接口要求（如某些传感器输出 float 类型数据）；

  3. 避坑点：

    不要用浮点型存储 “需要精确值” 的场景（如金额），改用整数（如以分为单位存储金额），因为浮点型本身是近似存储（比如

    1
    0.1

    无法用二进制浮点精确表示）。

const 是一个类型限定符（Type Qualifier），核心作用是限定变量 / 指针 / 函数参数等为 “只读”，即被const修饰的对象，其值 / 指向的内容不能被直接修改（编译阶段会检查，修改则报错）。

while(n--)的核心问题：“先判断后减 1，且乘法用了减 1 后的值”

T=6时，循环执行 6 次，对应 6 组输入。

n--是后置自减运算符，规则是：

  1. 先使用n的 “原值” 判断循环条件（是否≠0）；
  2. 再将n的值减 1；
  3. 进入循环体后，使用的是减 1 后的 n 值。

对应阶乘计算，问题体现在两点：

1. 丢失了初始的n值（最大的乘数）

比如输入n=5，循环中第一次乘法用的是4，而非5—— 直接漏掉了阶乘中最关键的 “初始 n”，导致计算的是4×3×2×1×0（而非5×4×3×2×1）。

2. 多乘了一个0，直接让结果归 0

当n减到 1 时：

  • 循环条件n--判断为真（1≠0），n先减 1 变成 0；
  • 循环体执行jie *= 0，结果直接变成 0，后续所有乘法都无法恢复。

取模const

1
2
3
4
5
6
7
8
9
int factorialOfN(int n ) {
    // write code here
    const int MOD=1000000007;
    long long jie=1;
    for(int i=1;i<=n;i++){
        jie=(jie*i) % MOD;//边乘边取模
    }
    return (int)jie;
}

C 语言不允许double与const int直接进行取模运算（取模%要求操作数为整数类型）；

一开始password不是字符指针吗，为什么for循环的时候可以转化成数组

要理解 “字符指针password能像数组一样用password[i]访问”，核心是搞清楚C 语言中数组和指针的底层等价性—— 数组下标访问本质是 “指针 + 偏移” 的语法糖，两者在内存层面完全互通。下面分三步讲透：

一、先明确：char* password的本质

题目中传入的password虽然声明为 “字符指针”，但它指向的是一段连续的字符内存（字符串数组）的起始地址：

  • 比如传入字符串

    1
    "abcd"

    ，内存布局是：

    内存地址（示例） 0x100 0x101 0x102 0x103 0x104
    存储内容 ‘a’ ‘b’ ‘c’ ‘d’ ‘\0’

  • password作为指针，存储的是起始地址0x100（即第一个字符 ‘a’ 的地址）。

二、password[i]的底层原理：下标访问 = 指针 + 偏移

C 语言规定：数组下标访问arr[i]等价于\*(arr + i)（指针解引用），不管arr是数组名还是字符指针。

拆解password[i]的计算过程：

  1. password是指针（存起始地址，比如0x100）；
  2. i是偏移量（单位：字节，字符占 1 字节）；
  3. password + i = 起始地址 + i 个字节 → 指向第 i 个字符的地址；
  4. *(password + i) = 解引用该地址，拿到对应字符；
  5. password[i]是*(password + i)的 “语法糖”（简化写法）。

示例（password="abcd"）：

  • password[0] = *(password + 0) = 取0x100地址的字符 → ‘a’；
  • password[1] = *(password + 1) = 取0x101地址的字符 → ‘b’；
  • password[3] = *(password + 3) = 取0x103地址的字符 → ‘d’。

password[i] - 'a'的计算过程（逐字符拆解）

假设password[i]是某个小写字母（比如 ‘a’、‘m’、‘z’），我们分情况计算：

情况 1：password[i] = 'a'（对应第一个小写字母）

1
password[i] - 'a' = 'a' - 'a' = 97 - 97 = 0

→ 映射结果：0（对应第一个位置）

情况 2：password[i] = 'm'（中间字母）

1
password[i] - 'a' = 'm' - 'a' = 109 - 97 = 12

→ 映射结果：12（a 是 0，b 是 1…m 是第 13 个字母，对应 12）

情况 3：password[i] = 'z'（最后一个小写字母）

1
password[i] - 'a' = 'z' - 'a' = 122 - 97 = 25

→ 映射结果：25（对应最后一个位置）

通用规律

对任意小写字母c（a≤c≤z），c - 'a'的结果 = 该字母在 26 个小写字母中的 “序号 - 1”（a 是第 1 个→0，b 第 2 个→1…z 第 26 个→25），最终结果刚好落在0~25范围内。

a确实是最小的小写字母，但offset依然会变成负数，核心原因是：解密时要对a做 “向前移位” 操作（比如a向前移 1 位），此时0 - n就会得到负数。

1
2
3
4
5
6
7
8
9
10
11
12
char* decodeWangzai(char* password, int n ) {//字符指针char*,c语言中字符串要么是数组要么是字符指针
    // write code here
    for(int i=0;password[i]!='\0';++i){
        //如果不到末尾就一直循环
        int offset = (password[i]-'a'-n)%26;//password[i]-'a'转换为ascll码值//C 语言中没有单独的 “字符类型”，char类型本质是1 字节的整数—— 当你写'a'、'b'这类字符常量时，编译器会自动替换成对应的 ASCII 码值（十进制整数）。
        if(offset<0){
            offset+=26;//
        }
        password[i]=offset+'a';//原地修改原字符串的当前字符（解密后覆盖加密字符）；
    }
    return password;
}

字符串的替换，一次for循环干完所有

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include<string.h>
int main() {
    int n;
    scanf("%d",&n);
    char bs[10];
        int bc1,bc2,bc3,bt;
        scanf("%s %d %d %d",bs,&bc1,&bc2,&bc3);
        bt=bc1+bc2+bc3;
    for(int i=0;i<n;i++){//由于只要一个总分最大的结果，所以可以只用一个for循环承包输入，比较，更新的功能，但是循环前要把第一个输入的学生作为标准比较
        char s[10];
        int c1,c2,c3,t;
        scanf("%s %d %d %d",s,&c1,&c2,&c3);
        t=c1+c2+c3;
        if(t>bt){
            strcpy(bs,s);//字符串不能像数字或字母一样赋值，但是bs和s的顺序和赋值顺序一样
            bc1 = c1; bc2 = c2; bc3 = c3; bt = t;
        }
    }
printf("%s %d %d %d\n",bs,bc1,bc2,bc3);
    return 0;
}

如何判断一个变量到底应该在循环内还是外声明

我认为判断那个变量是否是单次使用，或者循环的最终利用点不在变量本身，而是用变量作为一个跳板或者判断条件，这时候就可以在循环内

核心规则：如何判断变量该在循环内 / 外声明？

判断的核心是变量的 “作用域” 和 “生命周期” 需求，结合 4 个维度决策，下面用表格 + 示例清晰说明：

判断维度 声明在循环外 声明在循环内
1. 作用域需求 变量需要在循环外被使用（如后续计算、输出） 变量仅在单次循环内使用，循环外无意义
2. 生命周期需求 需要保留值到下一次循环（如计数器、累加值） 只需单次循环内有效，用完可销毁
3. 性能 / 开销 仅创建 / 销毁 1 次，开销小 每次循环创建 / 销毁，开销略大（编译器可优化）
4. 代码可读性 变量复用，减少重复声明 变量作用域最小化，避免误修改

典型场景示例

场景 1：计数器（必须在循环外）

如代码中的 f/r/t，需要累计 10 次循环的结果，若放在循环内，每次循环都会重置为 0，无法统计，因此必须在循环外声明：

1
2
3
4
5
6
7
8
// 错误：循环内声明计数器，每次循环f都会被初始化为0，最终f永远是0/1
for(int i=0; i<10; i++) {
    int f=0; 
    if(floor(x)==y) f++;
}
// 正确：循环外声明，累计10次结果
int f=0;
for(...) { f++; }
场景 2：临时变量（建议在循环内）

如仅用于单次循环的临时计算变量，放在循环内可最小化作用域，避免后续代码误修改：

1
2
3
4
5
6
7
8
9
// 示例：计算10个数的平方和
int sum = 0;  // 需保留值，循环外声明
for(int i=0; i<10; i++) {
    int num = 0;  // 仅单次循环用，循环内声明
    scanf("%d", &num);
    int square = num * num;  // 临时变量，循环内声明
    sum += square;
}
printf("%d", sum);
场景 3：复用变量（可循环外）

如代码中的 x/y，仅用于存储单次输入，无累计需求，循环内 / 外均可，但循环外更精简（少写一次声明）。

判断是否是对应的函数

就判断调用函数后返回的值是否是自己根据函数原理手算出来的值就行了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<math.h>
int main(){
    int f=0,r=0,t=0;
    for(int i=0;i<10;i++){
        double x,y;

        scanf("%lf%lf",&x,&y);
        if(floor(x)==y)f++;
        if(round(x)==y)r++;
        if(trunc(x)==y)t++;
    }
    printf("%s",f==10?"floor":r==10?"round":"trunc");
    return 0;

}

判断反素数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include<stdio.h>
int count_divisors(int num){
    int count=0;
    for(int i=1;i<=num;i++){
        if(num%i==0){
            count++;
        }
    }
    return count;
}
int main(){
    int n;
    scanf("%d",&n);
    int panduan=0;
    int count=count_divisors(n);
    for(int i=1;i<n;i++){
        int count1=count_divisors(i);
        
        if(count1>=count){
            
            panduan=1;
            break;
        }
    }
    if(panduan==0){
        printf("%s","YES");
    }else{
        printf("%s","NO");
    }
    return 0;
    }

提取各位数字时，如果循环结束后要用原值做判断，或者循环，则必须在提取时加temp保护变量

如果以及知道边界并且边界较小，那么可以不用while循环和数组，直接用for循环和a1,a2,a3.

易错：数组是从0开始为索引的，套公式的时候需要下标减一

j–的时候小于变大于

数组作用域问题：n和k数组定义在第一个for循环内部，第二个for循环无法访问（超出作用域）；

选择pow，还是循环

pow()的本质：返回浮点数，而非精准整数

pow(10, k[i]) 是 C 语言<math.h>库的函数，它的设计目标是计算任意实数的幂（比如pow(2.5, 3.2)），因此返回值是double类型（浮点数），而非整数。

浮点数的存储规则是 “近似表示”（比如无法精准存储0.1），这会导致两个致命问题：

问题 1：精度丢失，计算结果 “差一点”

比如你要算pow(10, 9)（10 的 9 次方 = 1000000000），但由于浮点数的精度限制：

  • 实际返回值可能是 999999999.999999999（而非精准的 1000000000.0）；
  • 当你把这个浮点数转成整数时，会直接截断小数部分，变成999999999（少了 1）；
  • 最终导致j * 999999999 % n[i]的判断结果完全错误。

问题 2：浮点数无法参与整数运算

C 语言中，%（取余）、++等运算符只能用于整数，如果直接写：

1
if ((j * pow(10, k[i])) % n[i] == 0)  // 错误！

编译器会报错 —— 因为j * pow(...)的结果是浮点数，浮点数不能用%取余。

即使你强制转换：

1
if ((j * (int)pow(10, k[i])) % n[i] == 0)

也会因为问题 1 的精度丢失，导致转换后的整数出错（比如(int)999999999.999=999999999）。

在函数里面声明它要输出返回的值时注意要和定义函数时的函数类型保持一致，避免类型不匹配

while不仅可以循环，还可以循环判断，

一、先搞懂：什么是质因数？

1. 基础定义（通俗版）

  • 质数：只能被 1 和自身整除的数（比如 2、3、5、7、11…），是数的 “最小不可分割单位”；

  • 因数：能整除某个数的数（比如 6 的因数是 1、2、3、6）；

  • 质因数：既是质数、又是某个数的因数（比如 6 的质因数是 2 和 3，1 和 6 不是质数，所以不算）；

  • 质因数分解

    ：把一个数拆成若干个质数相乘的形式（比如：

    • 12 = 2×2×3（也写作 2²×3¹）；
    • 375 = 3×5×5×5（即 3¹×5³）；
    • 100 = 2²×5²）。

2. 核心性质

任何大于 1 的正整数，都能唯一分解为一组质因数的乘积（数学上叫 “唯一分解定理”）—— 这是质因数能解决很多算法题的根本原因。

二、质因数在代码中的常见用途

质因数分解是算法题的 “万能工具” 之一，核心用途集中在数论类问题，比如：

应用场景 举例（对应本题 / 同类题） 代码作用
判断整除性 本题 “结果能被 n 整除”、判断 a 是否是 b 的倍数 对比质因数的种类和个数，无需暴力取余
找末尾 0 的个数 本题 “末尾 k 个 0”、统计 n!（n 的阶乘）末尾 0 的个数 统计 2 和 5 的质因数对数（10=2×5）
求最大公约数（GCD） 求两个数的最大公约数、最小公倍数（LCM） 取质因数的最小 / 最大个数相乘
判质数 / 合数 判断一个数是否是质数、分解大数 质因数分解后，若只有 1 个质因数则是质数
找最小 / 最大满足条件的数 本题 “找最小满足条件的数”、找 n 的最小倍数 补充 / 删减质因数，保证 “最小” 且满足条件

三、拆解关键句：“能被 n 整除” 的数学本质

这句话是理解本题的核心，我们用 “人话 + 例子” 讲透：

1. 核心翻译

“结果能被 n 整除” → 结果的质因数分解式中，必须包含 n 的所有质因数，且每个质因数的个数≥n 中的个数。

2. 举例验证（结合本题）

比如 n=375（质因数分解：3¹×5³），要让某个数 ans 能被 375 整除：

  • ans 的质因数必须包含 “3” 和 “5”（少一个都不行）；

  • ans 中 3 的个数≥1，5 的个数≥3（个数不够就不行）；

    比如 ans=30000（分解：2⁴×3¹×5⁴）：

    • 包含 3（个数 1≥1）、5（个数 4≥3）→ 能被 375 整除；

      比如 ans=10000（分解：2⁴×5⁴）：

    • 缺少质因数 3 → 不能被 375 整除；

      比如 ans=75（分解：3¹×5²）：

    • 5 的个数 2<3 → 不能被 375 整除。

再比如 n=12（2²×3¹）：

  • ans=24（2³×3¹）：包含 2（3≥2）、3（1≥1）→ 能被 12 整除；
  • ans=18（2¹×3²）：2 的个数 1<2 → 不能被 12 整除。

总结

  1. 质因数是 “数的最小构成单位”，分解后能把 “整除、倍数、末尾 0” 等问题转化为 “质因数个数的加减”，避开暴力循环；
  2. “能被 n 整除” 的本质是 “质因数的包含关系”—— 这也是本题能从 O (T×n) 暴力法优化到 O (T×logn) 的核心；
  3. 代码中统计质因数个数，就是为了量化这种 “包含关系”，进而计算需要补充的质因数数量，最终得到最小解。

简单说：质因数分解把 “数的运算” 降维成 “质因数个数的运算”，是数论题从 “暴力” 到 “高效” 的关键桥梁。

常见模板

输入格式转换（字符串转数字）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 题目：读取一个字符串形式的数字，计算其各位和
#include <stdio.h>
#include <string.h>

int main() {
    // 输入处理模块：字符串输入+格式转换
    char s[100];
    scanf("%s", s); // 读取字符串
    int sum = 0;
    for (int i=0; i<strlen(s); i++) {
        sum += s[i] - '0'; // 字符转数字
    }
    
    // 后续模块...
    printf("%d\n", sum);
    return 0;
}

核心计算模块：题目的 “灵魂”，可封装复用

核心目标：

  • 实现题目的核心逻辑，尽量封装为独立函数（复用性强）；
  • 专注于 “计算逻辑”，不掺杂输入输出、边界判断。

示例 1：排序题（核心：冒泡排序）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// 核心计算模块：冒泡排序函数（可复用）
void bubble_sort(int arr[], int n) {
    for (int i=0; i<n-1; i++) {
        for (int j=0; j<n-1-i; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    // 输入处理模块
    int n;
    scanf("%d", &n);
    int arr[1000];
    for (int i=0; i<n; i++) scanf("%d", &arr[i]);
    
    // 边界处理模块
    if (n <= 1) { // 无需排序
        for (int i=0; i<n; i++) printf("%d ", arr[i]);
        return 0;
    }
    
    // 核心计算模块：调用排序函数
    bubble_sort(arr, n);
    
    // 输出处理模块
    for (int i=0; i<n; i++) printf("%d ", arr[i]);
    return 0;
}

示例 2：数论题（核心：质因数分解）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 核心计算模块：质因数分解函数（可复用）
void factorize(long long x) {
    printf("%lld = ", x);
    int flag = 0; // 控制输出格式（避免多余的*）
    for (long long i=2; i*i<=x; i++) {
        if (x % i == 0) {
            int cnt = 0;
            while (x % i == 0) {
                cnt++;
                x /= i;
            }
            if (flag) printf(" * ");
            printf("%lld^%d", i, cnt);
            flag = 1;
        }
    }
    if (x > 1) { // 剩余的质因数
        if (flag) printf(" * ");
        printf("%lld^1", x);
    }
    printf("\n");
}

int main() {
    // 输入处理模块
    long long n;
    scanf("%lld", &n);
    
    // 边界处理模块
    if (n < 2) {
        printf("%lld 无质因数\n", n);
        return 0;
    }
    
    // 核心计算模块：调用分解函数
    factorize(n);
    return 0;
}

示例 3：动态规划（核心：状态转移）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// 核心计算模块：背包问题（01背包）
int knapsack(int weight[], int value[], int n, int cap) {
    int dp[1001] = {0}; // dp[j]表示容量j的背包最大价值
    for (int i=0; i<n; i++) { // 遍历物品
        for (int j=cap; j>=weight[i]; j--) { // 逆序遍历容量
            if (dp[j - weight[i]] + value[i] > dp[j]) {
                dp[j] = dp[j - weight[i]] + value[i];
            }
        }
    }
    return dp[cap];
}

int main() {
    // 输入处理模块
    int n, cap;
    scanf("%d %d", &n, &cap);
    int weight[100], value[100];
    for (int i=0; i<n; i++) {
        scanf("%d %d", &weight[i], &value[i]);
    }
    
    // 边界处理模块
    if (n == 0 || cap == 0) {
        printf("0\n");
        return 0;
    }
    
    // 核心计算模块：调用背包函数
    int max_val = knapsack(weight, value, n, cap);
    printf("%d\n", max_val);
    return 0;
}

4. 结果生成模块：加工核心结果，贴合题目要求

初识二分法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<stdio.h>
int check(int res[],int n,int m,int mid){
    int count = 1;//分的组数
    int sum = 0;
    for(int i=0;i<n;i++){
        if(sum+res[i]>mid){//mid就是我们猜的最小最大值
            count++;
            sum = res[i];
            if(count>m)return 0;
        }else{
            sum+=res[i];
        }
    }
    return 1;
}
int main(){
    int n,m;
    scanf("%d %d",&n,&m);
    int res[1000005],left = 0,right = 0;
    for(int i=0;i<n;i++){
        scanf("%d",&res[i]);
        if(res[i]>left)left=res[i];
        right+=res[i];
    }
    while(left<right){
        int mid=left+(right-left)/2;
        if(check(res,n,m,mid)){
            right=mid;
        }else{
            left=mid+1;
        }
    }
    printf("%d\n",left);
    return 0;

}

一、前缀和的核心定义

前缀和（Prefix Sum）是一种预处理数组的技巧，核心是构建一个新数组 pre，其中 pre[i] 表示原数组 nums 中从第一个元素到第 i 个元素的累加和（或从 0 到 i-1 的累加和，取决于下标定义）。

简单说：前缀和数组的每一位，都是原数组前若干位的总和。

可以把结构体理解为：

把多个不同 / 相同类型的变量 “打包” 成一个新的类型，用来描述一个 “有多个属性的事物”。

比如题目中 “队伍” 有两个属性：能力值（int）、抗压值（int），用结构体就能把这两个属性绑在一起，而不用分开定义两个数组。

代码例子（定义 + 使用结构体）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 定义结构体：描述“队伍”这个事物，包含a（能力值）和k（抗压值）两个属性
struct Team {
    int a;  // 第一个属性：能力值
    int k;  // 第二个属性：抗压值
};

int main() {
    // 定义结构体变量：表示“一支队伍”
    struct Team t1;
    t1.a = 10;  // 给t1的能力值赋值
    t1.k = 3;   // 给t1的抗压值赋值
    
    // 打印这支队伍的属性
    printf("能力值：%d，抗压值：%d\n", t1.a, t1.k);  // 输出：能力值：10，抗压值：3
    return 0;
}
核心特点
  • 结构体是 “自定义类型”：像 int、char 一样，是一种数据类型，只是由你自己定义；
  • 一个结构体变量对应 “一个完整的事物”：比如struct Team t1就对应 “一支有能力值和抗压值的队伍”；
  • 访问属性用.：结构体变量。属性名（如t1.a）。

2. 结构体数组名：结构体数组的 “名字”，本质是数组首地址

第一步：先理解 “结构体数组”

结构体数组就是：数组里的每个元素都是一个结构体变量，用来存储多个 “有复合属性的事物”（比如多支队伍）。

第二步：结构体数组名

结构体数组名就是你给这个数组起的 “名字”，比如定义struct Team t[3];，t就是这个结构体数组的名字。

代码例子（结构体数组）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct Team {
    int a;
    int k;
};

int main() {
    // 定义结构体数组：存储3支队伍，数组名是t
    struct Team t[3];
    
    // 给第一支队伍（数组第0个元素）赋值
    t[0].a = 10;
    t[0].k = 3;
    // 给第二支队伍（数组第1个元素）赋值
    t[1].a = 2;
    t[1].k = 5;
    // 给第三支队伍（数组第2个元素）赋值
    t[2].a = 3;
    t[2].k = 3;
    
    // 打印第二支队伍的属性
    printf("第二支队伍：能力值%d，抗压值%d\n", t[1].a, t[1].k);  // 输出：2,5
    return 0;
}

数组的上一层就是结构体

3. 数组首地址：数组在内存中的 “起始位置”

数组首地址就是：数组第一个元素在计算机内存中的地址，可以理解为 “数组的门牌号”。

关键特性

  • 数组名 “等价于” 数组首地址：比如结构体数组t，t本身就代表t[0]的地址（首地址）；

  • 地址的表示：用&取地址符可以获取，比如&t[0]就是t[0]的地址，和t完全相等；

  • 内存视角（以

    1
    t[3]

    为例）：

    内存地址（示例） 对应元素
    0x1000（首地址） t[0]
    0x1008 t[1]
    0x1016 t[2]
代码验证（数组名 = 首地址）
1
2
3
4
5
6
7
8
9
10
11
12
struct Team {
    int a;
    int k;
};

int main() {
    struct Team t[3];
    // 打印数组名t（首地址）、&t[0]（第一个元素的地址）
    printf("数组名t的地址：%p\n", t);       // 输出：比如 0x7ffeefbff5c0
    printf("t[0]的地址：%p\n", &t[0]);    // 输出：和上面完全一样
    return 0;
}

4. 比较函数指针：指向 “比较函数” 的地址，给 qsort 传 “函数入口”

第一步：先理解 “函数指针”

函数指针就是：存储函数在内存中起始地址的变量，可以理解为 “函数的门牌号”—— 通过这个指针，就能找到并调用对应的函数。

第二步：qsort 需要的 “比较函数指针”

qsort 不知道你想怎么比较两个元素（比如按a+k升序、按a降序），所以需要你把 “比较函数的地址” 传给它，qsort 拿到这个地址后，就能调用你的比较函数，知道怎么排序。

代码例子（比较函数 + 函数指针）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdio.h>
#include <stdlib.h>

struct Team {
    int a;
    int k;
};

// 定义比较函数：按a+k升序
int cmp(const void *x, const void *y) {
    struct Team *tx = (struct Team*)x;
    struct Team *ty = (struct Team*)y;//类型转换，x是void*类型，无法直接访问结构体成员eg：x->a
    return (tx->a + tx->k) - (ty->a + ty->k);
}
//const标识函数内不会修改x和y的指向内容，是只读约束
int main() {
    struct Team t[3] = {{10,3}, {2,5}, {3,3}};
    
    // 方式1：直接传函数名cmp（函数名本身就是函数的地址，即函数指针）
    qsort(t, 3, sizeof(struct Team), cmp);
    
    // 方式2：显式定义函数指针，再传（等价于方式1）
    // 定义函数指针：指向“接收两个const void*，返回int”的函数
    int (*cmp_ptr)(const void*, const void*) = cmp;
    // qsort(t, 3, sizeof(struct Team), cmp_ptr);  // 和传cmp效果一样
    
    // 打印排序结果
    for (int i=0; i<3; i++) {
        printf("a=%d, k=%d\n", t[i].a, t[i].k);  // 输出：3,3 → 2,5 → 10,3
    }
    return 0;
}

return (tx->a + tx->k) - (ty->a + ty->k);是什么意思

一、先拆解每一部分的含义

代码片段 含义
tx->a 指针 tx 指向的队伍的能力值（a 对应题目中的 Ai）
tx->k 指针 tx 指向的队伍的抗压值（k 对应题目中的 Ki）
tx->a + tx->k 计算第一个队伍的 a+k 总和（本题的排序依据）
ty->a + ty->k 计算第二个队伍的 a+k 总和
(tx->a+tx->k) - (ty->a+ty->k) 两个队伍的 a+k 做差，返回差值（决定排序顺序）

二、核心规则：返回值决定排序顺序

qsort 的比较函数通过返回值的正负 / 零判断两个元素的大小关系，规则是：

返回值 含义 排序结果
< 0（负数） 第一个元素（tx）更小 tx 排在 ty 前面
= 0（零） 两个元素相等 顺序不变
> 0（正数） 第一个元素（tx）更大 ty 排在 tx 前面

因此，return (tx->a+tx->k) - (ty->a+ty->k) 的本质是：

按两个队伍的 a+k 总和进行「升序排序」（a+k 小的队伍排在前面）。

三、举例子理解（结合题目样例）

题目样例中有 3 支队伍：

  • 队伍 1：a=10, k=3 → a+k=13
  • 队伍 2：a=2, k=5 → a+k=7
  • 队伍 3：a=3, k=3 → a+k=6

我们拿队伍 1（tx）和队伍 3（ty） 举例：

1
2
// tx指向队伍1，ty指向队伍3
(tx->a + tx->k) - (ty->a + ty->k) = 13 - 6 = 7（正数）

返回值是正数 → qsort 判定「tx（队伍 1）更大」→ 把 ty（队伍 3）排在 tx（队伍 1）前面。

再拿队伍 3（tx）和队伍 2（ty） 举例：

1
2
// tx指向队伍3，ty指向队伍2
(tx->a + tx->k) - (ty->a + ty->k) = 6 - 7 = -1（负数）

返回值是负数 → qsort 判定「tx（队伍 3）更小」→ 把 tx（队伍 3）排在 ty（队伍 2）前面。

最终排序结果：队伍 3（6）→ 队伍 2（7）→ 队伍 1（13），和题目样例的最优顺序一致。

四、反向验证（如果想降序怎么办？）

如果把代码改成：

1
return (ty->a + ty->k) - (tx->a + tx->k);

就是按 a+k 降序排序（大的排在前面），比如样例中会排成：队伍 1→队伍 2→队伍 3，这会导致最大压力指数变成 9（而非样例的 2），验证了升序才是最优解。

核心要点
  • 函数名就是函数指针：比如cmp本身就是这个比较函数的地址，直接传给qsort即可；
  • qsort的第四个参数类型是int (*compar)(const void *, const void *)：这是 “函数指针类型”，要求你传的函数必须符合这个格式（参数是两个const void*，返回 int）。

二、把所有概念串起来（结合 qsort 的调用）

再看qsort的调用代码：

1
qsort(t, 3, sizeof(struct Team), cmp);
  • t：结构体数组名 → 等价于数组首地址（告诉 qsort 要排序的数组从内存哪个位置开始）；
  • 3：数组元素个数（告诉 qsort 要排多少个元素）；
  • sizeof(struct Team)：单个结构体元素的大小（告诉 qsort 每个元素占多少内存，方便遍历）；
  • cmp：比较函数指针（告诉 qsort “怎么比大小” 的函数入口地址）。

三、总结

概念 大白话理解 例子
结构体 打包多个属性的自定义数据类型 struct Team {int a; int k;}
结构体数组名 给结构体数组起的名字 struct Team t[3]; 中的t
数组首地址 数组第一个元素的内存地址，= 数组名 t 就是t[0]的地址
比较函数指针 存储比较函数地址的 “指针”，= 函数名 cmp 就是比较函数的地址

这些概念本质是为了让qsort能找到 “要排序的数组”、“要排多少个元素”、“每个元素多大”、“怎么比较元素”，最终实现结构体数组的排序 —— 核心逻辑还是服务于 “按 a+k 升序排序，最小化最大压力指数” 这个目标。

对基本类型相同的指针变量，各运算符的合法性如下：

  1. 选项 A（+）：指针变量不能直接做加法运算（无意义，会导致指向非法内存），因此该运算符不可用。
  2. 选项 B（-）：同类型指针相减，表示两个指针之间的元素个数（如数组中两个指针相减，结果是元素间隔数），合法。
  3. 选项 C（=）：指针变量可以赋值（如将一个指针指向另一个变量的地址），合法。
  4. 选项 D（==）：同类型指针可以比较是否指向同一内存地址，合法。

指针减法有两个关键限制（必须满足才合法）：

  1. 两个指针必须是 同类型（如都是 int*、都是 char*，不能 int* - char*）；
  2. 两个指针必须 指向同一连续内存块（如同一数组、同一动态分配的内存），否则结果无意义（语法允许但逻辑错误）。

指针变量存储的是 “格子的编号”（内存地址），而 指针相减的结果 = （两个指针的地址差）÷（单个格子的大小），最终得到的是 “两个指针之间隔了多少个格子”—— 也就是 “元素个数（间隔数）”。

数组的核心特性是 “元素在内存中连续存储”，因此数组名（本质是数组首元素的地址）和指向数组元素的指针，是指针减法的典型用法。

例子 1：int 数组（每个元素占 4 字节）

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
int main() {
    int arr[] = {10, 20, 30, 40, 50};  // 数组元素连续存储，每个int占4字节
    int *p1 = &arr[0];  // p1 指向第0个元素（地址假设为 0x100）
    int *p2 = &arr[3];  // p2 指向第3个元素（地址 = 0x100 + 3*4 = 0x10C）
    
    // 指针相减：p2 - p1
    int diff = p2 - p1;
    printf("地址差：%zu 字节\n", (unsigned long)p2 - (unsigned long)p1);  // 0x10C - 0x100 = 12 字节
    printf("指针相减结果：%d\n", diff);  // 12 ÷ 4 = 3 → 输出 3
    return 0;
}
  • 结果解读：p2 - p1 = 3，表示 p1（指向 arr [0]）和 p2（指向 arr [3]）之间隔了 3 个 int 元素（arr [1]、arr [2]、arr [3] 与 arr [0] 的间隔数是 3）。
  • 注意：结果是 “元素索引差”（3 - 0 = 3），和数组元素的索引完全对应，这就是指针减法的实用价值 —— 快速计算两个元素在数组中的位置间隔。

例子 2：char 数组（每个元素占 1 字节）

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main() {
    char str[] = "abcde";  // 每个char占1字节，地址连续（假设首地址 0x200）
    char *q1 = &str[0];  // 指向 'a'（0x200）
    char *q2 = &str[4];  // 指向 'e'（0x204）
    
    int diff = q2 - q1;
    printf("地址差：%zu 字节\n", (unsigned long)q2 - (unsigned long)q1);  // 0x204 - 0x200 = 4 字节
    printf("指针相减结果：%d\n", diff);  // 4 ÷ 1 = 4 → 输出 4
    return 0;
}
  • 实参：调用函数时传入的 “原始变量 / 值”（比如本题main中的 &y 和 x）；
  • 形参：函数定义时接收实参的 “局部变量”（比如本题fun中的 *x 和 y）。

C 语言中，普通变量作为参数时，采用 “值传递” —— 相当于把实参的 “值” 复制了一份，交给形参。函数内部操作的是这份 “副本”，和原始变量（实参）没有直接关联。

也就是说函数里面普通变量要想改变必须用return返回，如果是void类型函数里面改变或赋值某个普通变量的动作是无效的，但是对于指针有效

冒泡排序的核心是 “相邻元素比较，逆序则交换”，每一趟会将当前未排序部分的最大元素 “冒泡” 到末尾。对初始序列4,5,6,3,2,1（从小到大排序），每一趟的过程如下：

第 1 趟排序（目标：将最大的 6 移到末尾）

  • 比较并交换：4,5,3,6,2,1 → 4,5,3,2,6,1 → 4,5,3,2,1,6
  • 结果：4,5,3,2,1,6（末尾 6 已排好）

第 2 趟排序（目标：将次大的 5 移到倒数第 2 位）

  • 比较并交换：4,3,5,2,1,6 → 4,3,2,5,1,6 → 4,3,2,1,5,6
  • 结果：4,3,2,1,5,6（末尾 5、6 已排好）

第 3 趟排序（目标：将第三大的 4 移到倒数第 3 位）

  • 比较并交换：3,4,2,1,5,6 → 3,2,4,1,5,6 → 3,2,1,4,5,6
  • 结果：4,3,2,1,5,6（实际过程中，第 3 趟未完成 4 的移动，最终状态为4,3,2,1,5,6）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <stdio.h>

// 冒泡排序函数：对数组arr进行从小到大排序，n为数组元素个数
void bubbleSort(int arr[], int n) {
    // 外层循环：控制排序趟数（最多需要n-1趟，因为每趟排好1个元素）
    for (int i = 0; i < n - 1; i++) {
        // 标记位：优化冒泡排序（若某趟无交换，说明数组已有序，直接退出）
        int isSwap = 0;
        
        // 内层循环：相邻元素比较+交换（每趟后，末尾i个元素已排好，无需再比较）
        for (int j = 0; j < n - 1 - i; j++) {
            // 相邻元素逆序（前>后），则交换
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];    // 临时变量存arr[j]
                arr[j] = arr[j + 1];  // 交换：后一个元素移到前一个位置
                arr[j + 1] = temp;    // 前一个元素移到后一个位置
                isSwap = 1;           // 标记：本趟发生了交换
            }
        }
        
        // 若本趟无交换，数组已有序，直接退出循环（优化效率）
        if (isSwap == 0) {
            break;
        }
    }
}

// 打印数组（辅助函数，用于查看排序前后的结果）
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    // 测试用例：你之前提到的初始序列
    int arr[] = {4, 5, 6, 3, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);  // 计算数组元素个数（6个）
    
    printf("排序前：");
    printArray(arr, n);  // 输出：4 5 6 3 2 1
    
    bubbleSort(arr, n);  // 调用冒泡排序函数
    
    printf("排序后：");
    printArray(arr, n);  // 输出：1 2 3 4 5 6
    
    return 0;
}

数组名a是数组首元素的地址（a等价于&a[0]）；不是整个数组

  1. *p = a+3表示指针p指向a[3]（因为a+3是a[3]的地址）；

  2. 指针的下标运算

    1
    p[2]

    等价于

    1
    *(p+2)
    • p指向a[3]，p+2表示指针向后移动 2 个int元素，指向a[3+2] = a[5]；
    • *(p+2)即a[5]的值，为5。

首先明确结构体指针的访问规则：

  • 结构体指针p访问成员时，应使用->（格式：p->成员名）；
  • 取成员地址时，需在成员前加&（格式：&p->成员名 或 &(*p).成员名）。
1
2
3
&(*p).age` 等价于 `&p->age


->高于++,u不加括号的时候先指向再增加指针位置，如果把++p括起来就是指针向前移动一位然后指向原值
-> > * > ++

px 是「指向struct stu结构体的指针」，它的本质是存储了结构体变量x的内存地址；
*px 是「解引用px」，意思是：顺着px里存的地址，找到它指向的那个结构体变量x本身。

struct stu x是一套房子这个实体，地址内容是&x，struct stu*是存储了地址的纸条，
*px是拿着纸条，找到了房子这个实体

1
2
3
4
5
6
7
8
9
10
11
// 定义结构体类型
struct stu {
    int a;    // 4字节
    float b;  // 4字节
    char *c;  // 8字节（64位系统）
};

// 定义结构体变量x，并初始化
struct stu x = {23, 98.5, "wang"};
// 定义结构体指针px，赋值为x的地址
struct stu *px = &x;

sizeof(struct ps):计算结构体ps的大小，需要内存对齐，编译器中默认按 成员中最大基本类型的字节数 对齐
比如double i:占8字节
char arr[24]:占24字节
总大小32，刚好是8的整数倍，无需额外补位
内存对齐的规则：成员对齐，整体对齐

Denominator:分母

++i（前置自增）：先自增，再返回新值。
i++（后置自增）：先返回当前值，再自增。

break
不仅可用于 switch，还可用于 for, while, do-while 循环中，用于提前跳出当前循环。

continue 语句的作用是使程序的执行流程跳过包含它的所有循环

continue 的作用是：跳过本次循环剩余语句，直接进入下一次循环判断。
它不会跳出所有循环，只影响最内层的当前循环。

1
2
3
4
5
for (int i = 0; i < 5; i++) {
    if (i == 2)  
     continue;
printf("%d ", i); // 出: 0 1 3 4
}

alt text

do-while 是先执行一次循环体，再判断条件。
只要 while 中的条件为真（非零），就继续循环。

num++是将num的值加1
关闭和打开代码ai
alt text
点击设置搜索Copilot
alt text
点击功能里面的chat

点击*对应的true → 改为false

*** 每输出5个数就换行（第5,10,15,…项后换行）

1
2
3
if (i % 5 == 0) {
    printf("\n");
}

*** 斐波那契
用两项滚动计算

1
2
3
current = f1 + f2;  // 新的一项 = 前两项之和
f1 = f2;            // f1 向前移：变成原来的 f2
f2 = current;       // f2 向前移：变成刚算出的 current

保证输出结果在长整型范围内就用long

if的小括号判断语句里面必须是两个等号

条件判断错误：if(m>=1 && m<=n && n<=500)

题目要求：1 ≤ M ≤ N ≤ 500  
但你写成了 m <= n，而输入习惯是 M N（先 M 后 N），所以应判断 M <= N  
正确条件：if (m >= 1 && n <= 500 && m <= n)

代码书写的正确步骤

1.输入的合法性判断（用if语句）
2.初始化变量（让变量从零或x开始递归）
这时开始思考实现算法的步骤，确定变量的个数，明确要用的实现方法
3.循环前n项
（1）.开始计算当前项的值
（2）.打印当前项
（3）.控制换行（每x项为一行）
（4）.更新循环变量
4.补充末尾换行

编程可以往最笨的方向上想————遍历爆破
但是遍历的次数越少与好

(!found) 等价于 found == 0
alt text
明确循环，细化步骤
第一个循环是遍历边界数值，这是随n变化的最直观表现，因为已知边界，所以用for循环
第二个循环是拆分步骤，因为拆分数字是随n变化的，并且每一步骤相似度较高，都是取出位数，算出位数的三次方，去掉位数，进入下一位，所以也是循环

模板步骤

1.取当前最后一位数字 digit = temp % 10;
2.累加“数字的n次幂” sum += pow(digit, n);先判断步骤里面有没有“加”，然后判断是不是累加，即随着n的变化而改变加的个数
3.去掉最后一位，继续处理 temp = temp / 10;

这是while循环里的三步，主要思考每一小循环里的具体步骤，可以用假设法，假设n=5（这时你已经写完了scanf，所以确定n为一个定值）当写出用m遍历所有5位数后，确定m为一个定值，m=12345,如果人脑直接想就一次性拆分成四个数字了，但是编码需要顺序，从右往左按顺序一小步一小步遍历，所以从个位数字开始提取（第1，3步），然后看到条件等式想要写if判断，但是没有确定的右边界，也就是说判断也是随着n的变化而变化的，判断不是一个定值而是变量，所以把if转换为while+if，用中间值sum来连接，之前想写if（个位数1+十位数2+百位数^3+……i）,现在直接令sum+=pow（位数，n次幂），然后if判断suni

沙漏

各行符号中心对齐
给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

char ch; 是 C 语言中的变量声明语句，核心解析如下：
类型说明：char 是字符类型关键字，用于声明存储单个字符（如 *、#、字母、数字等）的变量，在内存中占 1 字节（8 位）；

1.计算行数，设最大行数行数为k，用while计算，k与n的关系是求和公式，则将n分为沙漏的上半部分和下半部分，假设k刚好满足，则n=2*\kk-1,然后k++开始计算，注意循环跳出后要回退k–
然后计算剩余符号数，remain=n-2\k*k+1
2.开始打印，有上下两部分组成，因为上下两部分的循环改变方向，所以用两个循环
有空格，符号，换行三部分组成

在git中发送密钥时关闭代理，初始化时打开代理

ctrl+f 打开搜索
localhost：0.0.0.0

将本地blog部署到线上

1
2
3
4
deploy:
  type: git
  repo: git@github.com:yulian-art/Julien.github.io.git  # 你的仓库SSH地址（从GitHub仓库的Code→SSH复制）
  branch: main  # 仓库的默认分支（这里是main）

注意冒号后面的空格键
2.安装部署插件并生成 + 部署
打开git bash here，进入本地 Hexo 博客根目录，执行以下命令：
安装 Git 部署插件：

1
npm install hexo-deployer-git --save

清理缓存、生成静态文件、部署到 GitHub：

1
2
3
hexo clean
hexo generate
hexo deploy

最终还是没解决

网页源码看查看器和网络

看不出来就用dirsearch
python3 dirsearch.py -u http://ip地址
查看有没有git文件
有的话用wget -r 地址下载文件
然后用git log查看的时候要注意跳转到下载的文件里，cd ~/ip地址

弱比较，自动转换成相同类型

结构体 学生成绩排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdio.h>
#include <stdlib.h>

typedef struct{//typedef给类型起别名
    int id;
    char name[20];
    int score1,score2,score3;
    double avg;
    int index;
}Student;

int compare(const void *a,const void *b){//接收两个无类型指针，可以指向任何类型的数据
    Student *s1 = (Student *)a;
    Student *s2 = (Student *)b;//把通用指针强制类型转换成Student *类型
    if (s1->avg !=s2->avg){
        return(s2->avg>s1->avg)?1:-1;
        
    }
    return s1->index-s2->index;//->表示用指针访问结构体或类的成员
}
int main(){
    int n;
    scanf("%d",&n);
    Student students[50];//定义一个Student类型的名为students的数组

    for(int i=0;i<n;i++){
        students[i].index = i;
        scanf("%d %s %d %d %d",
             &students[i].id,//点号表示直接访问结构体或类的成员
             students[i].name,
             &students[i].score1,
             &students[i].score2,
              &students[i].score3
             );
        students[i].avg = (students[i].score1+students[i].score2+students[i].score3) / 3.0;
        
    }
    qsort(students,n,sizeof(Student),compare);//students等价于students[0]，表示要排序的数组起始地址
    //sizeof(Student)表示数组中实际要排序的元素个数
    //compare比较函数决定排序规则 不要加括号
    //qsort在排序时，会反复调用这个函数来比较两个元素
    //约定返回负数就把a排在b前

    for(int i = 0;i<n;i++){
        printf("%d,%s,%.2f\n",students[i].id,students[i].name,students[i].avg);
        
    }
    return 0;
}

递归函数接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
double fact(int n){
    if(n==0||n==1){
        return 1.0;
    }
    return n *fact(n-1);//递归：函数自己调用自己，每次调用都会创建新的函数栈帧
}//不是同一个函数return多次，而是每个递归曾经各return一次
//当调用到最内层n=1时直接return 1.0
//但是递归太深可能会导致栈溢出
double factsum(int n){
    if(n<=0)
        return 0.0;
    double sum  = 0.0;
    for(int i = 1;i<=n;i++){
        sum +=fact(i);
    }
    return sum;
}

Ackermenn函数

1
2
3
4
5
6
7
8
9
int Ack(int m,int n){
    if(m==0){
        return n+1;
    }else if(n==0){
        return Ack(m -1,1);
    }else{
        return Ack(m-1,Ack(m,n-1));
    }
}

思考步骤

  1. 明确函数功能
  2. 写出基本情况：用来决定终止条件（分类讨论）
  3. 写出递归情况：不满足基本情况时，让函数调用自己（重点是找下一步的等价关系式，找这个关系式的关键是先假设这个函数已经构建好，可以直接帮我们得到正确答案了）

数组传参会退化为指向首元素的指针，丢失长度信息

多维数组最外层数组名(行数)会退化为指针，内层维度的长度必须显式指定arr[][3]

%zu是sizeof返回值的占位符:size_t c=sizeof(*p);printf("%zu",c);

IntArray arr={{1,2,3},3}相当于int a

1
2
3
4
// 以下 3 种写法完全等价，均被解析为 int* arr
void func1(int arr[]);
void func2(int arr[10]); // 数字10仅作提示，无实际意义
void func3(int* arr);

定义一个字符串数组时要初始化全为零char path[10] = {0};，使其可以稳定输出

因为在内存层面，数字0与\0的二进制表达式(ascll码值)完全相同，所以初始化为全0，等价为全‘\0’

%s是字符串的占位符

递归输出全排列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>

void backtrack(int n,int *used,char *path,int depth);
int main(){
    int n;
    scanf("%d",&n);
    int used[10] = {0};//长度为10的整型数组作为索引，保留used[0]可以让索引和数字一致
    char path[10] = {0};//长度为10的字符串数组，最多9个数字所以长度为十（结尾‘\0’）
    backtrack(n,used,path,0);
    return 0;
    
}
void backtrack(int n,int *used,char *path,int depth){
    if(depth == n){  //设置递归终止情况 //当depth == n,说明已经选了n个数字，path构建完成
        printf("%s\n",path);
        return;} //结束档期那递归分支
        for(int i=1;i<=n;i++){
            if(!used[i]){//等价于used[i]==0,表示数字i还没被用过
                used[i]=1;//标记已使用
                path[depth] = '0'+i;//把整数转换为字符（ascll数值）
                //把1转换为'1'
                backtrack(n,used,path,depth+1);
                used[i] = 0;//
            
        }
    }

设计递归函数方法

  1. 明确递归目标（也就是函数接收的参数的个数和功能）
  2. 确定递归终止条件（一般是 函数接收参数==边界值）
  3. 开始递归：遍历，if判断，标记，记录，递归，回溯

链表

头指针存放的是头结点的地址而非内容

单向链表的结点也可以用静态内存分配

通常使用结构的嵌套来定义单向链表结点的数据类型。

数组支持随机访问（通过下标直接定位），查询更高效；链表需从头结点依次遍历，查询效率更低

结构图的声明后面加变量名[数字]相当于声明了两个数组对象struct 结构体名 变量名[数字]

struct Person *friend;说明这个指针只能指向其他Person类的对象

如果结构体成员里面有n

friend->n等价于(*friend).n，表示friend所指向的结构体的成员n

只有指针类型的变量才能用->

malloc(n)动态内存分配函数，在堆上分配n字节未初始化内存，返回void*指针

也就是说malloc返回了一个在堆上的内存地址

malloc只分配空间，不清理内容

未初始化是指内存里的随机垃圾值

这样想象内存结构

1
2
3
p → [num: ?, next: ?]  @0x1000
q → [num: ?, next: ?]  @0x2000
r → [num: ?, next: ?]  @0x3000

内存对齐是指：某些类型的数据必须存储在特定地址的倍数位置上

int *p[3]表示声明一个指针数组，包含三个元素，每个元素都是int *类型

数组名不能被赋值

*p = &a;一般编译错误，但是题目出了就是指针指向a[0]

++p 和 p++ 是对指针 p 本身做自增（移动地址）
++(\*p) 和 (\*p)++ 是对 p 指向的值做自增（修改内容）

一级指针无法修改调用者指针的值，所以让二级指针修改指针让其指向一个新的值

二级指针是一个指向指针的指针

1
2
3
int a = 10;
int *p = &a;      // p 是一级指针
int **pp = &p;    // pp 是二级指针，指向 p

求一个数的因子=>找到能整除的数

1
char *language[] = {"FORTRAN", "BASIC", "PASCAL", "JAVA", "C"};

language[1]的值是一个地址，该地址存放的是字符‘B’

链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void input(){
    int num,score;
    char name[20];

    while(1){
        scanf("%d",&num);
        if(num == 0){
            break;
        }
        scanf("%s %d",name,&score);

        struct stud_node *p=(struct stud_node*)malloc(sizeof(struct stud_node));
        p->num = num;//用指针访问结构体里面的num成员并且给它赋值scanf传来的num值
        strcpy(p->name,name);//不能写p->name=name，不支持数组直接赋值
        p->score=score;
        p->next=NULL;
        //尾插法
        if(head == NULL){
            head = p;
            tail = p;
        }else{
            tail->next = p;
            tail = p;
        }
    }
}

文件

从文件的逻辑结构上看，c语言把文件看作数据流，并将数据按顺序以一维方式组织存储。

c语言源程序是文本文件，目标文件和可执行文件是二进制文件。

对于缓冲文件系统，在进行文件操作时，系统自动为每一个文件分配一块文件内存缓冲区（内存单元）。

文件指针指向一个 FILE 结构体，该结构体内部维护着当前文件位置和缓冲区信息。

fopen()打开文件失败，返回值是NULL

函数fopen中第一个参数的正确格式是"c:\\user\\text.txt"

第二次机考练习

指针拆分小数和整数**“要修改变量，传地址（&）；函数内用 \* 赋值”**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<stdio.h>

void splitfloat(float x,int *intpart,float *fracpart){
	*intpart=(int)x;
	*fracpart=x-(int)x;
}
int main(){
	float x;
	scanf("%f",&x);
	
	int intpart;
	float fracpart;
	
	splitfloat(x,&intpart,&fracpart);
	
	printf("%d%g\n",intpart,fracpart);//%g是%f的去0简洁输出
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>
void split(float x,int *ints,float *flo){
	*ints = (int)x;
	*flo = x-(int)x;
}
int main(){
	float x,y;
	int z;
	scanf("%f",&x);
	split(x,&z,&y);
	printf("%d%f",z,y);
	
	return 0;
}

选择法排序

选择排序思想：
每一轮从未排序部分中找出最小值，放到已排序部分的末尾

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include<stdio.h>

void sort(int a[],int n){
	for(int i=0;i<n-1;i++){
		int min=i;//假设当前数是最小值
		
		for(int j=i+1;j<n;j++){
			if(a[j]<a[min]){//开始与后面的数比对
				min=j;
			}
		}
		if(min!=i){
			int temp=a[i];
			a[i]=a[min];//出现比当前数更小的数就与当前数交换位置
			a[min]=temp;
		}
	}
}
int main(){
    int n;
    scanf("%d",&n);
    int a[10];
	for (int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	sort(a,n);
	for(int i=0;i<n;i++){
		if(i>0)printf(" ");
		print("%d",a[i]);
	}
	printf("\n");          
	
	
	
	return 0;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<stdio.h>
void sort(int a[],int n){
	for(int i=0;i<n;i++){
		int min=i;
		for(int j=i+1;j<n;j++){
			if(a[min]>a[j]){
				min=j;//只修改地址位置，不修改原值
			}
		}
		if(a[min]!=a[i]){
			int temp=a[min];
			a[min]=a[i];//不要用j，j已经变成min了
			a[i]=temp;
		}
	}
}

int main(){
	int n;
	scanf("%d",&n);
	int a[100];
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	sort(a,n);
	
	for(int i=0;i<n;i++){
		if(i>0){
		printf(" ");
		}
		printf("%d",a[i]);
	}
	
	printf("\n");


return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
void convert(char* binary,int* decimal){//必须用char，因为int无法表示32位二进制输入，int会把输入当成十进制解析
	for(int i=0;i<4;i++){
		int value=0;
		for(int j=0;j<8;j++){
			value=value*2+(binary[i*8+j]-'0');//'1' - '0' = 1
		}
		decimal[i]=value;
	}
}
int main(){
	char binary[33];
	scanf("%32s",binary);

	int decimal[4];
	convert(binary,decimal);
	
	printf("%d.%d.%d.%d\n",decimal[0], decimal[1], decimal[2], decimal[3]);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stdio.h>
void convert(char *binary,int *decimal){
	for(int i=0;i<4;i++){
		int value =0;
		for(int j=0;j<8;j++){
			value=value*2+(binary[i*8+j]-'0');
			
		}
		decimal[i]=value;
	}
}
int main(){
	char binary[33];
	scanf("%32s",binary);
}


int main(){​    return 0;}

如有错误，多多指教

valine