浙大版《C语言程序设计（第3版）》题目集（函数题）

系统管理员 2022-12-31 14:18 253阅读 0赞

所谓函数题，是指主函数main()题目中已给出，要求为程序写一个/两个函数，以实现某种功能，如为一组数据排序。

--------------------

# 练习5-1 求m到n之和 (10分) #

本题要求实现一个计算m~n（m<n）之间所有整数的和的简单函数。

**函数接口定义：**

int sum( int m, int n );

其中`m`和`n`是用户传入的参数，保证有m<n。函数返回的是m~n之间所有整数的和。

**裁判测试程序样例：**

#include <stdio.h>
    
    int sum(int m, int n);
    
    int main()
    {    
        int m, n;
    
        scanf("%d %d", &m, &n);
        printf("sum = %d\n", sum(m, n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**答案**

int sum(int m,int n){
        int i;
        int sum = 0;
        for(i=m; i<=n; i++){
            sum += i;
        }
        return sum;
    }

# 练习5-2 找两个数中最大者 (10分) #

本题要求对两个整数a和b，输出其中较大的数。

**函数接口定义：**

int max( int a, int b );

其中`a`和`b`是用户传入的参数，函数返回的是两者中较大的数。

**裁判测试程序样例：**

#include <stdio.h>
    
    int max( int a, int b );
    
    int main()
    {    
        int a, b;
    
        scanf("%d %d", &a, &b);
        printf("max = %d\n", max(a, b));
    
        return 0;
    }

**答案**

int max(int a,int b)
    {
        if(a<=b)
          return b;
        else
          return a;
    }

# 练习5-3 数字金字塔 (15分) #

本题要求实现函数输出n行数字金字塔。

**函数接口定义：**

void pyramid( int n );

其中`n`是用户传入的参数，为\[1, 9\]的正整数。要求函数按照如样例所示的格式打印出`n`行数字金字塔。注

意每个数字后面跟一个空格。

**裁判测试程序样例：**

#include <stdio.h>
    
    void pyramid( int n );
    
    int main()
    {    
        int n;
    
        scanf("%d", &n);
        pyramid(n);
    
        return 0;
    }

**答案**

void pyramid( int n ){
    	int i,j,k,m;
     
    	m = n;
    	for(i=1;i<=n;i++,m--){
    		j=m;
    		for(;j>0;j--)
    			printf(" ");
    		for(k=i;k>0;k--)
    			printf("%d ", i);
    		printf("\n");
    	}
     
    }

# 习题5-1 符号函数 (10分) #

本题要求实现符号函数sign(x)。

**函数接口定义**：

int sign( int x );

其中`x`是用户传入的整型参数。符号函数的定义为：若`x`大于0，`sign(x)` = 1；若`x`等于0，`sign(x)` = 0；否则，`sign(x)` = −1。

**裁判测试程序样例：**

#include <stdio.h>
    
    int sign( int x );
    
    int main()
    {
        int x;
    
        scanf("%d", &x);
        printf("sign(%d) = %d\n", x, sign(x));
    
        return 0;
    }

**答案**

int sign(int x)
    {
       // int n;
      //  n=x;
        if(x>0)
            return 1;
        else if(x==0)
            return 0;
        else 
            return -1;
    }

# **习题5-2 使用函数求奇数和 (15分)** #

本题要求实现一个函数，计算N个整数中所有奇数的和，同时实现一个判断奇偶性的函数。

**函数接口定义：**

int even( int n );
    int OddSum( int List[], int N );

其中函数`even`将根据用户传入的参数`n`的奇偶性返回相应值：当`n`为偶数时返回1，否则返回0。函数`OddSum`负责计算并返回传入的`N`个整数`List[]`中所有奇数的和。

**裁判测试程序样例：**

#include <stdio.h>
    
    #define MAXN 10
    
    int even( int n );
    int OddSum( int List[], int N );
    
    int main()
    {    
        int List[MAXN], N, i;
    
        scanf("%d", &N);
        printf("Sum of ( ");
        for ( i=0; i<N; i++ ) {
            scanf("%d", &List[i]);
            if ( even(List[i])==0 )
                printf("%d ", List[i]);
        }
        printf(") = %d\n", OddSum(List, N));
    
        return 0;
    }

**答案**

int even(int n)
    {
        if(n%2==0)
            return 1;
        else
            return 0;
    }
    int OddSum(int List[],int N)
    {
        int i,sum=0;
        for(i=0;i<N;i++)
        {
            if(even(List[i])==0)
                sum+=List[i];
    
        }
        return sum;
    }

# 习题5-3 使用函数计算两点间的距离 (10分) #

本题要求实现一个函数，对给定平面任意两点坐标(x1,y1)和(x2,y2)，求这两点之间的距离。

**函数接口定义：**

double dist( double x1, double y1, double x2, double y2 );

其中用户传入的参数为平面上两个点的坐标(`x1`, `y1`)和(`x2`, `y2`)，函数`dist`应返回两点间的距离。

**裁判测试程序样例：**

#include <stdio.h>
    #include <math.h>
    
    double dist( double x1, double y1, double x2, double y2 );
    
    int main()
    {    
        double x1, y1, x2, y2;
    
        scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
        printf("dist = %.2f\n", dist(x1, y1, x2, y2));
    
        return 0;
    }

**答案**

double dist(double x1, double y1, double x2, double y2 )
    {
        double x,y,sum;
      /* if(x1>x2)
           x=x1-x2;
       else 
           x=x2-x1;
        if(y1>y2)
            y=y1-y2;
        elsev
            y=y2-y1;  */
        x=fabs(x1-x2);   //fabs 求双精度浮点数的绝对值，abs 求整数的绝对值
        y=fabs(y1-y2);
        sum=sqrt(x*x+y*y);
        return sum;
    }

# 习题5-4 使用函数求素数和 (20分) #

本题要求实现一个判断素数的简单函数、以及利用该函数计算给定区间内素数和的函数。

素数就是只能被1和自身整除的正整数。注意：1不是素数，2是素数。

**函数接口定义：**

int prime( int p );
    int PrimeSum( int m, int n );

其中函数`prime`当用户传入参数`p`为素数时返回1，否则返回0；函数`PrimeSum`返回区间\[`m`, `n`\]内所有素数的和。题目保证用户传入的参数`m`≤`n`。

**裁判测试程序样例：**

#include <stdio.h>
    #include <math.h>
    
    int prime( int p );
    int PrimeSum( int m, int n );
    
    int main()
    {
        int m, n, p;
    
        scanf("%d %d", &m, &n);
        printf("Sum of ( ");
        for( p=m; p<=n; p++ ) {
            if( prime(p) != 0 )
                printf("%d ", p);
        }
        printf(") = %d\n", PrimeSum(m, n));
    
        return 0;
    }

**答案**

int prime( int p )
    {
        if(p<=1)
           return 0;
        else
        {
            for(int i=2;i<p;i++)
            {
                if(p%i==0)
                    return 0;
            }
            return 1;
            
        }
        
        
    }
    int PrimeSum( int m, int n )
    {
        int sum=0;
        for(int i=m;i<=n;i++)
        {
            if(prime(i)==1)
                sum+=i;
        }
        return sum;
    }

# 习题5-6 使用函数输出水仙花数 (20分) #

水仙花数是指一个N位正整数（N≥3），它的每个位上的数字的N次幂之和等于它本身。例如：153=13+53+33。 本题要求编写两个函数，一个判断给定整数是否水仙花数，另一个按从小到大的顺序打印出给定区间(m,n)内所有的水仙花数。

**函数接口定义：**

int narcissistic( int number );
    void PrintN( int m, int n );

函数`narcissistic`判断`number`是否为水仙花数，是则返回1，否则返回0。

函数`PrintN`则打印开区间(`m`, `n`)内所有的水仙花数，每个数字占一行。题目保证100≤`m`≤`n`≤10000。

**裁判测试程序样例：**

#include <stdio.h>
    
    int narcissistic( int number );
    void PrintN( int m, int n );
    
    int main()
    {
        int m, n;
    
        scanf("%d %d", &m, &n);
        if ( narcissistic(m) ) printf("%d is a narcissistic number\n", m);
        PrintN(m, n);
        if ( narcissistic(n) ) printf("%d is a narcissistic number\n", n);
    
        return 0;
    }

**答案**

int narcissistic( int number )
    {
        int i,count=0,sum=0;   //此处count要加上赋值，没加上时结果错误，后面sum的赋值竟然对于count无效
        int test=number;
        while(number)
        {
            number/=10;
            count++;
        }
        number=test;
        while(number)
        {
            int j=number%10;
            int  mult=1;      //mult要记得赋值为1，则每次循环都是值为1
            for(int i=0;i<count;i++)
            {
                mult*=j;
            }
            sum+=mult;
            number/=10;        
        }
        if(sum==test)
            return 1;
        else
            return 0;
        
    }
    void PrintN( int m, int n )
    {
        m=m+1;
        for(;m<n;m++)
        {
            if(narcissistic(m)==1)
                printf("%d\n",m);
        }
    }

# 习题6-1 分类统计字符个数 (15分) #

本题要求实现一个函数，统计给定字符串中英文字母、空格或回车、数字字符和其他字符的个数。

**函数接口定义：**

void StringCount( char s[] );

其中 `char s[]` 是用户传入的字符串。函数`StringCount`须在一行内按照

letter = 英文字母个数, blank = 空格或回车个数, digit = 数字字符个数, other = 其他字符个数

的格式输出。

**裁判测试程序样例：**

#include <stdio.h>
    #define MAXS 15
    
    void StringCount( char s[] );
    void ReadString( char s[] ); /* 由裁判实现，略去不表 */
    
    int main()
    {
        char s[MAXS];
    
        ReadString(s);
        StringCount(s);
    
        return 0;
    }

**答案**

void StringCount( char s[] )
    {
        int letter,blank,digit,other;
        letter=blank=digit=other=0;
    
        int i=0;                  //或者使用strlen(s)得到字符串的长度
        for (;s[i]!='\0';i ++)
        {
            if((s[i]>='a'&&s[i]<='z')||(s[i]>='A'&&s[i]<='Z'))
                letter++;
            else if(s[i]==' ')
                blank++;
            else if(s[i]>='0'&&s[i]<='9')
                digit++;
            else
                other++;
        }
       printf("letter = %d, blank = %d, digit = %d, other = %d",letter , blank , digit , other );
    }

# 习题6-2 使用函数求特殊a串数列和 (20分) #

给定两个均不超过9的正整数a和n，要求编写函数求a+aa+aaa++⋯+aa⋯a（n个a）之和。

**函数接口定义：**

int fn( int a, int n );
    int SumA( int a, int n );

其中函数`fn`须返回的是`n`个`a`组成的数字；`SumA`返回要求的和。

**裁判测试程序样例：**

#include <stdio.h>
    
    int fn( int a, int n );
    int SumA( int a, int n );
    
    int main()
    {
        int a, n;
    
        scanf("%d %d", &a, &n);
        printf("fn(%d, %d) = %d\n", a, n, fn(a,n));        
        printf("s = %d\n", SumA(a,n));    
    
        return 0;
    }

**答案**

int fn( int a, int n )
    {
        int sum=0;
        for(int i=0;i<n;i++)
        {
            sum+=a*pow(10,i);
        }
        return sum;
    }
    int SumA( int a, int n )
    {
        int allsum=0;
        for(int i=1;i<=n;i++)
        {
            allsum+=fn(a,i);
        }
        return allsum;
    }

# 习题6-4 使用函数输出指定范围内的Fibonacci数 (20分) #

本题要求实现一个计算Fibonacci数的简单函数，并利用其实现另一个函数，输出两正整数m和n（0<m≤n≤10000）之间的所有Fibonacci数。所谓Fibonacci数列就是满足任一项数字是前两项的和（最开始两项均定义为1）的数列。

**函数接口定义：**

int fib( int n );
    void PrintFN( int m, int n );

其中函数`fib`须返回第`n`项Fibonacci数；函数`PrintFN`要在一行中输出给定范围\[`m`, `n`\]内的所有Fibonacci数，相邻数字间有一个空格，行末不得有多余空格。如果给定区间内没有Fibonacci数，则输出一行“No Fibonacci number”。

**裁判测试程序样例：**

#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 )
    {
        int front=1,back=1,sum=0;    
        if(n==1||n==2)
            return 1;
        for(int i=3;i<=n;i++)
        {
            sum=front+back;
            front=back;      //相当于两个指针，往后移
            back=sum;
        }
        return sum;      //若用递归，则很快：return fib(n-1)+fib(n-2)
    }
        
    void PrintFN( int m, int n )
    {
        int i=1;
        int count=0;
        while(fib(i)<=n)                //使用fib(i)判断可以大大减少检验的数 
        {
            if(fib(i)>=m&&fib(i)<=n)         
            {
                count++;
                if(count==1)
                    printf("%d",fib(i));
                else
                    printf(" %d",fib(i));
            }   
            i++;
        }
        
        if(count==0)
            printf("No Fibonacci number\n");
    }

# 习题6-5 使用函数验证哥德巴赫猜想 (20分) #

本题要求实现一个判断素数的简单函数，并利用该函数验证哥德巴赫猜想：任何一个不小于6的偶数均可表示为两个奇素数之和。素数就是只能被1和自身整除的正整数。注意：1不是素数，2是素数。

**函数接口定义：**

int prime( int p );
    void Goldbach( int n );

其中函数`prime`当用户传入参数`p`为素数时返回1，否则返回0；函数`Goldbach`按照格式“`n`=p+q”输出`n`的素数分解，其中p≤q均为素数。又因为这样的分解不唯一（例如24可以分解为5+19，还可以分解为7+17），要求必须输出所有解中p最小的解。

**裁判测试程序样例：**

#include <stdio.h>
    #include <math.h>
    
    int prime( int p );
    void Goldbach( int n );
    
    int main()
    {
        int m, n, i, cnt;
    
        scanf("%d %d", &m, &n);
        if ( prime(m) != 0 ) printf("%d is a prime number\n", m);
        if ( m < 6 ) m = 6;
        if ( m%2 ) m++;
        cnt = 0;
        for( i=m; i<=n; i+=2 ) {
            Goldbach(i);
            cnt++;
            if ( cnt%5 ) printf(", ");
            else printf("\n");
        }
    
        return 0;
    }

**答案**

int prime( int p )
    {
        if(p==1)
            return 0;
        for(int i=2;i<p;i++)     //当p=2时，并不执行for循环，而直接return 1 故无需讨论p==2
        {
            if(p%i==0)
                return 0;
        }
        return 1;
    }
    void Goldbach( int n )
    {
        int a = 0;
      for(int i=2;i<n;i++)
      {
          if(prime(i)&&prime(n-i))
          {
              printf("%d=%d+%d",n,i,n-i);
              a=1;
          }
          if(a) break;
      }
    }

# 习题6-6 使用函数输出一个整数的逆序数 (20分) #

本题要求实现一个求整数的逆序数的简单函数。

**函数接口定义：**

int reverse( int number );

其中函数`reverse`须返回用户传入的整型`number`的逆序数。

**裁判测试程序样例：**

#include <stdio.h>
    
    int reverse( int number );
    
    int main()
    {
        int n;
    
        scanf("%d", &n);
        printf("%d\n", reverse(n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例：**

-12340

**输出样例：**

-4321

**答案**

int reverse( int number )
    {
        int flag=1,sum=0;
        if(number<0)
        {
            number=-number;
            flag=-1;
        }
        while(number)
        {
            sum=sum*10+number%10;
            number/=10;
        }
        return sum*flag;
    
    }

# 练习8-2 计算两数的和与差 (10分) #

本题要求实现一个计算输入的两数的和与差的简单函数。

**函数接口定义：**

void sum_diff( float op1, float op2, float *psum, float *pdiff );

其中`op1`和`op2`是输入的两个实数，`*psum`和`*pdiff`是计算得出的和与差。

**裁判测试程序样例：**

#include <stdio.h>
    
    void sum_diff( float op1, float op2, float *psum, float *pdiff );
    
    int main()
    {
        float a, b, sum, diff;
    
        scanf("%f %f", &a, &b);
        sum_diff(a, b, &sum, &diff);
        printf("The sum is %.2f\nThe diff is %.2f\n", sum, diff);
    
        return 0; 
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例：**

4 6

**输出样例：**

The sum is 10.00
    The diff is -2.00

**答案**

void sum_diff( float op1, float op2, float *psum, float *pdiff )
    {
        *psum=op1+op2;
        *pdiff=op1-op2;
    }
    /* 这里用空函数，因为return无法返回两个变量的值，故而使用指针。通过函数的参数传入
    变量的地址（即指针），在函数中去改变该地址的变量的值则变得便捷，最后在主函数中读取
    该变量的值即可达到return的效果 */

# 练习8-8 移动字母 (10分) #

本题要求编写函数，将输入字符串的前3个字符移到最后。

**函数接口定义：**

void Shift( char s[] );

其中`char s[]`是用户传入的字符串，题目保证其长度不小于3；函数`Shift`须将按照要求变换后的字符串仍然存在`s[]`里。

**裁判测试程序样例：**

#include <stdio.h>
    #include <string.h>
    
    #define MAXS 10
    
    void Shift( char s[] );
    
    void GetString( char s[] ); /* 实现细节在此不表 */
    
    int main()
    {
        char s[MAXS];
    
        GetString(s);
        Shift(s);
        printf("%s\n", s);
    
        return 0; 
    }

**答案**

void Shift( char s[] )
    {
        char a[3];
        int i,j;
        for(i=0;i<3;i++)
            a[i]=s[i];
        for(i=3;s[i];i++)
            s[i-3]=s[i];
        for(j=i-3,i=0;i<3;i++,j++)
            s[j]=a[i];
    }

# 习题8-1 拆分实数的整数与小数部分 (15分) #

本题要求实现一个拆分实数的整数与小数部分的简单函数。

**函数接口定义：**

void splitfloat( float x, int *intpart, float *fracpart );

其中`x`是被拆分的实数（0≤`x`<10000），`*intpart`和`*fracpart`分别是将实数x拆分出来的整数部分与小数部分。

**裁判测试程序样例：**

#include <stdio.h>
    
    void splitfloat( float x, int *intpart, float *fracpart );
    
    int main()
    {
        float x, fracpart;
        int intpart;
    
        scanf("%f", &x);
        splitfloat(x, &intpart, &fracpart);
        printf("The integer part is %d\n", intpart);
        printf("The fractional part is %g\n", fracpart);
    
        return 0;
    }

**答案**

void splitfloat( float x, int *intpart, float *fracpart )
    {
        *intpart=(int)x;
        *fracpart=x-*intpart;
    }

# 习题8-2 在数组中查找指定元素 (15分) #

本题要求实现一个在数组中查找指定元素的简单函数。

**函数接口定义：**

int search( int list[], int n, int x );

其中`list[]`是用户传入的数组；`n`（≥0）是`list[]`中元素的个数；`x`是待查找的元素。如果找到

则函数`search`返回相应元素的最小下标（下标从0开始），否则返回−1。

**裁判测试程序样例：**

#include <stdio.h>
    #define MAXN 10
    
    int search( int list[], int n, int x );
    
    int main()
    {
        int i, index, n, x;
        int a[MAXN];
    
        scanf("%d", &n);
        for( i = 0; i < n; i++ )
            scanf("%d", &a[i]);
        scanf("%d", &x);
        index = search( a, n, x );
        if( index != -1 )
            printf("index = %d\n", index);
        else
            printf("Not found\n");
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例1：**

5
    1 2 2 5 4
    2

**输出样例1：**

index = 1

**输入样例2：**

5
    1 2 2 5 4
    0

**输出样例2：**

Not found

**答案**

int search( int list[], int n, int x )
    {
        for(int i=0;list[i];i++)   //或者i<n;
        {
            if(list[i]==x)
            {
                return i;
                break;
            }  
        }
       return -1;
        
    }

# 习题8-3 数组循环右移 (20分) #

本题要求实现一个对数组进行循环右移的简单函数：一个数组a中存有n（>0）个整数，将每个整数循环向右移m（≥0）个位置，即将a中的数据由（a0a1⋯an−1）变换为（an−m⋯an−1a0a1⋯an−m−1）（最后m个数循环移至最前面的m个位置）。

**函数接口定义：**

int ArrayShift( int a[], int n, int m );

其中`a[]`是用户传入的数组；`n`是数组的大小；`m`是右移的位数。函数`ArrayShift`须将循环右移后的数组仍然存在`a[]`中。

**裁判测试程序样例：**

#include <stdio.h>
    #define MAXN 10
    
    int ArrayShift( int a[], int n, int m );
    
    int main()
    {
        int a[MAXN], n, m;
        int i;
    
        scanf("%d %d", &n, &m);
        for ( i = 0; i < n; i++ ) scanf("%d", &a[i]);
    
        ArrayShift(a, n, m);
    
        for ( i = 0; i < n; i++ ) {
            if (i != 0) printf(" ");
            printf("%d", a[i]);
        }
        printf("\n");
    
        return 0;
    }

**答案**

int ArrayShift( int a[], int n, int m )
    {
        int i,j;
        m=m%n;       //保证m<n
        int tmp[n];
        for(i=0;i<n-m;i++)
            tmp[i]=a[i];
        for(i=n-m,j=0;i<n;i++)
            a[j++]=a[i];
        for(i=m,j=0;i<n;i++)
            a[i]=tmp[j++];
    }

更便捷的答案

int ArrayShift( int a[], int n, int m ){
    	int i,j;
    	m=m%n;//移动n个回复原位 
    	int temp[n];
    	for(j=0;j<n;j++){
    		temp[j]=a[j];
    	} 
    	for(i=0;i<n;i++){
    		if(i>=(n-m)){
    			a[i+m-n]=temp[i];
    		}else{
    			a[i+m]=temp[i];
    		}
    	}
    }

# 习题8-4 报数 (20分) #

报数游戏是这样的：有n个人围成一圈，按顺序从1到n编好号。从第一个人开始报数，报到m（<n）的人退出圈子；下一个人从1开始报数，报到m的人退出圈子。如此下去，直到留下最后一个人。

本题要求编写函数，给出每个人的退出顺序编号。

**函数接口定义：**

void CountOff( int n, int m, int out[] );

其中`n`是初始人数；`m`是游戏规定的退出位次（保证为小于n的正整数）。函数`CountOff`将每个人的退出顺序编号存在数组`out[]`中。因为C语言数组下标是从0开始的，所以第`i`个位置上的人是第`out[i-1]`个退出的。

**裁判测试程序样例**：

#include <stdio.h>
    #define MAXN 20
    
    void CountOff( int n, int m, int out[] );
    
    int main()
    {
        int out[MAXN], n, m;
        int i;
    
        scanf("%d %d", &n, &m);
        CountOff( n, m, out );   
        for ( i = 0; i < n; i++ )
            printf("%d ", out[i]);
        printf("\n");
    
        return 0;
    }

# 习题8-4 报数 (20分) #

本题要求编写函数，给出每个人的退出顺序编号。

**函数接口定义：**

void CountOff( int n, int m, int out[] );

**裁判测试程序样例：**

**答案**

void CountOff( int n, int m, int out[] )
    {
        int item=n,i,cnt=0,j=1;
    	int a[n];
    	for(i=0;i<n;i++)
    		a[i]=1;
        while(item)           
        {
            for(i=0;i<n;i++)      //从头开始报数
            {
                if(a[i]!=0)
                {
                    cnt++;
                    if(cnt==m)      //只有没有出局的人才参加计数（报数）
                    {
                        a[i]=0;
                        out[i]=j;
                        item--;
                        j++;
                        cnt=0;
                        
                    }
                }
            }
        }
      
        
    }

# 习题8-5 使用函数实现字符串部分复制 (20分) #

本题要求编写函数，将输入字符串t中从第m个字符开始的全部字符复制到字符串s中。

**函数接口定义：**

void strmcpy( char *t, int m, char *s );

函数`strmcpy`将输入字符串`char *t`中从第`m`个字符开始的全部字符复制到字符串`char *s`中。若`m`超过输入字符串的长度，则结果字符串应为空串。

**裁判测试程序样例：**

#include <stdio.h>
    #define MAXN 20
    
    void strmcpy( char *t, int m, char *s );
    void ReadString( char s[] ); /* 由裁判实现，略去不表 */
    
    int main()
    {
        char t[MAXN], s[MAXN];
        int m;
    
        scanf("%d\n", &m);
        ReadString(t);
        strmcpy( t, m, s );
        printf("%s\n", s);
    
        return 0;
    }

**答案**

void strmcpy( char *t, int m, char *s )
    {
        int len=0;
        while(t[len]!='\0')
              len++;         
        len++;      //求的是数组的长度，而len是从0开始的，故要+1
        if(m>len)
            *s=NULL;
        else
        {
            for(int i=m-1,j=0;i<len;i++)
                s[j++]=t[i];
        }
    }

# 习题8-8 判断回文字符串 (20分) #

本题要求编写函数，判断给定的一串字符是否为“回文”。所谓“回文”是指顺读和倒读都一样的字符串。如“XYZYX”和“xyzzyx”都是回文。

**函数接口定义：**

bool palindrome( char *s );

函数`palindrome`判断输入字符串`char *s`是否为回文。若是则返回`true`，否则返回`false`。

**裁判测试程序样例：**

#include <stdio.h>
    #include <string.h>
    
    #define MAXN 20
    typedef enum {false, true} bool;
    
    bool palindrome( char *s );
    
    int main()
    {
        char s[MAXN];
    
        scanf("%s", s);
        if ( palindrome(s)==true )
            printf("Yes\n");
        else
            printf("No\n");
        printf("%s\n", s);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例1：**

thisistrueurtsisiht

**输出样例1：**

Yes
    thisistrueurtsisiht

**输入样例2：**

thisisnottrue

**输出样例2：**

No
    thisisnottrue

答案

bool palindrome( char *s )
    {
        for(int i=0;i<strlen(s)/2;i++)
        {
            if(s[i]!=s[strlen(s)-i-1]) //strlen函数计数从1开始，而数组下标从0开始，故要-1
                return false;
        }
        return true;
    }
    
    //无需判断奇偶，若为奇数个字符，字符串中间的那个字符不用和任何字符比较

# 习题8-9 分类统计各类字符个数 (15分) #

本题要求实现一个函数，统计给定字符串中的大写字母、小写字母、空格、数字以及其它字符各有多少。

**函数接口定义：**

void StringCount( char *s );

其中 `char *s` 是用户传入的字符串。函数`StringCount`须在一行内按照

大写字母个数 小写字母个数 空格个数 数字个数 其它字符个数

的格式输出。

**裁判测试程序样例：**

#include <stdio.h>
    #define MAXS 15
    
    void StringCount( char *s );
    void ReadString( char *s ); /* 由裁判实现，略去不表 */
    
    int main()
    {
        char s[MAXS];
    
        ReadString(s);
        StringCount(s);
    
        return 0;
    }
    
    /* Your function will be put here */

**输入样例：**

aZ&*?
    093 Az

**输出样例：**

2 2 1 3 4

void StringCount( char *s )
    {
        int L,l,b,d,o;
        L=l=b=d=o=0;
    
       //或者使用strlen(s)得到字符串的长度
        for (int i=0;s[i]!='\0';i ++)
        {
            if(s[i]>='a'&&s[i]<='z')
                l++;
            else if(s[i]>='A'&&s[i]<='Z')
                 L++;
            else if(s[i]==' ')
                 b++;
            else if(s[i]>='0'&&s[i]<='9')
                 d++;
            else
                 o++;
        }
       printf("%d %d %d %d %d",L,l,b,d,o );
    }

# 习题9-2 计算两个复数之积 (15分) #

本题要求实现一个计算复数之积的简单函数。

**函数接口定义：**

struct complex multiply(struct complex x, struct complex y);

其中`struct complex`是复数结构体，其定义如下：

struct complex{
        int real;
        int imag;
    };

**裁判测试程序样例：**

#include <stdio.h>
    
    struct complex{
        int real;
        int imag;
    };
    
    struct complex multiply(struct complex x, struct complex y);
    
    int main()
    {
        struct complex product, x, y;
    
        scanf("%d%d%d%d", &x.real, &x.imag, &y.real, &y.imag);
        product = multiply(x, y);
        printf("(%d+%di) * (%d+%di) = %d + %di\n", 
                x.real, x.imag, y.real, y.imag, product.real, product.imag);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例：**

3 4 5 6

**输出样例：**

(3+4i) * (5+6i) = -9 + 38i

**答案：**

struct complex multiply(struct complex x, struct complex y)
    {
        struct complex num;
        num.real=(x.real*y.real)-(x.imag*y.imag);
        num.imag=x.real*y.imag+x.imag*y.real;
        return num;
    }

# 习题9-6 按等级统计学生成绩 (20分) #

本题要求实现一个根据学生成绩设置其等级，并统计不及格人数的简单函数。

**函数接口定义：**

int set_grade( struct student *p, int n );

其中`p`是指向学生信息的结构体数组的指针，该结构体的定义为：

struct student{
        int num;
        char name[20];
        int score;
        char grade;
    };

`n`是数组元素个数。学号`num`、姓名`name`和成绩`score`均是已经存储好的。`set_grade`函数需要根据学生的成绩`score`设置其等级`grade`。等级设置：85－100为A，70－84为B，60－69为C，0－59为D。同时，`set_grade`还需要返回不及格的人数。

**裁判测试程序样例：**

#include <stdio.h>
    #define MAXN 10
    
    struct student{
        int num;
        char name[20];
        int score;
        char grade;
    };
    
    int set_grade( struct student *p, int n );
    
    int main()
    {   struct student stu[MAXN], *ptr;
        int n, i, count;
    
        ptr = stu;
        scanf("%d\n", &n);
        for(i = 0; i < n; i++){
           scanf("%d%s%d", &stu[i].num, stu[i].name, &stu[i].score);
        } 
       count = set_grade(ptr, n);
       printf("The count for failed (<60): %d\n", count);
       printf("The grades:\n"); 
       for(i = 0; i < n; i++)
           printf("%d %s %c\n", stu[i].num, stu[i].name, stu[i].grade);
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**答案：**

int set_grade( struct student *p, int n )
    {
        int cnt=0;
        /*85－100为A，70－84为B，
        60－69为C，0－59为D。同时，set_grade还需要返回不及格的人数。*/
        for(int i=0;i<n;i++,p++)
        {
            if(p->score>=85&&p->score<=100)
                p->grade='A';
            else if(p->score>=70&&p->score<=84)
                 p->grade='B';
            else if(p->score>=60&&p->score<=69)
                 p->grade='C';
            else 
            {
                p->grade='D';
                cnt++;
            }
                 
        }
        return cnt;
    }

# 练习10-1 使用递归函数计算1到n之和 (10分) #

本题要求实现一个用递归计算1+2+3+…+n的和的简单函数。

**函数接口定义：**

int sum( int n );

该函数对于传入的正整数`n`返回`1+2+3+…+n`的和；若`n`不是正整数则返回0。题目保证输入输出在长整型范围内。建议尝试写成递归函数。

**裁判测试程序样例：**

#include <stdio.h>
    
    int sum( int n );
    
    int main()
    {
        int n;
    
        scanf("%d", &n);
        printf ("%d\n", sum(n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例1：**

**输出样例1：**

**输入样例2：**

**输出样例2：**

**答案:**

int sum( int n )
    {
        int cnt=0;
        if(n<=0)
            return 0;
        else if(n==1)
            return 1;
        else
            cnt=sum(n-1)+n;
        return cnt;
    }

# 习题10-1 判断满足条件的三位数 (15分) #

本题要求实现一个函数，统计给定区间内的三位数中有两位数字相同的完全平方数（如144、676）的个数。

**函数接口定义：**

int search( int n );

其中传入的参数`int n`是一个三位数的正整数（最高位数字非0）。函数`search`返回\[101, `n`\]区间内所有满足条件的数的个数。

**裁判测试程序样例：**

#include <stdio.h>
    #include <math.h>
    
    int search( int n );
    
    int main()
    {
        int number;
    
        scanf("%d",&number);
        printf("count=%d\n",search(number));
    
        return 0;
    }
    
    
    /* 你的代码将被嵌在这里 */

**输入样例：**

500

**输出样例：**

count=6

**答案：**

int search( int n )
    {
        int i,p=121,count=0;
        for(i=11;p<=n;i++,p=pow(i,2))  //pow(i,2)==i*i
        {        
            if(p%10==p/10%10||p%10==p/100||p/10%10==p/100)
                count++;               
        }
        return count;
    }

# 习题10-2 递归求阶乘和 (15分) #

本题要求实现一个计算非负整数阶乘的简单函数，并利用该函数求 1!+2!+3!+...+n! 的值。

**函数接口定义**：

double fact( int n );
    double factsum( int n );

函数`fact`应返回`n`的阶乘，建议用递归实现。函数`factsum`应返回 1!+2!+...+`n`! 的值。题目保证输入输出在双精度范围内。

**裁判测试程序样例：**

#include <stdio.h>
    
    double fact( int n );
    double factsum( int n );
    
    int main()
    {
        int n;
    
        scanf("%d",&n);
        printf("fact(%d) = %.0f\n", n, fact(n));
        printf("sum = %.0f\n", factsum(n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例1：**

**输出样例1：**

fact(10) = 3628800
    sum = 4037913

**输入样例2：**

**输出样例2：**

fact(0) = 1
    sum = 0

**答案：**

double fact( int n )
    {
        if(n==0)
            return 1;
        else if(n==1)
            return 1;
        else
            return fact(n-1)*n;
    }
    double factsum( int n )
    {
        int sum=0;
        for(int i=1;i<=n;i++)
            sum+=fact(i);
        
        return sum;
    }

# 习题10-3 递归实现指数函数 (15分) #

本题要求实现一个计算xn（n≥1）的函数。

**函数接口定义：**

double calc_pow( double x, int n );

函数`calc_pow`应返回`x`的`n`次幂的值。建议用递归实现。题目保证结果在双精度范围内。

**裁判测试程序样例：**

#include <stdio.h>
    
    double calc_pow( double x, int n );
    
    int main()
    {
        double x;
        int n;
    
        scanf("%lf %d", &x, &n);
        printf("%.0f\n", calc_pow(x, n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**答案：**

double calc_pow( double x, int n )
    {
        if(x==1)
            return x;
        else if(n==0)
            return 1;
        else
            return x*calc_pow(x,n-1);
    }

# 习题10-4 递归求简单交错幂级数的部分和 (15分) #

本题要求实现一个函数，计算下列简单交错幂级数的部分和：

f(x,n)=x−x2+x3−x4+⋯+(−1)n−1xn

**函数接口定义：**

double fn( double x, int n );

其中题目保证传入的`n`是正整数，并且输入输出都在双精度范围内。函数`fn`应返回上述级数的部分和。建议尝试用递归实现。

**裁判测试程序样例：**

#include <stdio.h>
    
    double fn( double x, int n );
    
    int main()
    {
        double x;
        int n;
    
        scanf("%lf %d", &x, &n);
        printf("%.2f\n", fn(x,n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**输入样例：**

0.5 12

**输出样例：**

0.33

**答案：**

double fn( double x, int n )
    {
        if(n==0)
            return 0;
        else 
            return pow(-1,n-1)*pow(x,n)+fn(x,n-1);
    }

# 习题10-5 递归计算Ackermenn函数 (15分) #

本题要求实现Ackermenn函数的计算，其函数定义如下：

![5a43b08ea129cdcdf72cf3a4ee340b85.png][]

**函数接口定义：**

int Ack( int m, int n );

其中`m`和`n`是用户传入的非负整数。函数`Ack`返回Ackermenn函数的相应值。题目保证输入输出都在长整型范围内。

**裁判测试程序样例：**

#include <stdio.h>
    
    int Ack( int m, int n );
    
    int main()
    {
        int m, n;
    
        scanf("%d %d", &m, &n);
        printf("%d\n", Ack(m, n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**答案：**

int Ack( int m, int n )
    {
        if(m==0)
            return n+1;
        else if(m>0&&n==0)
            return Ack(m-1,1);
        else if(m>0&&n>0)
            return Ack(m-1,Ack(m,n-1));
            
    }

# 习题10-6 递归求Fabonacci数列 (10分) #

本题要求实现求Fabonacci数列项的函数。Fabonacci数列的定义如下：

f(n)=f(n−2)+f(n−1) (n≥2)，其中f(0)=0，f(1)=1。

函数接口定义：

int f( int n );

函数`f`应返回第`n`个Fabonacci数。题目保证输入输出在长整型范围内。建议用递归实现。

裁判测试程序样例：

#include <stdio.h>
    
    int f( int n );
    
    int main()
    {
        int n;
    
        scanf("%d", &n);
        printf("%d\n", f(n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

**答案：**

int f( int n )
    {
      if(n<=0)
          return 0;
       else if(n==1)
           return 1;
        else if(n>=2)
            return f(n-2)+f(n-1);
         
    }

# 习题10-7 十进制转换二进制 (15分) #

本题要求实现一个函数，将正整数n转换为二进制后输出。

函数接口定义：

void dectobin( int n );

函数`dectobin`应在一行中打印出二进制的`n`。建议用递归实现。

裁判测试程序样例：

#include <stdio.h>
    
    void dectobin( int n );
    
    int main()
    {
        int n;
    
        scanf("%d", &n);
        dectobin(n);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例：

输出样例：

1010

**答案：**

void dectobin(int n)
    {
    	if (n == 0)
            printf("0");  //输出的首位0
        else if(n==1)
            printf("1");    
        else
        {
            dectobin(n/2);     //要想明白这两句为何输出语句在后，即可明白递归的道理
            printf("%d",n%2);
        }
           
    }

# 习题10-8 递归实现顺序输出整数 (15分) #

本题要求实现一个函数，对一个整数进行按位顺序输出。

函数接口定义：

void printdigits( int n );

函数`printdigits`应将`n`的每一位数字从高位到低位顺序打印出来，每位数字占一行。

裁判测试程序样例：

#include <stdio.h>
    
    void printdigits( int n );
    
    int main()
    {
        int n;
    
        scanf("%d", &n);
        printdigits(n);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例：

12345

输出样例：

1
    2
    3
    4
    5

**答案：**

void printdigits( int n )
    {
        if(n==0)
            printf("0");
        else if(n<10)         //当只有一位数时，直接输出这位数
            printf("%d\n",n);
        else
        {
            printdigits(n/10);
            printf("%d\n",n%10);
        }
            
    }

# 习题11-2 查找星期 (15分) #

本题要求实现函数，可以根据下表查找到星期，返回对应的序号。

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>星期</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>0</td> 
   <td>Sunday</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>Monday</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>Tuesday</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>Wednesday</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>Thursday</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>Friday</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>Saturday</td> 
  </tr> 
 </tbody> 
</table>

函数接口定义：

int getindex( char *s );

函数`getindex`应返回字符串`s`序号。如果传入的参数`s`不是一个代表星期的字符串，则返回-1。

裁判测试程序样例：

#include <stdio.h>
    #include <string.h>
    
    #define MAXS 80
    
    int getindex( char *s );
    
    int main()
    {
        int n;
        char s[MAXS];
    
        scanf("%s", s);
        n = getindex(s);
        if ( n==-1 ) printf("wrong input!\n");
        else printf("%d\n", n);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例1：

Tuesday

输出样例1：

**答案：**

int getindex( char *s )
    {
        int cnt=0;
        char *week[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
        while(cnt<=6)
        {
            if (strcmp(s, week[cnt]) ==0)
                break;
            cnt++;
        }
    
        if(cnt==7)
            return -1;
        else 
            return cnt;
    }

# 习题11-3 计算最长的字符串长度 (15分) #

本题要求实现一个函数，用于计算有n个元素的指针数组s中最长的字符串的长度。

函数接口定义：

int max_len( char *s[], int n );

其中`n`个字符串存储在`s[]`中，函数`max_len`应返回其中最长字符串的长度。

裁判测试程序样例：

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define MAXN 10
    #define MAXS 20
    
    int max_len( char *s[], int n );
    
    int main()
    {
        int i, n;
        char *string[MAXN] = {NULL};
    
        scanf("%d", &n);
        for(i = 0; i < n; i++) {
            string[i] = (char *)malloc(sizeof(char)*MAXS);
            scanf("%s", string[i]);
        }
        printf("%d\n", max_len(string, n));
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例：

4
    blue
    yellow
    red
    green

输出样例：

**答案：**

int max_len( char *s[], int n )
    {
        int Maxlen=strlen(s[0]);
        for(int i=1;i<n;i++)
        {
            if(Maxlen<strlen(s[i]))
                Maxlen=strlen(s[i]);
        }
        return Maxlen;
    }

# 习题11-4 字符串的连接 (15分) #

本题要求实现一个函数，将两个字符串连接起来。

函数接口定义：

char *str_cat( char *s, char *t );

函数`str_cat`应将字符串`t`复制到字符串`s`的末端，并且返回字符串`s`的首地址。

裁判测试程序样例：

#include <stdio.h>
    #include <string.h>
    
    #define MAXS 10
    
    char *str_cat( char *s, char *t );
    
    int main()
    {
        char *p;
        char str1[MAXS+MAXS] = {'\0'}, str2[MAXS] = {'\0'};
    
        scanf("%s%s", str1, str2);
        p = str_cat(str1, str2);
        printf("%s\n%s\n", p, str1);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例：

abc
    def

输出样例：

abcdef
    abcdef

答案：

其一（借助库函数）

char *str_cat( char *s, char *t )
    {
        return strcat(s,t);
    }

其二（利用循环，不借外力）

char *str_cat( char *s, char *t )
    {
        int i,j;
        for(i=0;s[i]!='\0';i++);
        for(j=0;t[j]!='\0';j++,i++)
        {
            s[i]=t[j];
        }
        s[i]='\0';
        return s;    
    }

附加：第二种耗时短，速度更快，但是稍微耗内存

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lheWFfMTIzNDU2Nzg_size_16_color_FFFFFF_t_70][]

第一种耗时长，但是相对省内存

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lheWFfMTIzNDU2Nzg_size_16_color_FFFFFF_t_70 1][]

# 习题11-5 指定位置输出字符串 (20分) #

本题要求实现一个函数，对给定的一个字符串和两个字符，打印出给定字符串中从与第一个字符匹配的位置开始到与第二个字符匹配的位置之间的所有字符。

函数接口定义：

char *match( char *s, char ch1, char ch2 );

函数`match`应打印`s`中从`ch1`到`ch2`之间的所有字符，并且返回`ch1`的地址。

裁判测试程序样例：

#include <stdio.h>
    
    #define MAXS 10
    
    char *match( char *s, char ch1, char ch2 );
    
    int main()
    {
        char str[MAXS], ch_start, ch_end, *p;
    
        scanf("%s\n", str);
        scanf("%c %c", &ch_start, &ch_end);
        p = match(str, ch_start, ch_end);
        printf("%s\n", p);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例1：

program
    r g

输出样例1：

rog
    rogram

**答案：**

char *match( char *s, char ch1, char ch2 )
    {    
        char *c1;
        c1=NULL;
        while(*s!='\0')
        {
            if(*s==ch1)
            {
                c1=s;
                for(;*s!='\0';s++)
                {
                    printf("%c",*s);
                    if(*s==ch2)
                       break;
                }            
            } 
            s++;
        }
        printf("\n");      //无论是否有输出字符串，都要有 换行符
        
       if(c1!=NULL)       
           return c1;
        else
            return s+strlen(s);    //注意：找不到，则返回指针s的'\0'的地址（我在这里错了很久） 
    }

# 习题11-6 查找子串 (20分) #

本题要求实现一个字符串查找的简单函数。

函数接口定义：

char *search( char *s, char *t );

函数`search`在字符串`s`中查找子串`t`，返回子串t在`s`中的首地址。若未找到，则返回NULL。

裁判测试程序样例：

#include <stdio.h>
    #define MAXS 30
    
    char *search(char *s, char *t);
    void ReadString( char s[] ); /* 裁判提供，细节不表 */
    
    int main()
    {
        char s[MAXS], t[MAXS], *pos;
    
        ReadString(s);
        ReadString(t);
        pos = search(s, t);
        if ( pos != NULL )
            printf("%d\n", pos - s);
        else
            printf("-1\n");
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例1：

The C Programming Language
    ram

输出样例1：

输入样例2：

The C Programming Language
    bored

输出样例2：

-1

**答案**：

char *search( char *s, char *t )
    {
        int i,j=0,cnt;
        for(i=0;i<strlen(s);i++)
        {
            cnt=i;
            j=0;                    //每循环一次，都将j置0
            while(s[i]==t[j])      //此处只能用while循环，不可以用if
            {            
                i++;
                j++;
            }
            if(j>=strlen(t))
                return &s[cnt];        
        }
        
         return NULL;
    }

# 习题11-7 奇数值结点链表 (20分) #

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下：

struct ListNode {
        int data;
        ListNode *next;
    };

函数接口定义：

struct ListNode *readlist();
    struct ListNode *getodd( struct ListNode **L );

函数`readlist`从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数`getodd`将单链表`L`中奇数值的结点分离出来，重新组成一个新的链表。返回指向新链表头结点的指针，同时将`L`中存储的地址改为删除了奇数值结点后的链表的头结点地址（所以要传入`L`的指针）。

裁判测试程序样例：

#include <stdio.h>
    #include <stdlib.h>
    
    struct ListNode {
        int data;
        struct ListNode *next;
    };
    
    struct ListNode *readlist();
    struct ListNode *getodd( struct ListNode **L );
    void printlist( struct ListNode *L )
    {
         struct ListNode *p = L;
         while (p) {
               printf("%d ", p->data);
               p = p->next;
         }
         printf("\n");
    }
    
    int main()
    {
        struct ListNode *L, *Odd;
        L = readlist();
        Odd = getodd(&L);
        printlist(Odd);
        printlist(L);
    
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7 
    2 2 4 6

**答案：**

[5a43b08ea129cdcdf72cf3a4ee340b85.png]: /images/20221120/32f29bfc76b443709c2807f9868c721f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lheWFfMTIzNDU2Nzg_size_16_color_FFFFFF_t_70]: /images/20221120/61a0def63b3542cba5a254f624b601c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lheWFfMTIzNDU2Nzg_size_16_color_FFFFFF_t_70 1]: /images/20221120/eaefe4f4858e4011a72ca45dd4d2245f.png