Python|数组|动态规划|哈希表|双指针|字符串|单选记录：杨辉三角|电话号码的字母组合|验证回文串

目录

1、杨辉三角（数组，动态规划）

选项代码

2、电话号码的字母组合（哈希表，字符串）

选项代码

3、验证回文串（双指针，字符串）

选项代码

---

1、杨辉三角（数组，动态规划）

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

杨辉三角，也称为帕斯卡三角形、贾宪三角形，是二项式系数在三角形中的一种几何排列。在欧洲，这个表叫做帕斯卡三角形。帕斯卡（1623----1662）是在1654年发现这一规律的，比杨辉要迟393年，比贾宪迟600年。

帕斯卡三角形的每个数字等于它左上方和右上方两个数字之和，形似三角形。例如，第0行有1个数字，第1行有2个数字，第2行有3个数字，以此类推。杨辉三角是最本质的特征是，它的两条斜边都是由数字1组成的，而其余的数则是等于它肩上的两个数之和。

 

示例 1:

输入: numRows = 5

输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

示例 2:

输入: numRows = 1

输出: [[1]]

 

提示:

• 1 <= numRows <= 30

选项代码：

from typing import List
class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        if numRows == 0:
            return []
        if numRows == 1:
            return [[1]]
        if numRows == 2:
            return [[1], [1, 1]]
        result = [[1], [1, 1]] + [[] for i in range(numRows - 2)]
        for i in range(2, numRows):
            for j in range(i + 1):
                if j == 0 or j == i:
                    result[i].append(1)
                else:
                    result[i].append(result[i - 1][j - 1] + result[i - 1][j])
        return result
if __name__ == "__main__":
        s = Solution()
        print (s.generate( numRows = 5))

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'] 的一个数字。

选项代码：

from typing import List
class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        letters = [
            [],
            [],
            ['a', 'b', 'c'],
            ['d', 'e', 'f'],
            ['g', 'h', 'i'],
            ['j', 'k', 'l'],
            ['m', 'n', 'o'],
            ['p', 'q', 'r', 's'],
            ['t', 'u', 'v'],
            ['w', 'x', 'y', 'z'],
        ]
        combinations = []
        i = 0
        for d in digits:
            letter = letters[int(d)]
            if i == 0:
                for l in letter:
                    combinations.append([l])
            else:
                added = []
                for c in combinations:
                    j = 0
                    origin_c = []
                    origin_c += c
                    for l in letter:
                        if j == 0:
                            c.append(l)
                        else:
                            new_c = []
                            new_c += origin_c
                            new_c.append(l)
                            added.append(new_c)
                        j += 1
                combinations += added
            i += 1
        output = []
        for c in combinations:
            output.append(''.join(c))
        return output
# %%
s = Solution()
print(s.letterCombinations(digits = "23"))

3、验证回文串（双指针，字符串）

回文串是指正读反读都一样的字符串。要验证一个字符串是否是回文串，可以将字符串与其反转后的字符串进行比较。如果两者相等，则该字符串是回文串；否则，它不是回文串。

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

 

示例 1:

输入: "A man, a plan, a canal: Panama"

输出: true

解释："amanaplanacanalpanama" 是回文串

示例 2:

输入: "race a car"

输出: false

解释："raceacar" 不是回文串

 

提示：

• 1 <= s.length <= 2 * 105
• 字符串 s 由 ASCII 字符组成

选项代码：

class Solution(object):
    def isPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        i = 0
        j = len(s) - 1
        while i < j:
            if s[i].isalnum() and s[j].isalnum():
                if s[i].upper() == s[j].upper():
                    i += 1
                    j -= 1
                else:
                    return False
            else:
                if not s[i].isalnum():
                    i += 1
                if not s[j].isalnum():
                    j -= 1
        return True
# %%
s = Solution()
print(s.isPalindrome("A man, a plan, a canal: Panama"))