练习题（2024/4/6）

1最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

示例 2：

输入：nums = [0,0,0], target = 1
输出：0

思路：

  1. 排序：首先对输入数组进行排序，这样可以使得相同的数字相邻，并且有利于后续的查找和处理过程。

  2. 遍历：遍历排序后的数组，对每个元素作为基准，使用双指针技巧来找到与目标值最接近的三个数的和。

  3. 双指针：在每次遍历中，设置两个指针，一个从当前元素的下一个位置开始，另一个从数组末尾开始。这两个指针向中间移动，以便在遍历过程中快速定位和处理。

  4. 计算和比较：计算当前三个数的和，并与目标值进行比较。根据比较结果，移动指针以调整三个数的选择，使得和尽可能接近目标值。

  5. 更新答案：在每次计算得到一个三个数的和之后，比较当前和与目标值之间的绝对差与当前答案与目标值之间的绝对差。如果当前和更接近目标值，则更新答案为当前和。

  6. 返回结果：最终返回找到的最接近目标值的三个数的和作为结果。

代码：

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        // 初始化答案为前三个数字的和
        int ans = nums[0] + nums[1] + nums[2];
        
        // 对输入数组进行排序
        sort(nums.begin(), nums.end());
        
        // 遍历数组
        for (int i = 0; i < nums.size(); i++) {
            // 设置两个指针，一个在数组起始，一个在数组末尾
            int start = i + 1, end = nums.size() - 1;
            
            // 将指针向中间移动
            while (start < end) {
                // 计算三个数字的和
                int sum = nums[start] + nums[end] + nums[i];
                
                // 如果和等于目标值，则返回目标值
                if (sum == target)  
                    return target;
                
                // 如果当前和与目标值的绝对差小于当前答案与目标值的绝对差，
                // 则更新答案为当前和
                if (abs(sum - target) < abs(ans - target)) 
                    ans = sum;
                
                // 根据当前和与目标值的比较，移动指针
                if (sum < target) 
                    start++;
                else 
                    end--;
            }
        }
        // 返回找到的最接近目标值的和
        return ans;
    }
};

2电话号码的字母组合 

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

提示：

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字。
回溯算法思路：

从示例上来说，输入"23"，最直接的想法就是两层for循环遍历了吧，正好把组合的情况都输出了。

如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环.

此时又是回溯法登场的时候了。

理解本题后，要解决如下三个问题：

  1. 数字和字母如何映射
  2. 两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来
  3. 输入1 * #按键等等异常情况

数字和字母如何映射

可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射，我这里定义一个二维数组，代码如下

const string letterMap[10] = {
    "", // 0
    "", // 1
    "abc", // 2
    "def", // 3
    "ghi", // 4
    "jkl", // 5
    "mno", // 6
    "pqrs", // 7
    "tuv", // 8
    "wxyz", // 9
};
回溯法来解决n个for循环的问题

例如：输入："23"，抽象为树形结构，如图所示

图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。

接下来就是回溯三部曲：

1确定回溯函数参数

首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。

再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

2确定终止条件

例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。

那么终止条件就是如果index 等于 输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。

然后收集结果，结束本层递归。

3  确定单层遍历逻辑

首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）

总体来说解题过程如下：

  1. 确定问题状态：首先，需要确定问题的状态，即每一层递归中需要处理的变量或参数。在 n 个嵌套的 for 循环中，通常每个循环都对应一个状态。

  2. 编写回溯函数：编写一个递归的回溯函数，它接受当前处理的状态以及当前处理到的层数作为参数。在每一层递归中，根据当前状态确定下一步的可能选择，并递归调用自身处理下一层状态。

  3. 确定递归结束条件：在编写回溯函数时，需要确定递归的结束条件。通常是达到了问题的边界条件或者处理完所有状态。

  4. 初始化和清理工作：在调用回溯函数之前，进行一些初始化工作，例如设置初始状态或者结果集。在回溯函数内部，可能需要进行一些清理工作，例如撤销当前状态的改变。

  5. 调用入口函数：编写一个入口函数，进行一些预处理工作后，调用回溯函数开始解决问题。

