代码随想录算法训练营第八天| 344. 反转字符串、541. 反转字符串 II、LCR 122. 路径加密、151. 反转字符串中的单词、LCR 182. 动态口令

LeetCode 344. 反转字符串
题目链接：344. 反转字符串 - 力扣（LeetCode）

​思路：

已经以数组的形式给出了，题目要求原地修改，直接使用双指针来实现就好。

#python
class Solution:
    def reverseString(self, s: List[str]) -> None:
        n=len(s)
        l,r=0,n-1
        while l<r:
            s[l],s[r]=s[r],s[l]
            l+=1
            r-=1
        return 

#java
class Solution {
    public void reverseString(char[] s) {
        int left = 0, right = s.length - 1;
        while (left < right) {
            s[left] = (char) (s[left] ^ s[right]);
            s[right] = (char) (s[left] ^ s[right]);
            s[left] = (char) (s[left] ^ s[right]);
            left++;
            right--;
        }
    }
}

困难与想法：

原地排序，两个指针相遇之后直接return就结束了

---

LeetCode 541. 反转字符串 II

题目链接：541. 反转字符串 II - 力扣（LeetCode）

​
思路：

注意讨论一下剩余字符的情况。我们可以想象每次都是向后跳跃2k个字符，所以用for循环挺好，规定了起点、终点、步长。

代码：

#python
class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        n=len(s)
        s=list(s)
        for i in range(0,n,2*k):
            if i+2*k<=n or (i+k<=n and i+2*k>n):
                s[i:i+k]=s[i:i+k][::-1]
            elif i<=n and i+k>n:
                s[i:n]=s[i:n][::-1]
        return ''.join(s)

#java
class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0; i < ch.length; i += 2 * k){
            int start = i;
            int end =Math.min(ch.length - 1, start + k -1);
            while(start < end){
                ch[start] ^= ch[end];
                // ch[start] ^= ch[end];
                ch[end] ^= ch[start];
                ch[start] ^= ch[end];
                start++;
                end--;
            }
        }
        return new String(ch);
    }
}

困难与想法：

第一种情况，加了2k还是小于n，那当然k内直接反转就好；

第二种情况，k<n<2k时，也是一样的k内反转就好，所以两种情况写在一起；

第三种情况，k>n了，那么就到n的部分反转呗；

上面三个情况可以直接切片，也可以自己用双指针来实现一个反转函数，但是其实做过一次就行，没必要每次都写反转函数的。

---

LeetCode LCR 122. 路径加密
题目链接：LCR 122. 路径加密 - 力扣（LeetCode）

​​
思路：
不知道这题的意义是啥，遍历一下字符数组，把'.'换成' '就好了。

代码：

#python
class Solution:
    def pathEncryption(self, path: str) -> str:
        res=[]
        for c in path:
            if c=='.':
                res.append(' ')
            else:
                res.append(c)
        return ''.join(res)

#java
class Solution {
    public String pathEncryption(String path) {
        char[] ch = path.toCharArray();
        for(int i = 0; i < ch.length; i++){
            if(ch[i] == '.'){
                ch[i] = ' ';
            }
            else{
                continue;
            }
        }
        return new String(ch);
    }
}

困难与想法：

直接做就好

---

LeetCode 151. 反转字符串中的单词
题目链接：151. 反转字符串中的单词 - 力扣（LeetCode）

​​
思路：
注意两个问题，一个是空格，还有一个就是两次反转，但其实我更推荐直接使用队列来做，看下列的代码

代码：

#python
class Solution:
    def reverseWords(self, s: str) -> str:
        s=s.split()
        res=deque()
        for x in s:
            if x==' ':
                continue
            else:
                res.appendleft(x.strip())
        return " ".join(res).strip()

#java
class Solution {
    public String reverseWords(String s) {
        s = s.trim();
        String[] words = s.split("\\s+");
        int left = 0, right = words.length - 1;
        while(left < right){
            String tmp = words[left];
            words[left] = words[right];
            words[right] = tmp;
            left++;
            right--;
        }
        return String.join(" ", words);
    }
}

困难与想法：

最后记得返回字符串

---

LeetCode LCR 182. 动态口令
题目链接：LCR 182. 动态口令 - 力扣（LeetCode）

​​
思路：
最简单的是直接切片就好，一行就搞定，但是一想到这种要反转的题就可以考虑双指针or双端队列，本题目就同双端队列来试试看。

代码：

#python
class Solution:
    def dynamicPassword(self, password: str, target: int) -> str:
        res=deque()
        for i in range(target):
            res.append(password[i])
        for i in range(len(password)-1,target-1,-1):
            res.appendleft(password[i])
        return ''.join(res)

#java
class Solution {
    public String dynamicPassword(String password, int target) {
        Deque<Character> deque = new ArrayDeque<>();
        for(int i = 0; i < target; i++){
            deque.offerLast(password.charAt(i));
        }
        for(int i = password.length() - 1; i >= target; i--){
            deque.offerFirst(password.charAt(i));
        }
        StringBuilder sb = new StringBuilder();
        for(char ch : deque){
            sb.append(ch);
        }
        return sb.toString();
    }
}

困难与想法：

最后记得返回字符串