leetcode基础编程：字符串

107. 验证回文串

难度：简单

收藏

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

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

示例 1:

输入: "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串

示例 2:

输入: "race a car"
输出: false
解释："raceacar" 不是回文串

提示：

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

def check(c:str)->bool:
    return c>='0' and c<='9' or c>='a' and c<='z' or c>='A' and c<='Z'
class Solution:
    def isPalindrome(self, s: str) -> bool:
        i = 0
        j = len(s)-1
        while i < j:
            while i < j and not check(s[i]):
                i+=1
            while i < j and not check(s[j]):
                j-=1
            if s[i] != s[j] and s[i] != chr(ord(s[j])^32):
                #异或32 大小写之间相差32
                #chr(ord('A')^32)='a'
                return False
            i+=1
            j-=1
        return True

127. 翻转字符串里的单词

难度：中等
收藏
给你一个字符串 s ，逐个翻转字符串中的所有 单词 。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。

说明：

输入字符串 s 可以在前面、后面或者单词间包含多余的空格。
翻转后单词间应当仅用一个空格分隔。
翻转后的字符串中不应包含额外的空格。

示例 1：

输入：s = “the sky is blue”
输出：“blue is sky the”
示例 2：

输入：s = " hello world "
输出：“world hello”
解释：输入字符串可以在前面或者后面包含多余的空格，但是翻转后的字符不能包括。
示例 3：

输入：s = “a good example”
输出：“example good a”
解释：如果两个单词间有多余的空格，将翻转后单词间的空格减少到只含一个。
示例 4：

输入：s = " Bob Loves Alice "
输出：“Alice Loves Bob”
示例 5：

输入：s = “Alice does not even like bob”
输出：“bob like even not does Alice”

提示：

1 <= s.length <= 104
s 包含英文大小写字母、数字和空格 ’ ’
s 中 至少存在一个 单词

进阶：

请尝试使用 O(1) 额外空间复杂度的原地解法。

class Solution:
    def reverseWords(self, s: str) -> str:
        s=s.split()
        s=s[::-1]
        s = ' '.join(s)
        return s

方法一：会超时的笨办法（$O(n^2)$）

class Solution:
    def validPalindrome(self, s: str) -> bool:
        # if s == s[::-1]:
        #     return True
        for i in range(len(s)):
            s1 = s[:i]
            s2 = s[i+1:]
            s3 = s1+s2
            if s3==s3[::-1]:
                return True
        return False

方法二：双指针往中间夹逼

遇到不相同的，如果删掉其中之一是回文串，就可以了。

def check(s:str,i:int,j:int)->bool:
    while i<j:
        if s[i] != s[j]:
            return False
        i+=1
        j-=1
    return True
class Solution:
    def validPalindrome(self, s: str) -> bool:
        i = 0
        j = len(s)-1
        while i<j:
            if s[i]!=s[j]:
                if check(s,i+1,j) or check(s,i,j-1):
                    return True
                return False
            i+=1
            j-=1
        return True

135. Excel表列名称

难度：简单

收藏

给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。

例如：

A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28 
...

示例 1：

输入：columnNumber = 1
输出："A"

示例 2：

输入：columnNumber = 28
输出："AB"

示例 3：

输入：columnNumber = 701
输出："ZY"

示例 4：

输入：columnNumber = 2147483647
输出："FXSHRXW"

提示：

• 1 <= columnNumber <= 2^31 - 1

方法一

class Solution:
    def convertToTitle(self, columnNumber: int) -> str:
        res=''
        while columnNumber:
            res+=chr(((columnNumber)-1)%26+ord('A'))
            columnNumber=(columnNumber-1)//26
        return res[::-1]

方法二

class Solution:
    def convertToTitle(self, columnNumber: int) -> str:
        k = 1
        p = 26
        while columnNumber>p:
            columnNumber -= p
            k += 1
            p *= 26
        
        columnNumber -= 1
        res=''
        while k:
            res += chr(columnNumber%26+ord('A'))
            columnNumber //= 26
            k -= 1
        
        return res[::-1]

224. 字符串解码

难度：中等

收藏

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

示例 1：

输入：s = "3[a]2[bc]"
输出："aaabcbc"

示例 2：

输入：s = "3[a2[c]]"
输出："accaccacc"

示例 3：

输入：s = "2[abc]3[cd]ef"
输出："abcabccdcdcdef"

示例 4：

输入：s = "abc3[cd]xyz"
输出："abccdcdcdxyz"

提示：

• 1 <= s.length <= 30
• s 由小写英文字母、数字和方括号 '[]' 组成
• s 保证是一个 有效 的输入。
• s 中所有整数的取值范围为 [1, 300]

class Solution:
    dig=[chr(i) for i in range(ord('0'),ord('9')+1)]
    def decodeString(self, s: str) -> str:
        res=''
        i = 0
        while i < len(s):
            if s[i] not in self.dig:
                res += s[i]
                i+=1
            else:
                j=i
                while s[j] in self.dig:
                    j+=1
                t = int(s[i:j])
                k = j+1
                sum = 0
                while sum>=0:
                    if s[k]=='[':
                        sum+=1
                    if s[k]==']':
                        sum-=1
                    k+=1
                str1 = self.decodeString(s[j+1:k-1])
                
                while t:
                    res+=str1
                    t-=1
                i=k
        return res