回溯法的关键在于，在每一步决策之后，都要进行回溯，即撤销上一步的选择，尝试其他可能的选择，直到找到所有解或者达到边界条件为止。

代码如下：


class Solution {
private:
    const string letterMap[10] = {
        "",      // 0 对应空字符，通常不会输入0，故而不用处理
        "",      // 1 对应空字符，通常不会输入1，故而不用处理
        "abc",   // 2 对应字符集"abc"
        "def",   // 3 对应字符集"def"
        "ghi",   // 4 对应字符集"ghi"
        "jkl",   // 5 对应字符集"jkl"
        "mno",   // 6 对应字符集"mno"
        "pqrs",  // 7 对应字符集"pqrs"
        "tuv",   // 8 对应字符集"tuv"
        "wxyz"   // 9 对应字符集"wxyz"
    };
public:
    vector<string> result;   // 存储结果的容器
    string s;                // 当前组合的字符串
    void backtracking(const string& digits, int index) {
        if (index == digits.size()) {  // 当组合长度等于数字串长度时，表示得到一个完整的组合
            result.push_back(s);       // 将当前组合加入结果集
            return;
        }
        int digit = digits[index] - '0';       // 将当前数字字符转换为整数
        string letters = letterMap[digit];     // 获取当前数字对应的字符集
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);           // 将当前字符加入组合字符串
            backtracking(digits, index + 1);   // 递归处理下一个数字
            s.pop_back();                      // 回溯，移除最后一个字符，尝试下一个字符
        }
    }
    vector<string> letterCombinations(string digits) {
        s.clear();          // 清空当前组合字符串
        result.clear();     // 清空结果集
        if (digits.size() == 0) {
            return result;  // 如果输入数字串为空，则直接返回空结果
        }
        backtracking(digits, 0);   // 调用回溯函数，从第一个数字开始生成组合
        return result;             // 返回最终结果
    }
};

 

 3 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

  • 0 <= a, b, c, d < n
  • a、b、c 和 d 互不相同
  • nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2

思路：

解决四数之和问题可以使用回溯算法的思想，但实际上更常用的是双指针法。下面我将简要介绍使用双指针法解决四数之和问题的思路：

  1. 排序数组：首先对给定的数组进行排序。这一步是为了方便后续的双指针移动，并且可以减少重复元素的考虑。

  2. 双指针遍历：使用两层循环来固定前两个数，在内层循环中使用双指针技巧来寻找后两个数。在双指针移动时，根据当前四数之和与目标值的大小关系来调整指针的移动方向，以尽量接近目标值。

  3. 跳过重复元素：在移动指针时，需要跳过重复元素，以避免重复的解。

  4. 收集结果：当找到一组满足条件的四个数时，将其加入结果集中。继续遍历直到完成所有可能的组合。

代码：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end()); // 对数组进行排序

        for (int k = 0; k < nums.size(); k++) {
            // 剪枝处理：如果当前数字大于目标且为正数，跳出循环，统一通过最后的return返回结果
            if (nums[k] > target && nums[k] >= 0) {
                break;
            }

            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }

            for (int i = k + 1; i < nums.size(); i++) {
                // 2级剪枝处理：如果当前两个数字之和大于目标且为正数，跳出循环
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }

                // 对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }

                int left = i + 1;
                int right = nums.size() - 1;

                while (right > left) {
                    // 避免四数相加可能的整数溢出，使用long类型转换
                    long sum = static_cast<long>(nums[k]) + nums[i] + nums[left] + nums[right];

                    if (sum > target) {
                        right--; // 如果和大于目标值，向左移动右指针
                    } else if (sum < target) {
                        left++; // 如果和小于目标值，向右移动左指针
                    } else {
                        // 找到答案时，将四个数添加到结果集中
                        result.push_back({nums[k], nums[i], nums[left], nums[right]});

                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        // 找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }
            }
        }
        return result; // 返回结果集
    }
};

4游戏玩法分析 I

