LeetCode17题Letter Combinations of a Phone Number

感谢平台分享-http://bjbsair.com/2020-04-10...

典型的回溯算法题目,实践三遍刷题方法,本人用Python 和Go 语言分别解题。

class Solution:  
      
    def letterCombinations(self, digits: str) -> List[str]:  
        if len(digits) == 0:  
            return []  
        letters = {  
            2: "abc",  
            3: "def",  
            4: "ghi",  
            5: "jkl",  
            6: "mno",  
            7: "pqrs",  
            8: "tuv",  
            9: "wxyz",   
        }   
        res = []  
          
        def dfs(digits, letters, path, index, res):  
            if index == len(digits):  
                res.append(path)  
                return  
            for char in letters[int(digits[index])]:  
                dfs(digits, letters, path + char, index + 1, res)  
            return  
        dfs(digits, letters, '', 0, res)  
        return res 

Go 语言代码

func letterCombinations(digits string) []string {  
    if len(digits) == 0 {  
        return nil  
    }  
    lettersDict := map[string]string{  
        "0":"",  
        "1":"",  
        "2":"abc",  
        "3":"def",  
        "4":"ghi",  
        "5":"jkl",  
        "6":"mno",  
        "7":"pqrs",  
        "8":"tuv",  
        "9":"wxyz",  
    }  
    var res []string  
    dfs(digits, 0, []string{}, &res, lettersDict)  
    return res  
}  
  
func dfs(digits string, idx int, path []string, res *[]string, lettersDict map[string]string) {  
    
    if idx == len(digits) {  
        *res = append(*res, strings.Join(path, ""))  
        return  
    }  
    c := digits[idx]  
    s, _:= lettersDict[string(c)]  
    for i:= 0; i < len(s); i++ {  
        path = append(path, string(s[i]))  
        dfs(digits, idx + 1, path , res, lettersDict)  
        path = path[:(len(path) - 1)]  
    }  
}

感谢平台分享-http://bjbsair.com/2020-04-10...

典型的回溯算法题目,实践三遍刷题方法,本人用Python 和Go 语言分别解题。

class Solution:  
      
    def letterCombinations(self, digits: str) -> List[str]:  
        if len(digits) == 0:  
            return []  
        letters = {  
            2: "abc",  
            3: "def",  
            4: "ghi",  
            5: "jkl",  
            6: "mno",  
            7: "pqrs",  
            8: "tuv",  
            9: "wxyz",   
        }   
        res = []  
          
        def dfs(digits, letters, path, index, res):  
            if index == len(digits):  
                res.append(path)  
                return  
            for char in letters[int(digits[index])]:  
                dfs(digits, letters, path + char, index + 1, res)  
            return  
        dfs(digits, letters, '', 0, res)  
        return res 

Go 语言代码

func letterCombinations(digits string) []string {  
    if len(digits) == 0 {  
        return nil  
    }  
    lettersDict := map[string]string{  
        "0":"",  
        "1":"",  
        "2":"abc",  
        "3":"def",  
        "4":"ghi",  
        "5":"jkl",  
        "6":"mno",  
        "7":"pqrs",  
        "8":"tuv",  
        "9":"wxyz",  
    }  
    var res []string  
    dfs(digits, 0, []string{}, &res, lettersDict)  
    return res  
}  
  
func dfs(digits string, idx int, path []string, res *[]string, lettersDict map[string]string) {  
    
    if idx == len(digits) {  
        *res = append(*res, strings.Join(path, ""))  
        return  
    }  
    c := digits[idx]  
    s, _:= lettersDict[string(c)]  
    for i:= 0; i < len(s); i++ {  
        path = append(path, string(s[i]))  
        dfs(digits, idx + 1, path , res, lettersDict)  
        path = path[:(len(path) - 1)]  
    }  
}

感谢平台分享-http://bjbsair.com/2020-04-10...

典型的回溯算法题目,实践三遍刷题方法,本人用Python 和Go 语言分别解题。

class Solution:  
      
    def letterCombinations(self, digits: str) -> List[str]:  
        if len(digits) == 0:  
            return []  
        letters = {  
            2: "abc",  
            3: "def",  
            4: "ghi",  
            5: "jkl",  
            6: "mno",  
            7: "pqrs",  
            8: "tuv",  
            9: "wxyz",   
        }   
        res = []  
          
        def dfs(digits, letters, path, index, res):  
            if index == len(digits):  
                res.append(path)  
                return  
            for char in letters[int(digits[index])]:  
                dfs(digits, letters, path + char, index + 1, res)  
            return  
        dfs(digits, letters, '', 0, res)  
        return res 

Go 语言代码

func letterCombinations(digits string) []string {  
    if len(digits) == 0 {  
        return nil  
    }  
    lettersDict := map[string]string{  
        "0":"",  
        "1":"",  
        "2":"abc",  
        "3":"def",  
        "4":"ghi",  
        "5":"jkl",  
        "6":"mno",  
        "7":"pqrs",  
        "8":"tuv",  
        "9":"wxyz",  
    }  
    var res []string  
    dfs(digits, 0, []string{}, &res, lettersDict)  
    return res  
}  
  
func dfs(digits string, idx int, path []string, res *[]string, lettersDict map[string]string) {  
    
    if idx == len(digits) {  
        *res = append(*res, strings.Join(path, ""))  
        return  
    }  
    c := digits[idx]  
    s, _:= lettersDict[string(c)]  
    for i:= 0; i < len(s); i++ {  
        path = append(path, string(s[i]))  
        dfs(digits, idx + 1, path , res, lettersDict)  
        path = path[:(len(path) - 1)]  
    }  
}

