力扣刷题笔记 字符串及其相关题目（含ACM模式）

最新推荐文章于 2024-09-13 18:11:35 发布
最新推荐文章于 2024-09-13 18:11:35 发布
阅读量102 收藏
点赞数
文章标签： leetcode 笔记 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sangedianhao/article/details/134449421
版权
文章介绍了Python中各种字符串操作，如反转字符串、使用KMP算法查找子串、替换数字、单词反转、右旋字符串以及检测重复字符串模式。核心代码展示了如何实现这些功能，并且区分了ACM模式和核心代码模式的区别。
摘要由CSDN通过智能技术生成

 《代码随想录》学习笔记，原链接：https://programmercarl.com/

344.反转字符串

  • 核心代码模式
class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        lenth = len(s)
        for i in range(lenth // 2):
            s[i], s[lenth - i - 1] = s[lenth - i - 1], s[i]     # 只能在一行之内这么写，不然s[i]的值会被覆盖
                    
        return str(s)

【注】 如果将

s[i], s[lenth - i - 1] = s[lenth - i - 1], s[i] 

改为

s[i] = s[lenth - i - 1]

s[lenth - i - 1] = s[i]

则会报错：

  • ACM模式
class Solution:
    def reverseString(self, s):
        """
        Do not return anything, modify s in-place instead.
        """
        lenth = len(s)
        for i in range(lenth // 2):
            s[i], s[lenth - i - 1] = s[lenth - i - 1], s[i]  # 只能在一行之内这么写，不然s[i]的值会被覆盖

        return str(s)

# 输入要反转的字符串
string = input("输入字符串s：")
s = []

for i in string:
    s.append(i)

# 反转字符串
solution = Solution()
result = solution.reverseString(s)
print(result)

【注】将字符串分割成单个字母组成的列表，不可以使用input("输入字符串s：").split("")，否则会报错：“ValueError: empty separator”。

原因：split()方法可以使用指定字符将字符串分割，生成一个字符串列表。当字符串中不包含分隔符或者split()方法中没有提供分隔符，则会生成由原字符串组成的只有一个元素的列表。但是，split()方法中的分隔符可以省略，却不可以使用空字符串，即("")作为分隔符，否则就会出现报错：“ValueError: empty separator”。

541.反转字符串II

  •  核心代码模式
class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        i =  0
        string_list = list(s)   # 将字符串转成列表，方便后续使用reversed函数进行反转
        lenth = len(string_list)    

        while i < lenth:
            if i + k <= lenth:  # 对前k个字符进行反转
                string_list[i: i + k] = reversed(string_list[i: i + k])     # 注意左开右闭，范围为[i: i + k]
            else:       # 对剩余字符进行反转
                string_list[i: lenth] = reversed(string_list[i: lenth])     # 注意左开右闭，范围为[i: lenth]
            
            i += k * 2  
        
        s = ''.join(string_list)    # 将列表整合成字符串

        return s

 【注】reversed()函数只能处理列表，因此需要先进行字符串到列表的变换。

  • ACM模式
class Solution:
    def reverseStr(self, s, k):
        i = 0
        string_list = list(s)  # 将字符串转成列表，方便后续使用reversed函数进行反转
        lenth = len(string_list)

        while i < lenth:
            if i + k <= lenth:  # 对前k个字符进行反转
                string_list[i: i + k] = reversed(string_list[i: i + k])  # 注意左开右闭，范围为[i: i + k]
            else:  # 对剩余字符进行反转
                string_list[i: lenth] = reversed(string_list[i: lenth])  # 注意左开右闭，范围为[i: lenth]

            i += k * 2

        s = ''.join(string_list)  # 将列表整合成字符串

        return s

# 输入要反转的字符串和k
s = input("输入字符串s：")
k = int(input("输入k："))

# 反转字符串II
solution = Solution()
result = solution.reverseStr(s, k)
print(result)

替换数字

卡码网题目链接

 

 

  • ACM模式
class Solution:
    def replaceNumber(self, s: str) -> str:
        s = list(s)  # 将字符串s转换成字符列表
        str_lenth = len(s)  # 记录原字符串长度
        record = list("number")  # 将要填充的字符串储存成列表

        # 统计数字字符的个数
        num_count = 0
        for i in s:
            if ord(i) - ord("0") in range(10):
                num_count += 1

        # 扩展字符串列表s的长度，直接使用 + 运算符添加新列表的元素。行为类似于我们修改变量值的方式
        s = s + [0] * (num_count * 5)

        # 双指针法
        slow, fast = str_lenth - 1, len(s) - 1
        while slow >= 0:
            if ord(s[slow]) - ord("0") in range(10):
                for i in range(5, -1, -1):
                    s[fast] = record[i]
                    fast -= 1
            else:
                s[fast] = s[slow]
                fast -= 1
            slow -= 1

        s = ''.join(s)
        return s


s = input("")
solution = Solution()
result = solution.replaceNumber(s)
print(result)

 151.反转字符串中的单词

先删除空白生成单词列表，然后单词反转输出。 因为字符串是不可变类型，所以反转单词的时候，需要将其转换成列表，然后通过join函数再将其转换成列表，所以空间复杂度不是O(1)。

  •  核心代码模式
class Solution:
    def reverseWords(self, s: str) -> str:
        record = s.split()      # 去除字符串内部和两端的多余空格，注意split函数括号内要为空，不能使用split(" ")，否则遇到多个连续空格只会去除其中一个
        result = " ".join(record[::-1]) # 将去除空格后的结果，使用空格倒序连接成字符串

        return result
  • ACM模式
class Solution:
    def reverseWords(self, s: str) -> str:
        record = s.split()      # 去除字符串内部和两端的多余空格，注意split函数括号内要为空，不能使用split(" ")，否则遇到多个连续空格只会去除其中一个
        result = " ".join(record[::-1]) # 将去除空格后的结果，使用空格倒序连接成字符串

        return result

# 输入单词字符串
s = input("输入要修改的字符串s：")

# 反转字符串中的单词
solution = Solution()
result = solution.reverseWords(s)
print(result)

55.右旋字符串（第八期模拟笔试）

  • ACM模式 
class Solution:
    def rotString(self, s: str, k: int) -> str:
        s = list(s)  # 将字符串拆分成字符列表
        lenth = len(s)
        
        s = s + [0] * (lenth - k)  # 扩容lenth - k个元素
        s[lenth:] = s[: lenth - k]  # 将前面lenth - k个元素按顺序存储到新扩容的部分

        result = ''.join(s[lenth - k:])     # 将右旋后的结果拼接成字符串

        return result

# 自定义输入k和字符串s
k = int(input())
s = input()

# 右旋字符串
solution = Solution()
result = solution.rotString(s, k)
print(result)
  • 不申请额外空间（ACM模式） 

（1）先根据k将字符串分割成两个部分

（2）对字符串s进行整体反转

（3）对每个部分再次进行反转，得到最终结果的列表形式

 

class Solution:
    def rotString(self, s, k):
        s = list(s)  # 将字符串拆分成字符列表

        # 整体反转字符串
        s = list(reversed(s))   # reversed()方法返回一个反转元素顺序的迭代器，要将其转换为列表
        
        # 分别反转两个部分的字符串
        s[0: k] = list(reversed(s[0: k]))   # reversed()方法返回一个反转元素顺序的迭代器，要将其转换为列表
        s[k: len(s)] = list(reversed(s[k: len(s)]))     # reversed()方法返回一个反转元素顺序的迭代器，要将其转换为列表

        # 将反转结果拼接成字符串
        result = ''.join(s)

        return result

# 自定义输入k和字符串s
k = int(input())
s = input()

# 右旋字符串
solution = Solution()
result = solution.rotString(s, k)
print(result)

28.找出字符串中第一个匹配项的下标

  • KMP算法

  • 核心代码模式
class Solution:
    # 构建前缀表next
    def get_next(self, s: str) -> None:
        next = [0] * len(s)     # 创建前缀表
        j = 0       # 初始化相等前后缀长度
        next[0] = 0     # 前缀表的第一个元素为0

        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j - 1]     # 若i和j对应的s元素不相同，则j回退到next[j - 1]代表的位置
            if s[i] == s[j]:
                j += 1      # 若i和j对应的s元素相同，则i和j均+1，注意对于每一个i，j只可能有一次+1操作，但可能有很多次回退操作
            
            next[i] = j     # 得到当前位置前缀表的元素值
    
        return next     # 返回前缀表next
    
    # 匹配字符串
    def strStr(self, haystack: str, needle: str) -> int:
        j = 0       # 初始化neddle开始匹配的位置

        if len(needle) == 0:        # 特殊情况判断
            return 0
        
        next = self.get_next(needle)        # 获取前缀表next

        for i in range(len(haystack)):
            while j > 0 and haystack[i] != needle[j]:
                j = next[j - 1]     # 如果i和j对应的元素不相同，则j回退到next[j - 1]的位置，注意，这里i和j分别时连个不同字符串的下标
            if haystack[i] == needle[j]:
                j += 1      # 如果i和j代表的元素相同，则i和j都+1，注意对于每个i，只会进行一次j+1的操作
            if j == len(needle):
                return i - j + 1        # 匹配成功，返回第一个匹配项的下标
        
        return -1       # 匹配失败
  • ACM模式
class Solution:
    # 构建前缀表next
    def get_next(self, s: str) -> None:
        next = [0] * len(s)  # 创建前缀表
        j = 0  # 初始化相等前后缀长度
        next[0] = 0  # 前缀表的第一个元素为0

        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j - 1]  # 若i和j对应的s元素不相同，则j回退到next[j - 1]代表的位置
            if s[i] == s[j]:
                j += 1  # 若i和j对应的s元素相同，则i和j均+1，注意对于每一个i，j只可能有一次+1操作，但可能有很多次回退操作

            next[i] = j  # 得到当前位置前缀表的元素值

        return next  # 返回前缀表next

    # 匹配字符串
    def strStr(self, haystack: str, needle: str) -> int:
        j = 0  # 初始化neddle开始匹配的位置

        if len(needle) == 0:  # 特殊情况判断
            return 0

        next = self.get_next(needle)  # 获取前缀表next

        for i in range(len(haystack)):
            while j > 0 and haystack[i] != needle[j]:
                j = next[j - 1]  # 如果i和j对应的元素不相同，则j回退到next[j - 1]的位置，注意，这里i和j分别时连个不同字符串的下标
            if haystack[i] == needle[j]:
                j += 1  # 如果i和j代表的元素相同，则i和j都+1，注意对于每个i，只会进行一次j+1的操作
            if j == len(needle):
                return i - j + 1  # 匹配成功，返回第一个匹配项的下标

        return -1  # 匹配失败