SQL Schema

Pandas Schema

活动表 Activity：

+--------------+---------+
| Column Name  | Type    |
+--------------+---------+
| player_id    | int     |
| device_id    | int     |
| event_date   | date    |
| games_played | int     |
+--------------+---------+
在 SQL 中，表的主键是 (player_id, event_date)。
这张表展示了一些游戏玩家在游戏平台上的行为活动。
每行数据记录了一名玩家在退出平台之前，当天使用同一台设备登录平台后打开的游戏的数目（可能是 0 个）。

查询每位玩家 第一次登录平台的日期。

查询结果的格式如下所示：

Activity 表：
+-----------+-----------+------------+--------------+
| player_id | device_id | event_date | games_played |
+-----------+-----------+------------+--------------+
| 1         | 2         | 2016-03-01 | 5            |
| 1         | 2         | 2016-05-02 | 6            |
| 2         | 3         | 2017-06-25 | 1            |
| 3         | 1         | 2016-03-02 | 0            |
| 3         | 4         | 2018-07-03 | 5            |
+-----------+-----------+------------+--------------+

Result 表：
+-----------+-------------+
| player_id | first_login |
+-----------+-------------+
| 1         | 2016-03-01  |
| 2         | 2017-06-25  |
| 3         | 2016-03-02  |
+-----------+-------------+

思路：从名为Activity的表中选择每个player_id的最早登录时间。为了实现这个目标，我们使用了SQL中的MIN函数，它可以找到给定列中的最小值，这里是event_date，即登录时间。然后，通过GROUP BY子句按照player_id对数据进行分组，以便获取每个player_id的最早登录时间。

代码：

-- 从Activity表中选取每个player_id的最早登录时间
select 
    player_id,          -- 选取player_id
    min(event_date) AS first_login -- 使用MIN函数获取每个player_id的最早登录时间，并将其命名为first_login
from
    Activity -- 从Activity表中查询数据
group by
    player_id; -- 按照player_id进行分组，以便获取每个player_id的最早登录时间

 5游戏玩法分析 IV

Table: Activity

+--------------+---------+
| Column Name  | Type    |
+--------------+---------+
| player_id    | int     |
| device_id    | int     |
| event_date   | date    |
| games_played | int     |
+--------------+---------+
（player_id，event_date）是此表的主键（具有唯一值的列的组合）。
这张表显示了某些游戏的玩家的活动情况。
每一行是一个玩家的记录，他在某一天使用某个设备注销之前登录并玩了很多游戏（可能是 0）。

编写解决方案，报告在首次登录的第二天再次登录的玩家的 比率，四舍五入到小数点后两位。换句话说，你需要计算从首次登录日期开始至少连续两天登录的玩家的数量，然后除以玩家总数。

结果格式如下所示：

示例 1：

输入：
Activity table:
+-----------+-----------+------------+--------------+
| player_id | device_id | event_date | games_played |
+-----------+-----------+------------+--------------+
| 1         | 2         | 2016-03-01 | 5            |
| 1         | 2         | 2016-03-02 | 6            |
| 2         | 3         | 2017-06-25 | 1            |
| 3         | 1         | 2016-03-02 | 0            |
| 3         | 4         | 2018-07-03 | 5            |
+-----------+-----------+------------+--------------+
输出：
+-----------+
| fraction  |
+-----------+
| 0.33      |
+-----------+
解释：
只有 ID 为 1 的玩家在第一天登录后才重新登录，所以答案是 1/3 = 0.33

思路：

  1. 首先，使用子查询计算出Activity表中不同玩家的数量。
  2. 然后，通过将Activity表与子查询的结果进行内连接，找出每个玩家参与活动的最早日期。
  3. 接着，在where子句中，筛选出满足条件“活动日期与最早日期相差1天”的记录。
  4. 最后，通过计算连续两天参与活动的玩家数量与总玩家数量的比值，并保留两位小数，得到这一比例。

代码：

-- 计算在activity表中，第二天登录的玩家所占的比例

