AcWing语法基础课学习笔记第六讲函数

左手的ㄟ右手 2024-03-16 09:55 37阅读 0赞

### AcWing语法基础课学习笔记 ###

![在这里插入图片描述][ede33abcc4ca4b758ff9fc0158d9b51b.png_pic_center]

##### 第六讲 函数 #####

如果世界上只有计算机没有人类，那么函数这个东西计算机是用不到的。

函数让代码变得更加简洁。——闫学灿

###### 1. 函数基础 ######

一个典型的函数定义包括以下部分：返回类型、函数名字、由0个或多个形参组成的列表以及函数体。

###### 1.1 编写函数 ######

我们来编写一个求阶乘的程序。程序如下所示：

int fact(int val)
    {
        int ret = 1;
        while (val > 1)
            ret *= val -- ;
        return ret;
    }

函数名字是`fact`，它作用于一个整型参数，返回一个整型值。return语句负责结束`fact`函数并返回`ret`的值。

> 如果省掉return ，会返回随机值

> 函数声明与函数定义
> 
>  *  当然算法题随便，真正写工程的时候，分开意义不大

###### 1.2 调用函数 ######

int main()
    {
        int j = fact(5);
        cout << "5! is " << j << endl;
    
        return 0;
    }

![在这里插入图片描述][3f9fd1364bf14c8ca60392558c2e1c46.png_pic_center]

函数的调用完成两项工作：

*  一是用实参初始化函数对应的形参
 *  二是将控制权转移给被调用函数。此时，主调函数的执行被暂时中断，被调函数开始执行。

![在这里插入图片描述][311568db7d2d458693aec7bb0a0c6790.png_pic_center]

> 树

###### 1.3 形参和实参 ######

实参是形参的初始值。第一个实参初始化第一个形参，第二个实参初始化第二个形参，依次类推。形参和实参的类型和个数必须匹配。

fact("hello");      // 错误：实参类型不正确
    fact();             // 错误：实参数量不足
    fact(42, 10, 0);    // 错误：实参数量过多
    fact(3.14);         // 正确：该实参能转换成int类型，等价于fact(3);

形参也可以设置默认值，但所有默认值**必须是最后几个**。当传入的实参个数少于形参个数时，最后没有被传入值的形参会使用默认值。

###### 1.4 函数的形参列表 ######

函数的形参列表可以为空，但是不能省略。

void f1() {/* …. */}            // 隐式地定义空形参列表
    void f2(void) {/* … */}         // 显式地定义空形参列表

形参列表中的形参通常用逗号隔开，其中每个形参都是含有一个声明符的声明。**即使两个形参的类型一样，也必须把两个类型都写出来：**

int f3(int v1, v2) {/* … */}        // 错误
    int f4(int v1, int v2) {/* … */}    // 正确

###### 1.5 函数返回类型 ######

大多数类型都能用作函数的返回类型。一种特殊的返回类型是`void`，它表示函数不返回任何值。函数的返回类型不能是数组类型或函数类型，但可以是指向数组或者函数的指针。

###### 1.6 局部变量、全局变量与静态变量 ######

局部变量只可以在函数内部使用，全局变量可以在所有函数内使用。当局部变量与全局变量重名时，会**优先使用局部变量**。

> 【补充静态变量】
> 
>     int output(void){
>         static int cnt = 0;
>     }
> 
> 函数不管调用多少次，`cnt` 只会创建一次，即复用，用的都是同一个变量
> 
> → 等于是在函数内部开了一个只有该函数能用的全局变量【开到堆】

###### 2. 参数传递 ######

###### 2.1 传值参数 ######

当初始化一个非引用类型的变量时，初始值被拷贝给变量。此时，对变量的改动不会影响初始值。

#include <iostream>
    
    using namespace std;
    
    int f(int x)
    {
        x = 5;
    }
    
    int main()
    {
        int x = 10;
    
        f(x);
        cout << x << endl;
    
        return 0;
    }

