leetcode17 电话号码的字母组合

news2024/10/1 17:23:07

方法1 if-else方法 

if-else方法的思路及其简单粗暴，如下图所示，以数字234为例，数字2所对应的字母是abc，数字3所对应的是def，数字4所对应的是ghi，最后所产生的结果就类似于我们中学所学过的树状图一样，从左到右的一组一组生成结果，首先取出数字2的第一个索引对应的a，然后紧接着添加数字3对应的第一个索引的字母d，然后再添加数字4所对应的ghi，分别组成adg、adh、adi，然后一直进行排列组合，直到把所有的结果都列举完，那么就程序就执行完了。

python完整代码：

class Solution:
    def letterCombinations(self, digits):
        # 获取输入数字串的长度
        n = len(digits)
        result = []  # 用于存储最终的字母组合结果
        if n == 0:
            return result  # 如果输入为空字符串，则直接返回空列表

        for i in range(n):
            self.AddString(result, digits[i])

        return result

    def AddString(self, result, t):  # 定义一个添加字符串的函数
        n = len(result)
        letters = ""
        if t == '2':
            letters = "abc"
        elif t == '3':
            letters = "def"
        elif t == '4':
            letters = "ghi"
        elif t == '5':
            letters = "jkl"
        elif t == '6':
            letters = "mno"
        elif t == '7':
            letters = "pqrs"
        elif t == '8':
            letters = "tuv"
        elif t == '9':
            letters = "wxyz"

        if n == 0:
            result.extend(list(letters))  # 如果结果集为空，直接添加第一个数字对应的字母
        else:
            temp_result = []
            for i in range(n):  # i表示第一个数字所对应的字母的位置
                for letter in letters:
                    # 将当前结果集中的每个组合与新的字母组合，得到新的结果集
                    temp_result.append(result[i] + letter)
            result[:] = temp_result  # 用新的结果集替换原有结果集


if __name__ == "__main__":
    solution = Solution()
    combinations = solution.letterCombinations("234")
    print(combinations)

c++完整代码： 

#include<iostream>
#include<vector>

using namespace std;

class Solution{
public:
    vector<string> letterCombinations(string digits){
        int n = digits.length();  //获取输入数字串的长度
        vector<string> result; //用于存储最终的字母组合结果
        if(n == 0){
            return result;
        }
        for(int i=0;i<n;++i){
            AddString(result, digits[i]);  // 调用添加字母函数
        }
        return result;
    }
private:
    void AddString(vector<string>& result, char digit){
        int n = result.size();
        string letters = "";
        if (digit == '2'){
            letters = "abc";
        } else if(digit == '3'){
            letters = "def";
        } else if(digit == '4'){
            letters = "ghi";
        } else if(digit == '5') {
            letters = "jkl";
        } else if(digit == '6'){
            letters = "mno";
        } else if(digit == '7'){
            letters = "pqrs";
        } else if(digit == '8'){
            letters = "tuv";
        } else if(digit == '9'){
            letters = "wxyz";
        }
        if (n == 0){
            for(char letter : letters){
                result.push_back(string(1, letter));
                // 如果结果集为空，直接添加第一个数字对应的字母
            }
        } else{
           vector<string> temp_result;
           for(int i = 0;i < n; ++i){
               for(char letter : letters){
                   // 将当前结果集中的每个组合与新的字母组合，得到新的结果集
                   temp_result.push_back(result[i] + letter);
               }
           }
           result = temp_result; // 用新的结果集替换原有结果集
        }
    }
};

int main(){
    Solution solution;
    vector<string> combinations = solution.letterCombinations("234");
    for(const auto& combination : combinations){
        cout << combination << endl;
    }
    return 0;
}

java完整代码：  

import java.util.List;
import java.util.ArrayList;
public class LetterCombinations {
    public List<String> letterCombinations(String digits) {
        // 获取输入数字串的长度
        int n = digits.length();
        // 用于存储最终的字母组合结果
        List<String> list = new ArrayList();
        // 如果输入为空字符串，则直接返回空列表
        if (n == 0) {
            return list;
        }

        // 遍历每个数字字符
        for (int i = 0; i < n; i++) {
            // 调用 StringAdd 函数处理每个数字对应的字母
            StringAdd(list, digits.charAt(i));
        }
        return list;
    }