select 
    round(
        count(a.player_id) / (select count(distinct player_id) from activity), -- 计算第二天登录的玩家数量占总玩家数量的比例，并使用round函数四舍五入保留两位小数
        2
    ) as fraction -- 将计算出的比例保留两位小数，并且作为别名命名为fraction
from 
    activity a -- 为activity表起别名a，以便在查询中引用
join 
    (
        -- 获取每个玩家的最早登录时间
        select 
            player_id, -- 选择玩家ID字段
            min(event_date) as mindate -- 使用min函数找到每个玩家的最早登录时间，并且给这一列起别名为mindate
        from 
            activity -- 从activity表中获取数据
        group by 
            player_id -- 根据玩家ID进行分组
    ) t on a.player_id = t.player_id -- 将activity表与子查询结果进行内连接，通过玩家ID进行关联
-- 仅选择第二天登录的记录
where 
    datediff(a.event_date, t.mindate) = 1; -- 使用datediff函数计算登录日期与最早登录时间相差的天数，如果相差一天则表示第二天登录

6至少有5名直接下属的经理

SQL Schema

Pandas Schema

表: Employee

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| id          | int     |
| name        | varchar |
| department  | varchar |
| managerId   | int     |
+-------------+---------+
id 是此表的主键（具有唯一值的列）。
该表的每一行表示雇员的名字、他们的部门和他们的经理的id。
如果managerId为空，则该员工没有经理。
没有员工会成为自己的管理者。

编写一个解决方案，找出至少有五个直接下属的经理。

以 任意顺序 返回结果表。

查询结果格式如下所示。

示例 1:

输入: 
Employee 表:
+-----+-------+------------+-----------+
| id  | name  | department | managerId |
+-----+-------+------------+-----------+
| 101 | John  | A          | Null      |
| 102 | Dan   | A          | 101       |
| 103 | James | A          | 101       |
| 104 | Amy   | A          | 101       |
| 105 | Anne  | A          | 101       |
| 106 | Ron   | B          | 101       |
+-----+-------+------------+-----------+
输出: 
+------+
| name |
+------+
| John |
+------+

思路：首先，内部子查询通过对员工表按照经理ID进行分组，并用COUNT函数统计每个经理ID出现的次数，即其直接下属的人数。然后，使用HAVING子句筛选出直接下属人数至少为5人的经理ID。最外层的主查询使用IN操作符，从员工表中选择经理ID在内部子查询结果中的员工记录，并返回这些经理的姓名

代码：



select name -- 选择姓名字段
from employee -- 从employee表中查询
where id in ( -- 筛选出经理ID在子查询结果中的员工记录
    select distinct managerid -- 选择去重后的经理ID
    from employee -- 从employee表中查询
    group by managerid -- 按经理ID分组
    having count(managerid) >= 5 -- 筛选出直接下属人数至少为5人的经理ID
); -- 结束主查询

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/520379.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Linux】shell 脚本基础使用

【Linux】shell 脚本基础使用

在终端中输入命令可以完成一些常用的操作&#xff0c;但是我们都是一条一条输入命令&#xff0c;比较麻烦&#xff0c;为了解决这个问题&#xff0c;就会涉及到 shell 脚本&#xff0c;它可以将很多条命令放到一个文件里面&#xff0c;然后直接运行这个文件即可。 shell 脚本类…
阅读更多...
STM32单片机智能手环心率计步器体温

STM32单片机智能手环心率计步器体温

简介 STM32F103C8T6单片机核心板电路、ADXL345传感器电路、心率传感器电路、温度传感器和lcd1602电路组成。通过重力加速度传感器ADXL345检测人的状态&#xff0c;计算出走路步数、走路距离和平均速度。过心率传感器实时检测心率&#xff0c;通过温度传感器检测温度。通过LCD16…
阅读更多...
基于springboot实现教师人事档案管理系统项目【项目源码+论文说明】

基于springboot实现教师人事档案管理系统项目【项目源码+论文说明】