![在这里插入图片描述][82eb3f7d10e141379c46d664c534a213.png_pic_center]

###### 2.2 传引用参数 ######

当函数的形参为引用类型时，对形参的修改会影响实参的值。使用引用的作用：**避免拷贝、让函数返回额外信息。**

#include <iostream>
    
    using namespace std;
    
    int f(int &x)
    {
        x = 5;
    }
    
    int main()
    {
        int x = 10;
    
        f(x);
        cout << x << endl;
    
        return 0;
    }

![在这里插入图片描述][428f7dda8ead4878bc5cce8b9d216ff2.png_pic_center]

###### 2.3 数组形参 ######

在函数中对数组中的值的修改，会影响函数外面的数组。

> 一种引用传递

一维数组形参的写法：

// 尽管形式不同，但这三个print函数是等价的
    void print(int *a) {/* … */}
    void print(int a[]) {/* … */}
    void print(int a[10]) {/* … */}

#include <iostream>
    
    using namespace std;
    
    void print(int a[])
    {
        for (int i = 0; i < 10; i ++ )
            cout << a[i] << endl;
    }
    
    int main()
    {
        int a[10];
    
        for (int i = 0; i < 10; i ++ )
            a[i] = i;
    
        print(a);
    
        return 0;
    }

![在这里插入图片描述][22f786fec03f45c78c81a06b4b298e1d.png_pic_center]

多维数组形参的写法：

// 多维数组中，除了第一维之外，其余维度的大小必须指定
    void print(int (*a)[10]) {/* … */}
    void print(int a[][10]) {/* … */}

#include <iostream>
    
    using namespace std;
    
    void print(int a[][10])
    {
        for (int i = 0; i < 10; i ++ )
        {
            for (int j = 0; j < 10; j ++ )
                cout << a[i][j] << ' ';
            cout << endl;
        }
    }
    
    int main()
    {
        int a[10][10];
    
        for (int i = 0; i < 10; i ++ )
            for (int j = 0; j < 10; j ++ )
                a[i][j] = j;
    
        print(a);
    
        return 0;
    }

![在这里插入图片描述][5749ba225fcd4d94b357ae49090f6328.png_pic_center]

###### 3. 返回类型和return语句 ######

return语句终止当前正在执行的函数并将控制权返回到调用该函数的地方。return语句有两种形式：

return;
    return expression;

###### 3.1 无返回值函数 ######

没有返回值的`return`语句只能用在返回类型是`void`的函数中。返回`void`的函数不要求非得有`return`语句，因为在这类函数的最后一句后面会隐式地执行`return`。

通常情况下，`void`函数如果想在它的中间位置提前退出，可以使用`return`语句。`return`的这种用法有点类似于我们用`break`语句退出循环。

void swap(int &v1, int &v2)
    {
        // 如果两个值相等，则不需要交换，直接退出
        if (v1 == v2)
            return;
        // 如果程序执行到了这里，说明还需要继续完成某些功能
    
        int tmp = v2;
        v2 = v1;
        v1 = tmp;
        // 此处无须显示的return语句
    }

###### 3.2 有返回值的函数 ######

只要函数的返回类型不是`void`，则该函数内的每条`return`语句必须返回一个值。

`return`语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换函数的返回类型。

#include <iostream>
    
    using namespace std;
    
    int max(int x, int y)
    {
        if (x > y) return x;
    
        return y;
    }
    
    int main()
    {
        int x, y;
        cin >> x >> y;
    
        cout << max(x, y) << endl;
    
        return 0;
    }

![在这里插入图片描述][9f17eb80fe024da9b2a42f33ec284527.png_pic_center]

###### 4. 函数递归 ######

在一个函数内部，也可以调用函数本身。

#include <iostream>
    
    using namespace std;
    
    int fact(int n)
    {
        if (n <= 1) return 1;
        return n * fact(n - 1);
    }
    
    int main()
    {
        int n;
        cin >> n;
    
        cout << fact(n) << endl;
    
        return 0;
    }