# 自定义输入字符串haystack和needle
haystack = input("haystack:")
needle = input("needle:")

# 找出字符串中第一个匹配项的下标
solution = Solution()
result = solution.strStr(haystack, needle)
print(result)

459.重复字符串

  • 核心代码模式
class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        next = [0] * len(s)     # 初始化前缀表next
        j = 0       # 初始化最长相等前后缀长度

        for i in range(1, len(s)):      # 获取前缀表next
            while j > 0 and s[i] != s[j]:
                j = next[j - 1]     # 若i和j对应的s元素不相同，则j回退到next[j - 1]代表的位置
            if s[i] == s[j]:
                j += 1      # 若i和j对应的s元素相同，则i和j均+1，注意对于每一个i，j只可能有一次+1操作，但可能有很多次回退操作
            next[i] = j     # j的取值即为当前i位置的前缀表的元素值
        
        """
            首先判断next的最后一个元素不为0，如果为0则一定不重复
            其次，如果字符串s重复，则next的最大值一定取到最后一个元素位置，所以使用len(s) - next[-1]
        """
        if next[-1] != 0 and len(s) % (len(s) - next[-1] ) == 0:      # 判断字符串是否重复  
            return True
        
        return False

【注】由于题目中给出1 <= s.lenth <= 10000，所以不需要进行s是否为空的特殊判断。

  • ACM模式
