实验一

任务1

问题1：reverse和reverse_copy有什么区别？

解答：reverse 会直接在原容器上进行操作，改变原容器内元素的排列顺序；而 reverse_copy 接受三个参数（源区间起始、源区间结束、目标容器起始迭代器），它不会改变原容器，而是将反转后的结果拷贝到另一个目标容器中。

问题2：rotate算法是如何改变元素顺序的？它的三个参数分别代表什么？

解答：rotate 会将指定区间内的元素进行循环移位，使得中间迭代器指向的元素成为新的第一个元素。它的三个参数分别是：

first：区间的起始迭代器。
middle：区间内要被移动到最前面的元素的迭代器
last：区间的结束迭代器（不包含该位置）。

任务2

问题1：generate算法的作用是什么？
generate 算法的作用是遍历指定迭代器区间内的所有元素，并通过调用传入的无参函数来为每个元素重新赋值。初始化容器。
问题2：minmax_element和分别调用min_element、max_element相比，有什么优势？
minmax_element 可以一次遍历同时找到最大值和最小值的迭代器，返回一个包含两个迭代器的 pair；而分别调用两次需要遍历容器两次。所以，minmax_element 的效率更高，且代码更简练。

问题3：查询 Lambda 表达式用法，与使用自定义函数相比，Lambda 表达式适用场景是什么？
Lambda 表达式适用于那些只在局部使用一次、逻辑较为短小的代码块。如果写成全局自定义函数，会污染命名空间且跳转不便；直接内联写 Lambda 让代码逻辑更加紧凑、可读性更高，无需额外定义函数声明。

任务3

问题1：自定义函数func功能是什么？

func 实现了一个简单的“凯撒密码”式的字符偏移。如果是字母，就将其替换为字母表中的下一个字母；如果是其他字符（如空格、标点），则原样返回。

问题2：tolower和toupper功能分别是什么？

tolower 用于将大写字母转换为小写字母，若参数不是大写字母则原样返回；toupper 用于将小写字母转换为大写字母。

问题3：transform的4个参数意义分别是什么？如果把第3个参数s2.begin()改成s1.begin()，有何区别？

4个参数依次是：源区间起始迭代器、源区间结束迭代器、目标区间起始迭代器、用于处理的函数。

区别：目前写法是将结果存入 s2 中，s1 保持原样；如果改成 s1.begin()，则算法会将处理后的结果直接覆盖回原字符串 s1 中。

任务4

cin >> s 遇到空格就会停止读取。要读取包含空格的整行字符串，应使用 std::getline(std::cin, s);

#include <iostream>
#include <string>
#include <algorithm>

bool is_palindrome(const std::string& s);
bool is_palindrome_ignore_case(const std::string& s);

int main() {
    using namespace std;
    string s;

    // 多组输入，直到按下Ctrl+Z结束测试
    while (cin >> s) {
        cout << boolalpha
            << "区分大小写: " << is_palindrome(s) << "\n"
            << "不区分大小写: " << is_palindrome_ignore_case(s) << "\n\n";
    }
    return 0;
}

// 函数is_palindrome定义
bool is_palindrome(const std::string& s) {
    // 使用 std::equal 比较前半部分和反向迭代器
    return std::equal(s.begin(), s.begin() + s.size() / 2, s.rbegin());
}

// 函数is_palindrome_ignore_case定义
bool is_palindrome_ignore_case(const std::string& s) {
    std::string lower_s = s;
    std::transform(lower_s.begin(), lower_s.end(), lower_s.begin(),
        [](char c) {
            if (c >= 'A' && c <= 'Z') {
                return static_cast<char>(c + 32);
            }
            return c;
        });


    return is_palindrome(lower_s);
}

任务5

#include <iostream>
#include <string>
#include <algorithm>

std::string dec2n(int x, int n = 2);