![在这里插入图片描述][a355291ec39e469baa12a905b9902b6f.png_pic_center]

![在这里插入图片描述][deb27909e63741ffa08dedbac732ca54.png_pic_center]

> 开始做题

`AcWing 804. n 的阶乘`

`AcWing 805. x和y的最大值`

#include <iostream>
    
    using namespace std;
    
    int max(int x, int y){
        
        if(x > y) return x;
        return y;
    }
    
    int main(){
        
        int x, y;
        cin >> x >> y;
        
        cout << max(x, y) << endl;
        
        return 0;
    }

`AcWing 808. 最大公约数`

#include <iostream>
    
    using namespace std;
    
    int gcd(int a, int b){
        
        for(int i = 1000; i ; i --)
            
            if(a % i == 0 && b % i == 0) return i;
    }
    
    int main(){
        
        int a, b;
        cin >> a >> b;
        
        cout << gcd(a, b) << endl;
        
        return 0;
    }

> 这道题因为数据小，直接暴力过掉了，正经的可以用辗转相除做，语法课就暂时不说了

`AcWing 811. 交换数值`

#include <iostream>
    
    using namespace std;
    
    void swap(int &x, int &y){
        
        int tmp  = x;
        x = y;
        y = tmp;
    }
    
    int main(){
        
        int x, y;
        cin >> x >> y;
        
        swap(x, y);
        
        cout << x << ' ' << y << endl;
        
        return 0;
    }

> 当然也可以判断一下，两个数相同的时候，不进行操作

`AcWing 812. 打印数字`

#include <iostream>
    
    using namespace std;
    
    void print(int a[], int size){
        
        for(int i = 0; i < size; i ++) cout << a[i] << ' ';
        
        cout << endl;
    }
    
    int main(){
        
        int n, size;
        
        cin >> n >> size;
        
        int a[n];
        
        for(int i = 0; i < n ; i ++) cin >> a[i];
        
        print(a, size);
        
        return 0;
    }

> 当然这里也尽可能把`a[n]`的大小定义成全局变量
> 
>     #include <iostream>
>     
>     using namespace std;
>     
>     const int N = 1010;
>     
>     void print(int a[], int size){
>         
>         for(int i = 0; i < size; i ++) cout << a[i] << ' ';
>         
>         cout << endl;
>     }
>     
>     int main(){
>         
>         int n, size;
>         
>         cin >> n >> size;
>         
>         int a[N];
>         
>         for(int i = 0; i < n ; i ++) cin >> a[i];
>         
>         print(a, size);
>         
>         return 0;
>     }

`AcWing 813. 打印矩阵`

#include <iostream>
    
    using namespace std;
    
    void print2D(int a[][105], int row, int col){
        
        for(int i = 0; i < row; i ++)
        {
            for(int j = 0; j < col; j ++)
                cout << a[i][j] << ' ';
            cout << endl;
        }
    }
    
    int main()
    {
        
        int a[105][105];
        
        int row, col;
        
        cin >> row >> col;
        
        for(int i = 0; i < row; i ++)
            for(int j = 0; j < col; j ++) cin >> a[i][j];
        
        print2D(a,  row, col);
        
        return 0;
    }

> 这个题需要注意的是函数形参中二维数组的那个`N`【不是就一定要写死那个`N`，N 也没法儿定义】

`AcWing 819. 递归求阶乘`

#include <iostream>
    
    using namespace std;
    
    int fact(int n){
        
        if(n == 1) return 1;
        return n * fact(n - 1);
    }
    
    int main()
    {
    
        int n;
        cin >> n;
        
        cout << fact(n) << endl;
        
        return 0;
    }

`AcWing 820. 递归求斐波那契数列`

#include <iostream>
    
    using namespace std;
    
    int fib(int n){
        
        if(n == 1 || n == 2) return 1;
        
        return fib(n - 1) + fib(n - 2);
    }
    
    int main()
    {
        
        int n;
        cin >> n;
        
        cout << fib(n) << endl;
        
        return 0;
    }

