【数据结构与算法】之字符串系列-20240121

---

一、344. 反转字符串

简单

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：
输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：
输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

def func344(nums):
    for i in range(len(nums) // 2):
        nums[i], nums[len(nums) - i - 1] = nums[len(nums) - i - 1], nums[i]
    return nums


nums = ["H", "a", "n", "n", "a", "h"]
res = func344(nums)
print(res)

二、125. 验证回文串

简单
如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。字母和数字都属于字母数字字符。
给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。

示例 1：
输入: s = “A man, a plan, a canal: Panama”
输出：true
解释：“amanaplanacanalpanama” 是回文串。

示例 2：
输入：s = “race a car”
输出：false
解释：“raceacar” 不是回文串。

示例 3：
输入：s = " "
输出：true
解释：在移除非字母数字字符之后，s 是一个空字符串 “” 。由于空字符串正着反着读都一样，所以是回文串。

class Solution:
    def func(self, s):
        s = s.lower()
        left = 0
        right = len(s) - 1
        while left < right:
            while left < right and not s[left].isalpha():
                left += 1
            while left < right and not s[right].isalpha():
                right -= 1
            if s[left] != s[right]:
                return False
            left += 1
            right -= 1
        return True


ss = Solution()
s = " "
print(ss.func(s))

三、205. 同构字符串

简单
给定两个字符串 s 和 t ，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

示例 1:
输入：s = “egg”, t = “add”
输出：true

示例 2：
输入：s = “foo”, t = “bar”
输出：false

示例 3：
输入：s = “paper”, t = “title”
输出：true

class Solution:
    def func205(self,s,t):
        d={}
        for i in range(len(s)):
            if s[i] not in d:
                if t[i] in d.values():
                    return False
                else:
                    d[s[i]]=t[i]
            else:
                if d[s[i]]!=t[i]:
                    return False
        return True
s = "paper"
t = "title"
r=Solution()
print(r.func205(s, t))

四、242. 有效的字母异位词

简单
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true

示例 2:
输入: s = “rat”, t = “car”
输出: false

class Solution1:
    def func(self, s, t):
        ss = Counter(s)
        tt = Counter(t)
        if ss == tt:
            return True
        return False


s = Solution1()
s1 = "rat"
t1 = "car"
print(s.func(s1, t1))

五、290. 单词规律

简单
给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

示例1:
输入: pattern = “abba”, s = “dog cat cat dog”
输出: true

示例 2:
输入:pattern = “abba”, s = “dog cat cat fish”
输出: false

示例 3:
输入: pattern = “aaaa”, s = “dog cat cat dog”
输出: false

class Solution:
    def func(self,pattern,s):
        ss=s.split()
        d={}
        for i in range(len(pattern)):
            if pattern[i] not in d:
                if ss[i] in d.values():
                    return False
                else:
                    d[pattern[i]]=ss[i]
            else:
                if d[pattern[i]]!=ss[i]:
                    return False
        return True
r=Solution()

pattern = "aaaa"
s = "dog cat cat dog"
print(r.func(pattern, s))