感谢平台分享-http://bjbsair.com/2020-04-10...

典型的回溯算法题目,实践三遍刷题方法,本人用Python 和Go 语言分别解题。

class Solution:  
      
    def letterCombinations(self, digits: str) -> List[str]:  
        if len(digits) == 0:  
            return []  
        letters = {  
            2: "abc",  
            3: "def",  
            4: "ghi",  
            5: "jkl",  
            6: "mno",  
            7: "pqrs",  
            8: "tuv",  
            9: "wxyz",   
        }   
        res = []  
          
        def dfs(digits, letters, path, index, res):  
            if index == len(digits):  
                res.append(path)  
                return  
            for char in letters[int(digits[index])]:  
                dfs(digits, letters, path + char, index + 1, res)  
            return  
        dfs(digits, letters, '', 0, res)  
        return res 

Go 语言代码

func letterCombinations(digits string) []string {  
    if len(digits) == 0 {  
        return nil  
    }  
    lettersDict := map[string]string{  
        "0":"",  
        "1":"",  
        "2":"abc",  
        "3":"def",  
        "4":"ghi",  
        "5":"jkl",  
        "6":"mno",  
        "7":"pqrs",  
        "8":"tuv",  
        "9":"wxyz",  
    }  
    var res []string  
    dfs(digits, 0, []string{}, &res, lettersDict)  
    return res  
}  
  
func dfs(digits string, idx int, path []string, res *[]string, lettersDict map[string]string) {  
    
    if idx == len(digits) {  
        *res = append(*res, strings.Join(path, ""))  
        return  
    }  
    c := digits[idx]  
    s, _:= lettersDict[string(c)]  
    for i:= 0; i < len(s); i++ {  
        path = append(path, string(s[i]))  
        dfs(digits, idx + 1, path , res, lettersDict)  
        path = path[:(len(path) - 1)]  
    }  
}

感谢平台分享-http://bjbsair.com/2020-04-10...

典型的回溯算法题目,实践三遍刷题方法,本人用Python 和Go 语言分别解题。

class Solution:  
      
    def letterCombinations(self, digits: str) -> List[str]:  
        if len(digits) == 0:  
            return []  
        letters = {  
            2: "abc",  
            3: "def",  
            4: "ghi",  
            5: "jkl",  
            6: "mno",  
            7: "pqrs",  
            8: "tuv",  
            9: "wxyz",   
        }   
        res = []  
          
        def dfs(digits, letters, path, index, res):  
            if index == len(digits):  
                res.append(path)  
                return  
            for char in letters[int(digits[index])]:  
                dfs(digits, letters, path + char, index + 1, res)  
            return  
        dfs(digits, letters, '', 0, res)  
        return res 

Go 语言代码

func letterCombinations(digits string) []string {  
    if len(digits) == 0 {  
        return nil  
    }  
    lettersDict := map[string]string{  
        "0":"",  
        "1":"",  
        "2":"abc",  
        "3":"def",  
        "4":"ghi",  
        "5":"jkl",  
        "6":"mno",  
        "7":"pqrs",  
        "8":"tuv",  
        "9":"wxyz",  
    }  
    var res []string  
    dfs(digits, 0, []string{}, &res, lettersDict)  
    return res  
}  
  
func dfs(digits string, idx int, path []string, res *[]string, lettersDict map[string]string) {  
    
    if idx == len(digits) {  
        *res = append(*res, strings.Join(path, ""))  
        return  
    }  
    c := digits[idx]  
    s, _:= lettersDict[string(c)]  
    for i:= 0; i < len(s); i++ {  
        path = append(path, string(s[i]))  
        dfs(digits, idx + 1, path , res, lettersDict)  
        path = path[:(len(path) - 1)]  
    }  
}

感谢平台分享-http://bjbsair.com/2020-04-10...

典型的回溯算法题目,实践三遍刷题方法,本人用Python 和Go 语言分别解题。

class Solution:  
      
    def letterCombinations(self, digits: str) -> List[str]:  
        if len(digits) == 0:  
            return []  
        letters = {  
            2: "abc",  
            3: "def",  
            4: "ghi",  
            5: "jkl",  
            6: "mno",  
            7: "pqrs",  
            8: "tuv",  
            9: "wxyz",   
        }   
        res = []  
          
        def dfs(digits, letters, path, index, res):  
            if index == len(digits):  
                res.append(path)  
                return  
            for char in letters[int(digits[index])]:  
                dfs(digits, letters, path + char, index + 1, res)  
            return  
        dfs(digits, letters, '', 0, res)  
        return res 

Go 语言代码

func letterCombinations(digits string) []string {  
    if len(digits) == 0 {  
        return nil  
    }  
    lettersDict := map[string]string{  
        "0":"",  
        "1":"",  
        "2":"abc",  
        "3":"def",  
        "4":"ghi",  
        "5":"jkl",  
        "6":"mno",  
        "7":"pqrs",  
        "8":"tuv",  
        "9":"wxyz",  
    }  
    var res []string  
    dfs(digits, 0, []string{}, &res, lettersDict)  
    return res  
}  
  
func dfs(digits string, idx int, path []string, res *[]string, lettersDict map[string]string) {  
    
    if idx == len(digits) {  
        *res = append(*res, strings.Join(path, ""))  
        return  
    }  
    c := digits[idx]  
    s, _:= lettersDict[string(c)]  
    for i:= 0; i < len(s); i++ {  
        path = append(path, string(s[i]))  
        dfs(digits, idx + 1, path , res, lettersDict)  
        path = path[:(len(path) - 1)]  
    }  
}

评论

暂无评论