> 递归调用过程
> 
> ![在这里插入图片描述][a744f9cd26de4fa1a79f460e8ae858c4.png_pic_center]
> 
> 树的深度优先遍历

`AcWing 810. 绝对值`

#include <iostream>
    
    using namespace std;
    
    int abs(int x){
        
        if(x < 0) return -x;
        
        return x;
    }
    
    int main(){
        
        int n;
        cin >> n;
        
        cout << abs(n) << endl;
        
        return 0;
    }

`AcWing 806. 两个数的和`

#include <iostream>
    #include <cstdio>
    
    using namespace std;
    
    double add(double x, double y)
    {
        
        return x + y;
    }
    
    int main()
    {
        
        double x, y;
        cin >> x >> y;
        
        printf("%.2lf\n", add(x, y));
        
        return 0;
    }

`AcWing 807. 区间求和`

#include <iostream>
    
    using namespace std;
    
    int sum(int l, int r)
    {
        int n = r - l + 1;
        return n * l + n * (n - 1) / 2;
    }
    
    int main()
    {
        
        int l, r;
        
        cin >> l >> r;
        
        cout << sum(l, r) << endl;
        
        return 0;
    }

> 当然这个很明显有公式，等差数列求和
> 
> ![在这里插入图片描述][923f0a56dd954d279ec45669c6f0bb5f.png_pic_center]
> 
> 再不济就用循环

`AcWing 809. 最小公倍数`

#include <iostream>
    
    using namespace std;
    
    int lcm(int a, int b)
    {
        
        for(int i = a; i <= a * b; i ++){
            if(i % a == 0 && i % b == 0) return i;
        }
        
    }
    
    int main()
    {
        int a, b;
        
        cin >> a >> b;
        
        cout << lcm(a, b) << endl;
        
        return 0;
    }

> 从小到大枚举，遇到了就返回，就一定是最小的

`AcWing 814. 复制数组`

#include <iostream>
    
    using namespace std;
    
    const int N = 105;
    
    void copy(int a[], int b[], int size)
    {
        
        for(int i = 0; i < size; i ++) b[i] = a[i];
    }
    
    int main()
    {
        
        int a[N], b[N];
        
        int n, m, size;
        cin >> n >> m >> size;
        
        for(int i = 0; i < n; i ++) cin >> a[i];
        
        for(int j = 0; j < m; j ++) cin >> b[j];
        
        copy(a, b, size);
        
        for(int i = 0; i < m; i ++) cout << b[i] << ' ';
        
        return 0;
    }

> 也可以直接上函数`memcpy`，
> 
>     memcpy(b, a, size * 4);

`AcWing 815. 打印字符串`

#include <cstdio>
    
    void print(char str[])
    {
        printf("%s", str);
    }
    
    int main()
    {
        
        char str[110];
        
        fgets(str, 110, stdin);
        
        print(str);
        
        return 0;
    }

> 这道题需要注意的就是`fgets` 函数的用法
> 
> ![在这里插入图片描述][0895acb338174f84b60533848b3c5b2d.png_pic_center]
> 
> 而且要多读入一个回车，不然会报错

`AcWing 816. 数组翻转`

#include <iostream>
    
    using namespace std;
    
    void reverse(int a[], int size)
    {
        
        for(int i = 0, j = size - 1; i < j; i ++ ,j -- )
            swap(a[i], a[j]);
    }
    
    int main()
    {
        
        int a[1000];
        
        int n, size;
        cin >> n >> size;
        
        for(int i =0; i < n; i ++) cin >> a[i];
        
        reverse(a , size);
        
        for(int i =0; i < n; i ++) cout << a[i] << ' ';
        
        return 0;
    }

> 双指针实现翻转，`swap` 函数在`iostream` 库文件中也有

`AcWing 817. 数组去重`