class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        next = [0] * len(s)  # 初始化前缀表next
        j = 0  # 初始化最长相等前后缀长度

        for i in range(1, len(s)):  # 获取前缀表next
            while j > 0 and s[i] != s[j]:
                j = next[j - 1]  # 若i和j对应的s元素不相同，则j回退到next[j - 1]代表的位置
            if s[i] == s[j]:
                j += 1  # 若i和j对应的s元素相同，则i和j均+1，注意对于每一个i，j只可能有一次+1操作，但可能有很多次回退操作
            next[i] = j  # j的取值即为当前i位置的前缀表的元素值

        """
            首先判断next的最后一个元素不为0，如果为0则一定不重复
            其次，如果字符串s重复，则next的最大值一定取到最后一个元素位置，所以使用len(s) - next[-1]
        """
        if next[-1] != 0 and len(s) % (len(s) - next[-1]) == 0:  # 判断字符串是否重复
            return True

        return False


# 自定义输入字符串s
s = input("s:")

# 重复字符串
solution = Solution()
result = solution.repeatedSubstringPattern(s)
print(result)

通信转爱人
关注
ACM模式输入输出攻略 | C++篇
qq_46046431的博客
02-28 2万+
本文内容干货非常非常多，从笔试面试环境的要点，到C++输入输出的具体函数，再到几乎覆盖全部情况的ACM模式写法，最后也给出了链表和二叉树的定义和输入输出。
一道『easy』等级的力扣题，我写了两个小时的笔记...
记录学习痕迹的公众号：Piper蛋窝
11-28 547
原因是我对 C++ 11 及以上一直不熟（以前一直在用 python 干活儿），因此，决定，一边做题，一边总结知识点。
力扣 不同路径（动态规划）（ACM模式详解）
qq_58785091的博客
03-24 728
力扣 62.不同路径 63.不同路径II，ACM模式下详解
算法题的ACM模式与核心代码模式
code_peak
12-25 6482
这两种模式各自都有优点，ACM 模式的代码是要求直接可以在本地运行的，但是需要自己写 include 哪些库函数，输入和输出格式控制等，在本地调试也是非常方便，但在代码调试正确后提交前，不要忘了删掉调试的代码。：在实现题目过程中，所有的输入和输出触发方式必须严格按照题目的描述进行，数据需要自己构造输入，OJ 不会提供任何代码，包括 include 都需要自己写，输出的格式也需要自行控制格式，即便输入输出结果正确，但因为格式控制错误也无法通过 OJ。
力扣刷题笔记 二分查找以及相关题目（含ACM模式）
sangedianhao的博客
10-13 292
区间的定义就是不变量，循环中坚持根据区间的定义来做边界处理，就是循环不变量规则。左闭右闭 [left, right]，即能取到left和right两个端点：left, right = 0, len(nums) - 1 # 定义左闭右闭的区间端点，[left, right]right = middle - 1 # target在区间的左半部分，即在[left, middle - 1]范围内。
力扣 27 移除元素 ACM模式
a1026681462的博客
09-29 599
移除数组中的元素
【双指针】双指针算法详解两道经典OJ【力扣27，力扣26，力扣38】超详细算法教程
后端开发为主+人工智能
04-23 672
【双指针】双指针算法详解两道经典OJ【力扣27，力扣26，力扣38】超详细算法教程 今天又又到了我们刷力扣题的时间啦！ 今天博主给大家带来的三道题是： 27. 移除元素 26. 删除有序数组中的重复项 88. 合并两个有序数组 这三道题，都是双指针算法题的一个入门题，掌握这三道题，认识双指针算法，是我们今天的目标！ 文章目录前言OJ27 移除元素题目描述算法分析实现代码OJ26 删除有序数组中的重复项题目描述算法分析实现代码OJ88 合并两个有序数组题目描述算法分析实现代码尾声 前言 那么这里博主先安利一
【笔记】二叉树
ericma12的博客
12-09 548
本系列总计六篇文章，是 [基于STL实现的笔试题常考七大基本数据结构] 该文章在《代码随想录》和《labuladong的算法笔记》题目中的具体实践，每篇的布局是这样的：开头是该数据结构的总结，然后是在不同场景的应用，以及不同的算法技巧。本文是系列最后一篇，第六篇，介绍了树的相关题目，重点是要掌握二叉树、多叉树的构造、遍历（递归、非递归、层次），以及二叉树、二叉搜索树的属性，体会递归算法的本质是二叉树。
剑指offer_edition2刷题记录
jiandandian_的博客
04-21 1412
剑指offer_edition2刷题记录
Java设计模式
weixin_48304192的博客
06-19 967
设计模式
什么是核心代码模式，什么又是ACM模式？
热门推荐
代码随想录
03-23 3万+
搞清楚
常用模板，常用面试题
小麦China的博客
04-25 352
字符串分离splitstring vector<string> splitstring(string& s,string& c) { vector<string> res; string::size_type pos1,pos2; pos1=0; pos2=s.find(c,0); while(pos2!=string::npos) {
力扣刷题本地化-输入输出方法大全
MY_ONE_98的博客
03-21 3530
力扣刷题本地化-输入输出方法大全 力扣代码在本地编译运行-数组转化成容器打印 参考代码随想录 拿我们刚讲过的这道题动态规划：使用最小花费爬楼梯 (opens new window)来做示范 #include <iostream> #include <vector> using namespace std; class Solution { public: int minCostClimbingStairs(vector<int>& cost) {
开刷leetcode，纪念短暂而平凡的ACM生涯!
笔墨留年。
03-11 1572
2014年6月，博主高考。 2014年9月，进入了合肥一个很普通的二本大学。 2014年到2016年底，我每天泡在实验室里刷题= =。可能对很多人来说，这种生活很枯燥，但我还算乐在其中，有几个志同道合的朋友（特别感谢一个学长，在我成长过程中帮了我很多）。 2014年-2016年间，参加过一些小比赛（省大学生程序设计竞赛、蓝桥杯全国大学生程序设计竞赛等），拿过一些小奖。都不是我想要的，毕竟目标只有A...
ACM入门题-力扣tusimple-005. 服务器-图论最短路径Go语言
qq_22328011的博客
05-18 317
ACM入门题-力扣tusimple-005. 服务器-图论最短路径Go语言 tusimple-005. 服务器 中等 描述 公司来了一批新的分布式服务器，TuTu 要负责启动他们。 公司的服务器都有一个唯一的不会和其他服务器重复的名字，现在一共有 n 台服务器，这些服务器之间有 m 条数据线连接起来。 如果服务器 x 和 y 之间有一条数据线连接，那么在服务器 x 启动的 t 毫秒后，服务器 y 会自动启动（注意启动是有方向的）。当然如果同时服务器 x 和其他服务器也有数据线连接，而那个服务器在关闭状态，则
ACM各OJ网站简介
Ember_Sky
05-07 5007
ACM各OJ网站简介 写在前面: 以下介绍纯属娱乐, 侵删 （顺序按推荐排序，；其实是随便排的，除了最后的三个，其余的都可以试试看。） AcWing 点击前往 Acwing： 是由北大一神级人物——“大雪菜” 创办的算法交流社区，每道题都有题解/视频题解，中文，界面简洁大方，交流群QQ：728297306，一般群里问的问题，都是由大佬亲自解答。里面除了正常 oj 网站的功能之外, 还提供单人训...
力扣OJ题感悟——链表篇
New_learner55的博客
11-17 317
1.移除链表元素 代码如下: /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* removeElements(struct ListNode* head, int val) ...
【Leetcode】ACM模式的各种输入处理
锥栗的博客
09-21 5208
前言 以牛客笔试题为例，ACM模式下的输入处理示例 ZJ1 附加题 (多行多个int） ZJ1 附加题题目地址 第一行一个int数字，第二行有多个int数字, 那我们第一个存一个数字，第二行用ArrayList存起来。 import java.util.Scanner; import java.util.List; import java.util.ArrayList; public class Main { public static List<Integer> list = ne
Python世界：力扣29题两数相除算法实践
最新发布
来知晓的博客
09-13 434
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
力扣刷题笔记.pdf
12-11
力扣刷题笔记.pdf是一份非常重要的学习资料，里面记录了刷力扣题目时的一些关键思路、解题方法和总结。在这份笔记中，可以记录下每道题的解法和思路，以及一些常见的错误和易错点。这样在以后复习和总结的时候，就...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值