基于springboot实现在线商城系统演示 摘要 现代经济快节奏发展以及不断完善升级的信息化技术&#xff0c;让传统数据信息的管理升级为软件存储&#xff0c;归纳&#xff0c;集中处理数据信息的管理方式。本ONLY在线商城系统就是在这样的大环境下诞生&#xff0c;其可以帮助管理…
阅读更多...
ZYNQ学习之Petalinux 设计流程实战

ZYNQ学习之Petalinux 设计流程实战

基本都是摘抄正点原子的文章&#xff1a;<领航者 ZYNQ 之嵌入式Linux 开发指南 V3.2.pdf&#xff0c;因初次学习&#xff0c;仅作学习摘录之用&#xff0c;有不懂之处后续会继续更新~ PetaLinux工具提供了在 Xilinx 处理系统上自定义、构建和部署嵌入式 Linux 解决方案所需的…
阅读更多...
单链表学习

单链表学习

//静态链表&#xff0c;只往后看&#xff0c;找前面必须遍历 //算法题用数组解题更快速 //初始化,头节点为空 //将x插入到头节点 //将x插到结点k的后面 //将下标k的后面的点删掉 #include<algorithm> #include<iostream> #include<cstring> #include<queu…
阅读更多...
STL —— list

STL —— list

博主首页&#xff1a; 有趣的中国人 专栏首页&#xff1a; C专栏 本篇文章主要讲解 list模拟实现的相关内容 &#xff11;. list简介 列表&#xff08;list&#xff09;是C标准模板库&#xff08;STL&#xff09;中的一个容器&#xff0c;它是一个双向链表数据结构&#xff0c…
阅读更多...
嵌入式开发学习---（部分）数据结构（无代码）

嵌入式开发学习---（部分）数据结构（无代码）

数据结构 为什么学习数据结构&#xff1f; 1&#xff09;c语言告诉如何写程序&#xff0c;数据结构是如何简洁高效的写程序 2&#xff09;遇到一个实际问题&#xff0c;需要写程序去实现相应功能&#xff0c;需要解决那两个方面的问题&#xff1f; 如何表达数据之间的逻辑规律…
阅读更多...
20240327-PCL-1.41.0安装说明-VS2022-CMAKE篇

20240327-PCL-1.41.0安装说明-VS2022-CMAKE篇

20240327-PCL-1.41.0安装说明-VS2022-CMAKE篇 一、软件环境 Win10 x64 22h2 Junecmake 3.29.1VSCODE v1.87.2GIT v2.29.2标签&#xff1a;win10 22h2 vscode cmake分栏&#xff1a;C 二、硬件环境 Win10 x64的PC台式机 三、下载最新版本PCL-1.41.0 方法一 https://githu…
阅读更多...
上市公司股权性质演变：2000-2022年集中度数据深度剖析（5W+数据）

上市公司股权性质演变：2000-2022年集中度数据深度剖析（5W+数据）

01、数据介绍 股权性质主要指的是股份公司中不同性质的股东即股权所有人的身份&#xff0c;以及他们各自持有的股份比例。在我国&#xff0c;股权性质通常涉及国家股东、法人股东&#xff08;包括机构投资者&#xff09;和流通股东等。 股权集中度则是反映公司股东对管理者的…
阅读更多...
博客部署004-成功截图

博客部署004-成功截图

1、前台client 2、后台管理admin 3、后端API
阅读更多...
【Docker】搭建开源免费的书签管理系统 - OneNav

【Docker】搭建开源免费的书签管理系统 - OneNav

【Docker】搭建开源免费的书签管理系统 - OneNav 前言 本教程基于绿联的NAS设备DX4600 Pro的docker功能进行搭建。 简介 OneNav是一个基于PHP的轻量级网址导航系统&#xff0c;旨在帮助用户整理和访问他们的常用网站。 OneNav的主要特点如下&#xff1a; 美观易用&#x…
阅读更多...
【Unity音游制作】音符和音符对象池的创建【二】

【Unity音游制作】音符和音符对象池的创建【二】

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;元宇宙-秩沅 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 秩沅 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a;Uni…
阅读更多...
【Spring进阶系列丨第七篇】Spring框架新注解分类及详解