#include <iostream>
    
    // 感觉和y 总那道题已经不一样了，没有规定size 这个东西, 就直接返回整个数组中不同数的个数了
    
    using namespace std;
    
    int get_unique_count(int a[], int n)
    {
        
        int cnt = 0;
        
        for(int i = 0; i < n; i ++)
        {
            bool is_exist = false;
            for(int j = 0; j < i ; j ++)
                if(a[j] == a[i]) 
                {
                    is_exist = true;
                    break;
                }
            if(!is_exist) cnt ++;
        }
        
        return cnt;
    }
    
    int main()
    {
        int a[1010];
        
        int n;
        cin >> n;
        
        for(int i = 0; i < n ; i ++) cin >> a[i];
        
        cout << get_unique_count(a, n) << endl;
        
        return 0;
    }

> 当然这里假装我们不会集合，直接暴力求解

`AcWing 818. 数组排序`

#include <iostream>
    
    using namespace std;
    
    // 选择排序
    void sort(int a[], int l, int r)
    {
        for(int i = l; i <= r; i ++)
            for(int j = i + 1; j <= r; j ++)
                if(a[j] < a[i])
                    swap(a[i], a[j]);
        
    }
    
    int main()
    {
        int a[1010];
        
        int n, l, r;
        
        cin >> n >> l >> r;
        
        for(int i = 0; i < n; i ++) cin >> a[i];
        
        sort(a, l, r);
        
        for(int i = 0; i < n; i ++) cout << a[i] << ' ';
        
        return 0;
    }

> 选择排序

`AcWing 821. 跳台阶`

#include <iostream>
    
    using namespace std;
    
    int n;
    int ans;
    
    int f(int k){
        
        if(k == n) ans ++;
        else if(k < n)
        {
            f(k + 1); // 跳一级
            f(k + 2); // 跳两级
        }
    }
    
    int main()
    {
        cin >> n;
        
        f(0);
        cout << ans << endl;
        
        return 0;
    }

> 函数递归调用。递归搜索树
> 
> ![在这里插入图片描述][c2b083df3975493fa6076885db035349.png_pic_center]
> 
> 深度优先【又有算法内味了】
> 
> 还可以从dp 的角度去考虑，当然这也是算法基础课的内容了
> 
> ![在这里插入图片描述][a8a8f665214a4a89a23c50692a3ce3b7.png_pic_center]

`AcWing 822. 走方格`

#include <iostream>
    
    using namespace std;
    
    int n, m;
    int ans;
    
    void dfs(int x, int y)
    {
        
        if(x == n && y == m) ans ++;
        else{
            
            if(y < m) dfs(x, y + 1); // 向右走
            if(x < n) dfs(x + 1, y); // 向下走
            
        }
        
    }
    
    int main()
    {
        cin >> n >> m;
        
        dfs(0, 0);
        
        cout << ans << endl;
        
        return 0;
    }

> 二维的"跳台阶"，同样直接递归求解
> 
> ![在这里插入图片描述][6093ebe2f7854eceba7eb2e215066846.png_pic_center]
> 
> 深度优先遍历，`dfs(x, y)`
> 
> ![在这里插入图片描述][4f9f0d5d293946f1bb6d371b30e6bf87.png_pic_center]

`AcWing 823. 排列`

#include <iostream>
    
    using namespace std;
    
    const int N = 10; // 最多9 个数
    
    int n;
    
    void dfs(int u, int nums[], bool st[])
    {
        
        if(u > n) // 每个坑都填完了，可以输出了
        {
            for(int i = 1; i <= n; i ++) cout << nums[i] << ' ';
            cout << endl;
        }
        else{
            for(int i = 1; i <= n; i ++)
                if(!st[i])
                {
                    st[i] = true; // 标记这个坑用过了
                    nums[u] = i;
                    dfs(u + 1, nums, st); 
                    st[i] = false; // 恢复现场
                }
        }
        
    }
    
    
    int main()
    {
        
        cin >> n;
        
        int nums[N]; // 记录每种情况【从1开始用】
        bool st[N] = {0}; // 记录状态
        
        dfs(1, nums, st);
    
        return 0;
    }

