跳转至

3823. 反转一个字符串里的字母后反转特殊字符

题目描述

给你一个由小写英文字母和特殊字符组成的字符串 s。

你的任务是 按顺序 执行以下操作：

  • 反转小写字母，并将它们放回原来字母所占据的位置。
  • 反转特殊字符，并将它们放回原来特殊字符所占据的位置。

返回执行反转操作后的结果字符串。

 

示例 1：

输入： s = ")ebc#da@f("

输出： "(fad@cb#e)"

解释：

  • 字符串中的字母为 ['e', 'b', 'c', 'd', 'a', 'f']：
    • 反转它们得到 ['f', 'a', 'd', 'c', 'b', 'e']
    • s 变为 ")fad#cb@e("
  • 字符串中的特殊字符为 [')', '#', '@', '(']：
    • 反转它们得到 ['(', '@', '#', ')']
    • s 变为 "(fad@cb#e)"

示例 2：

输入： s = "z"

输出： "z"

解释：

字符串仅包含一个字母，反转它不会改变字符串。没有特殊字符。

示例 3：

输入： s = "!@#$%^&*()"

输出： ")(*&^%$#@!"

解释：

字符串不包含字母。字符串全部由特殊字符组成，因此反转特殊字符即反转整个字符串。

 

提示：

  • 1 <= s.length <= 100
  • s 仅由小写英文字母和 "!@#$%^&*()" 中的特殊字符组成。

解法

方法一

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution:
    def reverseByType(self, s: str) -> str:
        a = []
        b = []
        for c in s:
            if c.isalpha():
                a.append(c)
            else:
                b.append(c)
        return ''.join(a.pop() if c.isalpha() else b.pop() for c in s)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    public String reverseByType(String s) {
        StringBuilder a = new StringBuilder();
        StringBuilder b = new StringBuilder();
        char[] t = s.toCharArray();
        for (char c : t) {
            if (Character.isLetter(c)) {
                a.append(c);
            } else {
                b.append(c);
            }
        }
        int j = a.length(), k = b.length();
        for (int i = 0; i < t.length; ++i) {
            if (Character.isLetter(t[i])) {
                t[i] = a.charAt(--j);
            } else {
                t[i] = b.charAt(--k);
            }
        }
        return new String(t);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Solution {
public:
    string reverseByType(string s) {
        string a, b;

        for (char c : s) {
            if (isalpha(c)) {
                a.push_back(c);
            } else {
                b.push_back(c);
            }
        }

        int j = a.size(), k = b.size();
        for (int i = 0; i < s.size(); ++i) {
            if (isalpha(s[i])) {
                s[i] = a[--j];
            } else {
                s[i] = b[--k];
            }
        }

        return s;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
func reverseByType(s string) string {
    a := make([]byte, 0)
    b := make([]byte, 0)
    t := []byte(s)

    for _, c := range t {
        if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') {
            a = append(a, c)
        } else {
            b = append(b, c)
        }
    }

    j, k := len(a), len(b)
    for i := 0; i < len(t); i++ {
        if (t[i] >= 'A' && t[i] <= 'Z') || (t[i] >= 'a' && t[i] <= 'z') {
            j--
            t[i] = a[j]
        } else {
            k--
            t[i] = b[k]
        }
    }

    return string(t)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function reverseByType(s: string): string {
    const a: string[] = [];
    const b: string[] = [];
    const t = s.split('');

    for (const c of t) {
        if (/[a-zA-Z]/.test(c)) {
            a.push(c);
        } else {
            b.push(c);
        }
    }

    let j = a.length,
        k = b.length;
    for (let i = 0; i < t.length; i++) {
        if (/[a-zA-Z]/.test(t[i])) {
            t[i] = a[--j];
        } else {
            t[i] = b[--k];
        }
    }

    return t.join('');
}

评论