【Spring进阶系列丨第七篇】Spring框架新注解分类及详解

文章目录 一、Spring新注解1.1、Configuration注解1.1.1、定义一个类1.1.2、使用Configuration注解修饰类1.1.3、作用 1.2、Bean注解1.2.1、定义bean1.2.2、在主配置类中注册bean1.2.3、测试容器中是否有该bean1.2.4、注册bean的同时可以指定bean名称1.2.5、补充内容1.2.5.1、案…
阅读更多...
初始Java篇（JavaSE基础语法）（6）（继承和多态）（上）

初始Java篇（JavaSE基础语法）（6）（继承和多态）（上）

Java学习篇 个人主页&#xff08;找往期文章包括但不限于本期文章中不懂的知识点&#xff09;&#xff1a;我要学编程(ಥ_ಥ)-CSDN博客 目录 继承篇 为什么需要继承&#xff1f; 继承概念 继承的语法 父类成员访问 super关键字 子类构造方法 super和this的比较 再谈…
阅读更多...
柯桥外语机构商务英语学习，“五星级”酒店到底是five star还是five stars？这个千万别搞错！

柯桥外语机构商务英语学习，“五星级”酒店到底是five star还是five stars？这个千万别搞错！

“五星级酒店”的英语表达 关于酒店&#xff0c;大家都知道有星级之分&#xff1b;其中&#xff0c;最高级的酒店当属“五星级”了&#xff1b; 那么问题来了&#xff0c;这个“五星级”的英语&#xff0c;究竟是“five star”&#xff0c;还是“five stars”呢&#xff1f; 其…
阅读更多...
11_Spring-IOC/DI

11_Spring-IOC/DI

文章目录 SpringIOC控制反转&#xff08;存&#xff09;DI依赖注入&#xff08;取&#xff09;Spring的优点Spring的核心技术入门案例入门案例1入门案例2 注解配置类组件注册功能&#xff08;IOC&#xff09;类直接注册配置类中注册&#xff08;JavaConfig&#xff09; 组件注入…
阅读更多...
Premiere Pro 2024：赋予创意翅膀，让你的视频飞翔 mac/win版

Premiere Pro 2024：赋予创意翅膀，让你的视频飞翔 mac/win版

Premiere Pro 2024&#xff0c;作为Adobe旗下的旗舰视频编辑软件&#xff0c;自推出以来&#xff0c;一直在视频制作领域占据着重要的地位。随着技术的不断进步和创新&#xff0c;Premiere Pro 2024为用户带来了前所未有的编辑体验&#xff0c;重新定义了视频制作的标准。 Pre…
阅读更多...
网络原理 - HTTP / HTTPS(5)——https协议

网络原理 - HTTP / HTTPS(5)——https协议

目录 一、HTTPS是什么 为什么要进行加密 二、“加密” 是什么 三、HTTPS的工作过程 &#xff08;1&#xff09;引入对称加密 对称密钥的特点&#xff1a; &#xff08;2&#xff09;引入非对称加密 非对称加密的特点&#xff1a; &#xff08;3&#xff09;中间人攻击…
阅读更多...
【C++】STL--vector

【C++】STL--vector

目录 vector的使用 vector的定义 vector iterator的使用 vector空间增长问题 vector增删查改 vector深度剖析及模拟实现 vector核心接口模拟实现 使用memcpy拷贝问题 迭代器失效问题 vector的使用 vector的定义 C中&#xff0c;vector是一个模版&#xff0c;第一个参…
阅读更多...
PHP数据类型

PHP数据类型

华子目录 数据类型PHP的八种数据类型基本数据类型&#xff0c;4类复合数据类型&#xff0c;2类特殊数据类型&#xff0c;2类 类型转换在PHP中有两种类型转换方式其他类型转bool类型其他类型转数值类型实例 类型判断获取和设定变量类型获取gettype(变量名)设置settype(变量名,类…
阅读更多...
最新文章

Copyright @ 2022~2023