int main() {
    int x;
    while (std::cin >> x) {
        std::cout << "十进制: " << x << '\n'
            << "二进制: " << dec2n(x) << '\n'
            << "八进制: " << dec2n(x, 8) << '\n'
            << "十二进制: " << dec2n(x, 12) << '\n'
            << "十六进制: " << dec2n(x, 16) << '\n'
            << "三十二进制: " << dec2n(x, 32) << "\n\n";
    }
}

// 函数dec2n定义
 std::string dec2n(int x, int n) {
    if (x == 0) {
        return "0";
    }

    std::string result;
    const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    while (x > 0) {
        result += digits[x % n];
        x /= n;
    }

    std::reverse(result.begin(), result.end());
    return result;
}

任务6

#include <iostream>

int main() {
    
    for (int i = 0; i < 26; ++i) {
        std::cout << static_cast<char>('a' + i);
    }
    std::cout << std::endl;

    for (int i = 0; i < 26; ++i) {
        if (i + 1 < 10) {
            std::cout << (i + 1) << " ";
        }
        else {
            std::cout << (i + 1);
        }

     
        for (int j = 0; j < 26; ++j) {  
            char c = 'A' + (i + j) % 26;
            std::cout << c;
        }
        std::cout << std::endl;
    }

    return 0;
}

任务7

// 现代C++标准库、算法库体验
// 本例用到以下内容:
// 1. 字符串string, 动态数组容器类vector、迭代器
// 2. 算法库：反转元素次序、旋转元素
// 3. 函数模板、const引用作为形参

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

// 模板函数声明
template<typename T>
void output(const T &c);

void test1();
void test2();
void test3();

int main() {
    std::cout << "测试1: \n";
    test1();

    std::cout << "\n测试2: \n";
    test2();

    std::cout << "\n测试3: \n";
    test3();
}

// 输出容器对象c中的元素
template <typename T>
void output(const T &c) {
    for(auto &i : c)
        std::cout << i << ' ';
    std::cout << '\n';
}

// 测试1：组合使用算法库、迭代器、string反转字符串
void test1() {
    using namespace std;

    string s0{"0123456789"};
    cout << "s0 = " << s0 << endl;

    string s1(s0);
    // 反转s1自身
    reverse(s1.begin(), s1.end());  
    cout << "s1 = " << s1 << endl;

    string s2(s0.size(), ' ');
    // 将s0反转后结果拷贝到s2, s0自身不变
    reverse_copy(s0.begin(), s0.end(), s2.begin()); 
    cout << "s2 = " << s2 << endl;
}

// 测试2：组合使用算法库、迭代器、vector反转动态数组对象vector内数据
void test2() {
    using namespace std;

    vector<int> v0{2, 0, 4, 9};
    cout << "v0: "; output(v0);

    vector<int> v1{v0};
    reverse(v1.begin(), v1.end());
    cout << "v1: "; output(v1);

    vector<int> v2{v0};
    reverse_copy(v0.begin(), v0.end(), v2.begin());
    cout << "v2: "; output(v2);
}

// 测试3：组合使用算法库、迭代器、vector实现元素旋转移位
void test3() {
    using namespace std;

    vector<int> v0{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    cout << "v0: "; output(v0);

    vector<int> v1{v0};
    // 将[v1.begin(), v1.end())区间内元素循环左移1位
    rotate(v1.begin(), v1.begin()+1, v1.end());  
    cout << "v1: "; output(v1);

    vector<int> v2{v0}; 
    // 将[v1.begin(), v1.end())区间内元素循环左移2位
    rotate(v2.begin(), v2.begin()+2, v2.end());  
    cout << "v2: "; output(v2);

    vector<int> v3{v0};
    // 将[v1.begin(), v1.end())区间内元素循环右移1位
    rotate(v3.begin(), v3.end()-1, v3.end()); 
     cout << "v3: "; output(v3);

    vector<int> v4{v0};
    // 将[v1.begin(), v1.end())区间内元素循环右移2位
    rotate(v4.begin(), v4.end()-2, v4.end()); 
    cout << "v4: "; output(v4);
}