刷题第七天 344.反转字符串 541.反转字符串II LCR 122.路径加密 LCR182. 动态加密 151.反转字符串中单词

344. 反转字符串

class Solution(object):
    def reverseString(self, s):
        i = 0
        j = len(s) - 1
        while (i <= j):
            tmp = s[i]
            s[i] = s[j]
            s[j] = tmp
            i += 1
            j -= 1

两个指针，前后交换就行

541. 反转字符串II

class Solution(object):
    def reverseStr(self, s, k):
        def reverse_subset(s):
            i = 0
            j = len(s) - 1
            while (i <= j):
                tmp = s[j]
                s[j] = s[i]
                s[i] = tmp
                i += 1
                j -= 1
            return s
        s = list(s)
        for i in range(0, len(s), 2*k):
            if i + k < len(s):
                s[i : i + k] = reverse_subset(s[i : i + k])
                continue
            else:
                s[i : len(s)] = reverse_subset(s[i : len(s)])
        return ''.join(s)

python中的字符串都是不可变的，不能修改字符串中的单个字符，所以要先转化为字符列表，修改字符列表之后再返回字符串 = list(s) 以及''.join(s)

join()用于将序列中的元素以指定的字符连接成一个新的字符串

LCR 122.路径加密

class Solution(object):
    def pathEncryption(self, path):
        p_list = list(path)
        for i in range(len(p_list)):
            if p_list[i] == ".":
                p_list[i] = " "
        return ''.join(p_list)

replace和join都可以实现：其中join的意思是使用前面的字符串作为连接符，链接后面的列表

LCR 182.动态口令

class Solution(object):
    def dynamicPassword(self, password, target):
        password = list(password)
        list_1 = password[0 : target]
        list_2 = password[target:]
        result = list_2 + list_1
        return ''.join(result)

## 看了解析，不用变成字符列表，直接利用切片操作        
## return password[target:] + password[:target]

可以采用多次反转的方式，先把前target个反转，再把后面的反转 最后整体反转就把前target个放到最后了

151.反转字符串中单词

class Solution(object):
    def reverseWords(self, s):
        s_list = s.split(' ')
        s_list = s_list[::-1]
        i = 0
        s_list = ' '.join(s_list)
        while i < len(s_list):
            if i == 0 and s_list[i] == ' ':               ##首位空格去重
                s_list = s_list[1:]
                continue
            if i == len(s_list) - 1 and s_list[i] == ' ': ##最后一位空格去重
                s_list = s_list[:i]
                i = i - 1
                continue
            if s_list[i] == ' ' and s_list[i - 1] == ' ': ##中间去重
                s_list = s_list[:i - 1] + s_list[i:]
            else:
                i = i + 1
        return s_list

反转用python很快，但是涉及到首位空格以及中间空格重复的情况，想到的是手动去重，后面想到python利用strip()可以去掉空格

class Solution(object):
    def reverseWords(self,s):
        s_list = s.split(' ')
        s_list = s_list[::-1]
        _reverse_list = [item for item in s_list if item.strip()]
        return ' '.join(_reverse_list)