> 本质上也是递归搜索树，想象各个位置上的东西，以3 为例
> 
> ![在这里插入图片描述][66b61026f495421d9e571af1b384e849.png_pic_center]
> 
> 6 种
> 
> ![在这里插入图片描述][253e1971a5744818ac2345023df2c5b4.png_pic_center]
> 
> 可以看到时间并不快，可以简单优化一下，用`printf()` 和 `scanf()` 进行读入输出，
> 
> ![在这里插入图片描述][b492e183811b487f8ed50a44a0796d00.png_pic_center]
> 
> 看下时间
> 
> ![在这里插入图片描述][4a988b99d25349b0b3ee773ce852c056.png_pic_center]
> 
> 没问题【深搜的思想后面学算法的时候肯定还会大量用到】
> 
> 而且`n = 10` 的话，会超时
> 
> ![在这里插入图片描述][7cd4457f6ee542debf831d269fd43863.png_pic_center]

![在这里插入图片描述][5e9d9cbb10d04afba5b20a43dee221d8.png]

OK。

[ede33abcc4ca4b758ff9fc0158d9b51b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/c11a1d4a91374754afcb428dca46a8d4.png
[3f9fd1364bf14c8ca60392558c2e1c46.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/18db15ddf8f54bab9c094673778a25c2.png
[311568db7d2d458693aec7bb0a0c6790.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/a0517b0886f74b7daf5475cf875cceee.png
[82eb3f7d10e141379c46d664c534a213.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8135ea0d43b640b1996fe4086f1eb453.png
[428f7dda8ead4878bc5cce8b9d216ff2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/729f3f40d6cc4adc9276add2d95c3973.png
[22f786fec03f45c78c81a06b4b298e1d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3b33fae768554396b431e0a8c7874127.png
[5749ba225fcd4d94b357ae49090f6328.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/fadcd3993d6e4210b6bfdc5866224ed9.png
[9f17eb80fe024da9b2a42f33ec284527.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/5658a267cd6f4ce4aa60cdb92411d8f1.png
[a355291ec39e469baa12a905b9902b6f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/95ae6bdefe284d6cbe5f8ae876dd3279.png
[deb27909e63741ffa08dedbac732ca54.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/c901eaeec920476bb33f232ff631ccb7.png
[a744f9cd26de4fa1a79f460e8ae858c4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d7250ed66812438fa1f5aba3f7819ae6.png
[923f0a56dd954d279ec45669c6f0bb5f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/4ed5e7d5e09946418bae98ba24daed05.png
[0895acb338174f84b60533848b3c5b2d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/76b5388ee73b47fdb532b5ad4c187330.png
[c2b083df3975493fa6076885db035349.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/59b6fc6f6aaf44ee915cd0152ad61252.png
[a8a8f665214a4a89a23c50692a3ce3b7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/82c7bb5ab12546838db66ffe0297e547.png
[6093ebe2f7854eceba7eb2e215066846.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b4b44eb46d8440419235cd1a780a02f5.png
[4f9f0d5d293946f1bb6d371b30e6bf87.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/5a808ccee14947f8a3f208256f9fc37b.png
[66b61026f495421d9e571af1b384e849.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/5d2835833c8344f180ff117c91b23f65.png
[253e1971a5744818ac2345023df2c5b4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/13867967c71b4d7598d1910f93f759a2.png
[b492e183811b487f8ed50a44a0796d00.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/c786d899669f4740a049bcb198781e4f.png
[4a988b99d25349b0b3ee773ce852c056.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0988324c0bd2442ca9b6a677b2cfe634.png
[7cd4457f6ee542debf831d269fd43863.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/e5471470fc4c420a8bf1cbb44a3cfbf5.png
[5e9d9cbb10d04afba5b20a43dee221d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/ad54d9e5c929413ca0667efcc95b4cab.png