    // 定义一个添加字符串的函数
    public void StringAdd(List<String> list, char t) {
        // 获取当前结果集的长度
        int n = list.size();
        if(t == '2'){  // 处理数字 2 对应的字母组合
            if(n==0){
                list.add("a");
                list.add("b");
                list.add("c");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 'a', 'b', 'c'，得到新的结果集
                    list.add(list.get(i)+"a");
                    list.add(list.get(i)+"b");
                    list.add(list.get(i)+"c");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
            // 3
        }else if(t == '3'){
            if(n==0){
                list.add("d");
                list.add("e");
                list.add("f");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 'd', 'e', 'f'，得到新的结果集
                    list.add(list.get(i)+"d");
                    list.add(list.get(i)+"e");
                    list.add(list.get(i)+"f");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
            // 4
        }else if(t == '4'){
            if(n==0){
                list.add("g");
                list.add("h");
                list.add("i");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 'g', 'h', 'i'，得到新的结果集
                    list.add(list.get(i)+"g");
                    list.add(list.get(i)+"h");
                    list.add(list.get(i)+"i");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
            // 5
        }else if(t == '5'){
            if(n==0){
                list.add("j");
                list.add("k");
                list.add("l");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 'j', 'k', 'l'，得到新的结果
                    list.add(list.get(i)+"j");
                    list.add(list.get(i)+"k");
                    list.add(list.get(i)+"l");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
            // 6
        }else if(t == '6'){
            if(n==0){
                list.add("m");
                list.add("n");
                list.add("o");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 'm', 'n', 'o'，得到新的结果
                    list.add(list.get(i)+"m");
                    list.add(list.get(i)+"n");
                    list.add(list.get(i)+"o");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
            // 7
        }else if(t == '7'){
            if(n==0){
                list.add("p");
                list.add("q");
                list.add("r");
                list.add("s");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 'p', 'q', 'r', 's'，得到新的结果
                    list.add(list.get(i)+"p");
                    list.add(list.get(i)+"q");
                    list.add(list.get(i)+"r");
                    list.add(list.get(i)+"s");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
            // 8
        }else if(t == '8'){
            if(n==0){
                list.add("t");
                list.add("u");
                list.add("v");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 't', 'u', 'v'，得到新的结果
                    list.add(list.get(i)+"t");
                    list.add(list.get(i)+"u");
                    list.add(list.get(i)+"v");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
            // 9
        }else if(t == '9'){
            if(n==0){
                list.add("w");
                list.add("x");
                list.add("y");
                list.add("z");
            }else{
                for(int i=0;i<n;i++){
                    // 遍历当前结果集，为每个组合添加 'w', 'x', 'y', 'z'，得到新的结果
                    list.add(list.get(i)+"w");
                    list.add(list.get(i)+"x");
                    list.add(list.get(i)+"y");
                    list.add(list.get(i)+"z");
                }
                for(int i=0;i<n;i++){
                    list.remove(0);
                }
            }
        }
    }
    public static void main(String[] args){
        LetterCombinations solution = new LetterCombinations();
        List<String> combinations = solution.letterCombinations("234");
        System.out.println(combinations);
    }
}

方法2 回溯法 

上面我们讨论了通过列举的方法生成结果，但是发现程序写起来实在是太长了，而且看着很low，那么此时我们就可以把数字组合里面每一个数字所对应的字母组合通过一个篮子（哈希表）存起来，要用哪个就拿哪一个，紧接着再通过回溯的方法进行解决，以下是chatgpt所回答的回溯算法：

回溯算法（Backtracking）是一种通过尝试所有可能的候选解并在找到可行解之前放弃部分（或全部）解空间的策略。在问题的解空间中，通过深度优先搜索，一步一步地探索各个可能的解，当发现当前的部分解不能满足问题的约束条件时，就放弃该部分解，回溯到上一步，继续搜索其他可能的解。

回溯算法通常采用递归的方式实现，每一层递归代表问题的一个阶段，通过递归的深入，逐步构建出问题的解。在搜索过程中，如果当前解不满足问题的条件，则回溯到上一步，尝试其他可能的选择。

典型的回溯问题包括组合问题、排列问题、子集问题等。回溯算法通常用于解决组合优化问题，其中问题的解是某种组合的集合，而且问题通常可以分解为多个子问题，通过递归地解决子问题来构建整体的解。

关键特点：

  1. 状态空间树： 回溯算法可以通过状态空间树的形式进行表示，每个节点代表问题的一个阶段，树的每一层对应算法的一个递归调用。
  2. 深度优先搜索： 回溯算法采用深度优先搜索的策略，即一条路走到底，如果发现当前路径不能满足问题的条件，就回溯到上一步。
  3. 剪枝： 在搜索的过程中，可以通过剪枝来减少搜索空间，提高效率。当发现当前部分解无法满足问题的条件时，可以提前结束搜索。

经典的回溯问题包括八皇后问题、0-1背包问题、图的着色问题等。回溯算法的复杂度通常比较高，因此在设计时需要注意优化搜索空间以提高效率。

但是本题不存在不可行的解，所以通过穷举的方法就可以实现。该方法的思路和上述的方法基本上是一致的。

python完整代码：

class Solution:
    def letterCombinations(self, digits):
        # 如果输入为空，则直接返回空列表
        if not digits:
            return list()
        # 定义电话号码到字母的映射关系
        phoneMap = {
            "2": "abc",
            "3": "def",
            "4": "ghi",
            "5": "jkl",
            "6": "mno",
            "7": "pqrs",
            "8": "tuv",
            "9": "wxyz",
        }
        def backtrack(index):
           # 当前组合字符串长度等于输入数字串长度时，将其加入结果集
           if index == len(digits):
               combinations.append("".join(combination))  # 获取当前数字对应的字母集合
           else:
               digit = digits[index]  # 将当前字母加入组合字符串，递归调用下一层
               for letter in phoneMap[digit]:
                   combination.append(letter)
                   backtrack(index + 1)
                   # pop()函数用于移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
                   combination.pop()  # 当combinations里面存有adg，紧接着执行for letter in phoneMap[digit]:其中digit=4

        combination = list()  # 初始化组合列表和当前组合字符串
        combinations = list()
        backtrack(0)  # 初始调用回溯函数
        return combinations

if __name__ == "__main__":
    # 创建 Solution 对象
    solution = Solution()
    # 调用 letterCombinations 函数并输出结果
    combinations = solution.letterCombinations("234")
    print(combinations)
class Solution:
    def letterCombinations(self, digits):
        # 如果输入为空，则直接返回空列表
        if not digits:
            return list()
        # 定义电话号码到字母的映射关系
        phoneMap = {
            "2": "abc",
            "3": "def",
            "4": "ghi",
            "5": "jkl",
            "6": "mno",
            "7": "pqrs",
            "8": "tuv",
            "9": "wxyz",
        }
        def backtrack(index):
           # 当前组合字符串长度等于输入数字串长度时，将其加入结果集
           if index == len(digits):
               combinations.append("".join(combination))  # 获取当前数字对应的字母集合
           else:
               digit = digits[index]  # 将当前字母加入组合字符串，递归调用下一层
               for letter in phoneMap[digit]:
                   combination.append(letter)
                   backtrack(index + 1)
                   # pop()函数用于移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
                   combination.pop()  # 当combinations里面存有adg，紧接着执行for letter in phoneMap[digit]:其中digit=4

        combination = list()  # 初始化组合列表和当前组合字符串
        combinations = list()
        backtrack(0)  # 初始调用回溯函数
        return combinations

if __name__ == "__main__":
    # 创建 Solution 对象
    solution = Solution()
    # 调用 letterCombinations 函数并输出结果
    combinations = solution.letterCombinations("234")
    print(combinations)

c++完整代码：

#include<iostream>
#include<vector>
#include<unordered_map>

using namespace std;

class Solution{
public:
    vector<string> letterCombination(string digits){
        unordered_map<char, string> phoneMap = { // 定义数字对应的字母映射关系
                {'2', "abc"},
                {'3', "def"},
                {'4', "ghi"},
                {'5', "jkl"},
                {'6', "mno"},
                {'7', "pqrs"},
                {'8', "tuv"},
                {'9', "wxyz"}
        };
        // 处理特殊情况，如果输入为空字符串，则直接返回空列表
        if(digits.empty()){
            return vector<string> ();
        }
        // 用于存储最终的字母组合结果
        vector<string> result;
        // 回溯函数，参数分别为当前数字索引和当前已形成的组合字符串
        backtrack(digits,0,"",phoneMap,result);  
        //可以试试index等于1是什么结果，就能明白该参数具体指的是什么
        
        return result;
    }
private:
    // index ---> 数字所对应字母的索引
    void backtrack(const string& digits, int index, const string& path,
                   const unordered_map<char, string>& phoneMap, vector<string>& result){
        // 如果当前组合字符串的长度等于输入数字串的长度，将其加入结果集
        if(index == digits.length()){
            result.push_back(path);
            return;
        }
        // 获取当前数字对应的字母集合
        char currentDigit = digits[index];
        const string& letters = phoneMap.at(currentDigit);
        // 遍历当前数字对应的字母集合，进行递归回溯
        for(char letter : letters){
            // 将当前字母加入组合字符串，递归调用下一层
            backtrack(digits, index + 1, path + letter, phoneMap, result);
        }
    }
};

int main(){
    // 创建 Solution 对象
    Solution solution;
    // 调用 letterCombinations 函数并输出结果
    vector<string> combinations = solution.letterCombination("234");
    for(const string& combination : combinations){
        cout << combination << "" << endl;
    }
    return 0;
}

java完整代码：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class letterCombinations_1 {
    public List<String> letterCombinations(String digits) {
        Map<Character, String> phoneMap = new HashMap<>(); // 定义数字对应的字母映射关系
        phoneMap.put('2', "abc");
        phoneMap.put('3', "def");
        phoneMap.put('4', "ghi");
        phoneMap.put('5', "jkl");
        phoneMap.put('6', "mno");
        phoneMap.put('7', "pqrs");
        phoneMap.put('8', "tuv");
        phoneMap.put('9', "wxyz");

        // 处理特殊情况，如果输入为空字符串，则直接返回空列表
        if (digits == null || digits.isEmpty()) {
            return new ArrayList<>();
        }

        // 用于存储最终的字母组合结果
        List<String> result = new ArrayList<>();
        // 回溯函数，参数分别为当前数字索引和当前已形成的组合字符串
        backtrack(digits, 0, "", phoneMap, result);

        return result;
    }

    private void backtrack(String digits, int index, String path,
                           Map<Character, String> phoneMap, List<String> result) {
        // 如果当前组合字符串的长度等于输入数字串的长度，将其加入结果集
        if (index == digits.length()) {
            result.add(path);
            return;
        }

        // 获取当前数字对应的字母集合
        char currentDigit = digits.charAt(index);
        String letters = phoneMap.get(currentDigit);

        // 遍历当前数字对应的字母集合，进行递归回溯
        for (char letter : letters.toCharArray()) {
            // 将当前字母加入组合字符串，递归调用下一层
            backtrack(digits, index + 1, path + letter, phoneMap, result);
        }
    }

    public static void main(String[] args) {
        // 创建 Solution 对象
        letterCombinations_1 solution = new letterCombinations_1();
        // 调用 letterCombinations 函数并输出结果
        List<String> combinations = solution.letterCombinations("234");
        for (String combination : combinations) {
            System.out.println(combination);
        }
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

VUE指令（一）

VUE指令（一）

vue会根据不同的指令&#xff0c;针对不同的标签实现不同的功能。指令是带有 v- 前缀的特殊标签属性。指令的职责是&#xff0c;当表达式的值改变时&#xff0c;将其产生的连带影响&#xff0c;响应式地作用于 DOM。 1、v-text&#xff1a;设置元素的文本内容&#xff0c;不会解…
阅读更多...
LabVIEW在动态力传感器校准技术的创新应用

LabVIEW在动态力传感器校准技术的创新应用

简介 动态力传感器校准装置集成了冲击法原理和自动化控制&#xff0c;实现精准、高效的传感器校验。LabVIEW的图形化界面提供简便操作和实时数据分析&#xff0c;显著提高了校准过程的准确度和效率。 01 系统设计和功能 动态力传感器在工业生产中发挥着重要作用&#xff0c;其…
阅读更多...
基于SSM的驾校预约管理系统

基于SSM的驾校预约管理系统

基于SSM的驾校预约管理系统的设计与实现~ 开发语言&#xff1a;Java数据库&#xff1a;MySQL技术&#xff1a;SpringSpringMVCMyBatis工具&#xff1a;IDEA/Ecilpse、Navicat、Maven 系统展示 主页 详情 管理员界面 摘要 随着社会的不断发展&#xff0c;驾驶技能的需求逐渐增…
阅读更多...
MySQL入门：DCL数据控制语言（管理用户，权限控制），MySQL函数（字符串，数值，日期，流程）

MySQL入门：DCL数据控制语言（管理用户，权限控制），MySQL函数（字符串，数值，日期，流程）

目录 1.DCL&#xff08;数据控制语言&#xff09;1.管理用户2.权限控制 2.函数1.字符串函数2.数值函数3.日期函数4.流程函数 1.DCL&#xff08;数据控制语言&#xff09; DCL英文全称是Data ControlLanguage(数据控制语言)&#xff0c;用来管理数据库用户、控制数据库的访问权限…
阅读更多...
linux 内存

linux 内存

linux内存分类 按用途分 stack heap(brk,sbrk , mmap), 文件映射&#xff0c; bss&#xff0c; data , text, 还有page cache&#xff0c; slab&#xff08;kmalloc连续&#xff09;, vmalloc等内核深处的。 属性 进程OOM 对于进程来说&#xff0c;堆泄漏在死亡时是没问题 但…
阅读更多...
轻松上手Linux文件操作：五种方法教你创建文件

轻松上手Linux文件操作：五种方法教你创建文件

轻松上手Linux文件操作&#xff1a;五种方法教你创建文件 一、引言二、使用touch命令创建文件三、使用文本编辑器创建文件四、使用echo命令创建文件五、使用cat命令创建文件六、使用重定向符号创建文件七、总结 一、引言 本文介绍五种在Linux系统中创建文件的方法&#xff0c;…
阅读更多...
自制数据库空洞率清理工具-C版-03-EasyClean-V1.2（支持南大通用数据库Gbase8a）

自制数据库空洞率清理工具-C版-03-EasyClean-V1.2（支持南大通用数据库Gbase8a）

目录 一、环境信息 二、简述 三、升级点 四、支持功能 五、空洞率 六、工具流程图 1、流程描述 2、注意点 &#xff08;1&#xff09;方法一 &#xff08;2&#xff09;方法二 七、清理空洞率流程图 八、安装包下载地址 九、参数介绍 1、命令模板 2、命令样例 3…
阅读更多...
Jmeter接口自动化03-JMeter的常用核心组件

Jmeter接口自动化03-JMeter的常用核心组件

p03 高清B站视频链接 由于JMeter涉及的组件数目很多&#xff0c;据不完全统计至少有110个&#xff0c;而其实只需要掌握20%的组件就可以完成80%甚至更多的日常工作了&#xff0c;所以接下来我们重点剖析使用最频繁的核心组件&#xff0c;如下图所示。只需要优先掌握这10个左右…
阅读更多...
IBM X3750 M4服务器主板故障全国协助处理

IBM X3750 M4服务器主板故障全国协助处理

2023年12月31这天中午看到有位网络朋友加我&#xff0c;通过后该用户反馈说是有一台IBM System x3750 M4服务器有故障&#xff0c;现在无法开机。希望我们工程师协助他检测 分析 定位该故障问题原因和处理方案。 如上图所示&#xff1a;经过工程师与用户排查&#xff0c;发现该…
阅读更多...
3D scanner with DLPC3478

3D scanner with DLPC3478

https://www.bilibili.com/video/BV1vJ411J7ih?p3&vd_source109fb20ee1f39e5212cd7a443a0286c5 因数&#xff1a; 分别率波长pattern速度 DMD 与 DLPC匹配 3D scanner是结构光的概念走的 Internal pattern, 是DLPC内部提供图像给DMD External Pattern, 外部FPGA /MCU…
阅读更多...
河南省农村合作医疗 及 社保缴费信息 查询方法

河南省农村合作医疗 及 社保缴费信息 查询方法

河南省农村合作医疗 及 社保缴费信息 查询方法 参考链接&#xff1a;河南城乡居民参保网上缴费及查询操作流程&#xff01; 一、河南省农村合作医疗&#xff0c;缴费信息查询方法 1、在支付宝或者微信中搜索 “河南税务” 公众号&#xff0c;并按步骤登陆&#xff1b; 2、在…
阅读更多...
C桑(Cython)从入坑到入土(1)

C桑(Cython)从入坑到入土(1)

Cython 概览 Cython 是一个将类似 Python 的代码文件编译为 C 代码的编译器。尽管如此&#xff0c;“Cython 不是 Python 到 C 的翻译器”。也就是说&#xff0c;它不会将完整的程序"转换为 C"------相反&#xff0c;结果会充分利用 Python 运行时环境。一种看待它…
阅读更多...
Visual Studio中项目添加链接文件

Visual Studio中项目添加链接文件

这个需求在VS里面使用还真不多见&#xff0c;只是最近在做项目的版本编号的时候遇到一个头大的问题&#xff0c;我一个解决方案下面有几十个类库&#xff0c;再发布的时候这几十个类库的版本号必须要统一&#xff0c;之前我们都是在单个的AssemblyInfo.cs里面去改相关的信息&am…
阅读更多...
CCF模拟题 202309-2 坐标变换（其二）

CCF模拟题 202309-2 坐标变换（其二）

问题描述 试题编号&#xff1a; 202309-2 试题名称&#xff1a; 坐标变换&#xff08;其二&#xff09; 时间限制&#xff1a; 1.0s 内存限制&#xff1a; 512.0MB 问题描述&#xff1a; 对于平面直角坐标系上的坐标 &#xff08;x,y&#xff09;&#xff0c;小 P 定义了如下两…
阅读更多...
如何解决NAND系统性能问题？--NAND分类

如何解决NAND系统性能问题？--NAND分类

一、故事引言 想象一下&#xff0c;你正在管理一座神奇的数据仓库&#xff0c;这个仓库没有沉重的门、旋转的磁盘和机械手臂&#xff0c;而是由一群训练有素的“数据小飞侠”组成。这些小飞侠们居住在一个叫做闪存芯片&#xff08;NAND Flash&#xff0c;本文主人公&#xff0…
阅读更多...
【Linux】进程信号——进程信号的概念和介绍、产生信号、四种产生信号方式、阻塞信号、捕捉信号、阻塞和捕捉信号的函数

【Linux】进程信号——进程信号的概念和介绍、产生信号、四种产生信号方式、阻塞信号、捕捉信号、阻塞和捕捉信号的函数

文章目录 进程信号1.进程信号的概念和介绍2.产生信号2.1通过终端按键产生信号2.2 调用系统函数向进程发信号2.3 由软件条件产生信号2.4硬件异常产生信号 3.阻塞信号3.1信号在内核中的表示3.2信号集操作函数3.3sigprocmask 4.捕捉信号4.1内核如何实现信号的捕捉4.2 sigaction 进…
阅读更多...
Docker安装MySql详细步骤

Docker安装MySql详细步骤

1、新建挂载目录 首先进入安装mysql的目录&#xff0c;没有就自行创建 mkdir -p /usr/local/docker/mysql-docker cd /usr/local/docker/mysql-docker 接着挂载目录 # 选择自己的软件安装目录&#xff0c;新建挂载文件目录 mkdir -p data logs mysql-files conf # 赋予权限…
阅读更多...
xcode安装及运行源码

xcode安装及运行源码

抖音教学视频 目录 1、xcode 介绍 2、xcode 下载 3、xocde 运行ios源码 4、快捷键 1、xcode 介绍 Xcode 是运行在操作系统Mac OS X上的集成开发工具&#xff08;IDE&#xff09;&#xff0c;由Apple Inc开发。Xcode是开发 macOS 和 iOS 应用程序的最快捷的方式。Xcode 具有…
阅读更多...
使用主题模型和古老的人类推理进行无监督文本分类

使用主题模型和古老的人类推理进行无监督文本分类

一、说明 我在日常工作中不断遇到的一项挑战是在无法访问黄金标准标签的情况下标记文本数据。这绝不是一项微不足道的任务&#xff0c;在本文中&#xff0c;我将向您展示一种相对准确地完成此任务的方法&#xff0c;同时保持管道的可解释性和易于调整。 一些读者可能已经开始考…
阅读更多...
小程序商城的优势是什么？

小程序商城的优势是什么？

随着科技的飞速发展&#xff0c;电商行业也在不断变革。其中&#xff0c;电商小程序商城系统以其独特的优势&#xff0c;正在成为电商领域的新宠。本文将深入探讨电商小程序商城系统的优势&#xff0c;展望其未来发展前景。 一、便捷快速&#xff1a;体验至上 与传统电商网站相…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023