字符串打卡[1]

小齐今天进步了嘛～

于 2020-11-23 22:36:18 发布

阅读量249

点赞数

分类专栏： leetcode刷题文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_43110132/article/details/110006640

版权

leetcode刷题专栏收录该内容

15 篇文章 0 订阅

订阅专栏

551. 学生出勤记录. I

给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：

‘A’ : Absent，缺勤 ‘L’ : Late，迟到 ‘P’ : Present，到场
如果一个学生的出勤记录中不超过一个’A’(缺勤)并且不超过两个连续的’L’(迟到),那么这个学生会被奖赏。

你需要根据这个学生的出勤记录判断他是否会被奖赏。

示例 1:

输入: “PPALLP” 输出: True

class Solution:
    def checkRecord(self, s: str) -> bool:
        anum = 0
        flag = 0
        for i in s:
            if i != 'L':
                flag = 0
                if i == 'A':
                    anum += 1
            else:
                if flag>>1:
                    return False
                flag += 1
            if anum>>1:
                return False
        return True

单纯匹配规则
小错误：最后一个anum的判断应该放在最后或者判断A的部分，而不是最前。如果放在最前，那么类似‘‘AA’’这样的字符串就会判断错误。

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”] 输出：[“o”,“l”,“l”,“e”,“h”]

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        n = len(s)
        for i in range(len(s)>>1):
            s[i], s[n-i-1] = s[n-i-1], s[i]

最简单的思路，对称交换

937. 重新排列日志文件

你有一个日志数组 logs。每条日志都是以空格分隔的字串。

对于每条日志，其第一个字为字母与数字混合的标识符，除标识符之外的所有字为这一条日志的内容。

除标识符之外，所有字均由小写字母组成的，称为字母日志除标识符之外，所有字均由数字组成的，称为数字日志
题目所用数据保证每个日志在其标识符后面至少有一个字。

请按下述规则将日志重新排序：

所有字母日志都排在数字日志之前。字母日志在内容不同时，忽略标识符后，按内容字母顺序排序；在内容相同时，按标识符排序；数字日志
应该按原来的顺序排列。返回日志的最终顺序。

示例：

输入：[“a1 9 2 3 1”,“g1 act car”,“zo4 4 7”,“ab1 off key dog”,“a8 act
zoo”] 输出：[“g1 act car”,“a8 act zoo”,“ab1 off key dog”,“a1 9 2 3
1”,“zo4 4 7”]

class Solution:
    def reorderLogFiles(self, logs: List[str]) -> List[str]:
        def rt(log):
            id_, content = log.split(' ', 1)
            return (0, content, id_) if content[0].isalpha() else (1,)
        return sorted(logs, key = rt)

主要是学习python内置函数sorted，sort跟sorted的区别是sorted是返回值，不改变原来的list，sort是直接改。
同时复习了深浅拷贝
直接赋值：拷贝的是对象

# 直接赋值
a = [5]
b = a
a.append(3)
>>> b:[5,3]
# 深浅拷贝
import copy
# 浅拷贝
a = [1,2,[1,2,3]]
b = copy.copy(a)
# or
b = a.copy()
a.append(3)
>>> a: [1,2,[1,2,3],3]
>>> b: [1,2,[1,2,3]]
a[2].append(3)
>>> a: [1,2,[1,2,3,3],3]
>>> b: [1,2,[1,2,3,3]]
# 深拷贝
a = [1,2,[1,2,3]]
b = copy.deepcopy(a)
a.append(3)
a[2].append(3)
>>> a: [1,2,[1,2,3,3],3]
>>> b: [1,2,[1,2,3]]

824. 山羊拉丁文

给定一个由空格分割单词的句子 S。每个单词只包含大写或小写字母。

我们要将句子转换为 “Goat Latin”（一种类似于猪拉丁文 - Pig Latin 的虚构语言）。

山羊拉丁文的规则如下：

如果单词以元音开头（a, e, i, o, u），在单词后添加"ma"。例如，单词"apple"变为"applema"。

如果单词以辅音字母开头（即非元音字母），移除第一个字符并将它放到末尾，之后再添加"ma"。例如，单词"goat"变为"oatgma"。

根据单词在句子中的索引，在单词最后添加与索引相同数量的字母’a’，索引从1开始。
例如，在第一个单词后添加"a"，在第二个单词后添加"aa"，以此类推。返回将 S 转换为山羊拉丁文后的句子。

示例 1:

输入: “I speak Goat Latin” 输出: “Imaa peaksmaaa oatGmaaaa atinLmaaaaa”

class Solution:
    def toGoatLatin(self, S: str) -> str:
        slist = S.split(' ')
        for i in range(len(slist)):
            if slist[i][0].lower() in ['a','e','i','o','u']:
                slist[i] += 'ma'+'a'*(i+1)
            else:
                slist[i] = slist[i][1:]+slist[i][0]+'ma'+'a'*(i+1)
        return ' '.join(slist)

就根据规则来。

415. 字符串相加

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。

提示：

num1 和num2 的长度都小于 5100 num1 和num2 都只包含数字 0-9 num1 和num2 都不包含任何前导零
你不能使用任何內建 BigInteger 库，也不能直接将输入的字符串转换为整数形式

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        list1 = list(num1)[::-1]
        list2 = list(num2)[::-1]
        if len(list1) < len(list2):
            list1,list2 = list2,list1
        n1 = len(list1)
        n2 = len(list2)
        tof = 0
        listsum = []
        for i in range(n2):
            tsum = int(list1[i])+int(list2[i])+tof
            listsum.append(str(tsum%10))
            tof = tsum//10
            #print(listsum)
        if n1-n2:
            for i in range(n2,n1):
                tsum = int(list1[i])+tof
                listsum.append(str(tsum%10))
                tof = tsum//10
        if tof:
            listsum.append('1')
            #print(listsum)
        return ''.join(listsum[::-1])

先是想去获得最长的list，然后把剩余部分直接接到新的list里面，即listsum，但是这样会忽略掉进位，比如一个99999+9，前面就是一直要进位的，所以要注意。
然后是想要去在range的时候从后往前加，但是有点问题。

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: [“flower”,“flow”,“flight”] 输出: “fl”

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        try:
            nl = []
            for i in range(len(strs[0])):
                flag = 1
                for stritem in strs[1:]:
                    if stritem[i] != strs[0][i]:
                        flag = 0
                        break
                if flag == 0:
                    return ''.join(nl)
                else:
                    nl.append(strs[0][i])
            return ''.join(nl)
        except:
            return ''.join(nl)

又是小旗子
flag用来判断出来以后是不是出现了不等于的
但是其实不用flag，直接break那里直接改成return 就好
但是还是复习了以下break，continue，pass的用法

# break:
# 在这里是跳出整个for循环
# continue：
# 只是跳出当前循环的item
# pass:
# 占位
# example：
for i in range(5):
	if i == 3:
		break
	print(i)
> 0
> 1
> 2

for i in range(5)
	if i == 3:
		continue
	print(i)
> 0
> 1
> 2
> 4

28. 实现strStr()

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置
(从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = “hello”, needle = “ll” 输出: 2

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        n = len(needle)
        if not n:
            return 0
        if len(haystack) < n:
            return -1
        for i in range(len(haystack)-n+1):
            if haystack[i:i+n] == needle:
                return i
        return -1

滑动窗口，然后比较。
可优化方法是逐个比较。
另有优化方法：
- https://leetcode-cn.com/problems/implement-strstr/solution/shi-xian-strstr-by-leetcode/
- https://leetcode-cn.com/problems/implement-strstr/solution/kmp-suan-fa-xiang-jie-by-labuladong/
一版错误代码。为了限定长度，可以像上面一样从for i in xxx 开始限制，但是我为了省事，选择用try来限制，超出长度就报错。在list可以，会报 ‘out of range’ 的错，但是字符串不会，比如一个字符串aaaaa，如果选择其中的[3:7]，如果是list会报错，但是str会输出aa，无报错。

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        n = len(needle)
        if not n:
            return 0
        if len(haystack) < n:
            return -1
        try:
            for i in range(len(haystack)):
                print(haystack[i:i+n])
                if haystack[i:i+n] == needle:
                    return i
        except:
            return -1

小齐今天进步了嘛～

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
字符串打卡[1]

551. 学生出勤记录. I 给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：‘A’ : Absent，缺勤 ‘L’ : Late，迟到 ‘P’ : Present，到场如果一个学生的出勤记录中不超过一个’A’(缺勤)并且不超过两个连续的’L’(迟到),那么这个学生会被奖赏。你需要根据这个学生的出勤记录判断他是否会被奖赏。示例 1:输入: “PPALLP” 输出: Trueclass Solution: def checkRecord(self, s: str)
复制链接

扫一扫