2026-05-30：反转一个字符串里的字母后反转特殊字符。用go语言，给定一个只包含小写英文字母和特殊字符的字符串 s。按顺序进行两步变换：

福大大架构师每日一题

发布于 2026-06-01 18:19:38

830

2026-05-30：反转一个字符串里的字母后反转特殊字符。用go语言，给定一个只包含小写英文字母和特殊字符的字符串 s。按顺序进行两步变换：先把所有小写字母的相对顺序整体反过来，并放回到它们原来所在的位置；再把所有特殊字符的相对顺序整体反过来，并放回到它们原来所在的位置。最终返回变换后的字符串。

1 <= s.length <= 100。

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

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

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

解释：

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

题目来自力扣3823。

**一、分步骤执行过程（输入：!@#$%^&*()）**

输入字符串：!@#$%^&*()，全程无小写字母，全是特殊字符。

步骤1：执行 reverseByType 函数，将字符串转为字节切片

把字符串!@#%^&*()转换成字节数组t，数组元素依次为：!、@、#、

步骤2：第一次调用 reverse 函数（处理小写字母）

• 判断条件：是小写字母（a-z）
• 执行逻辑：
1. 1. 初始化双指针i=0（左指针）、j=9（右指针）；
2. 2. 左指针向右遍历：所有元素都是特殊字符，不满足“是小写字母”的条件，左指针停止；
3. 3. 右指针向左遍历：所有元素都是特殊字符，不满足“是小写字母”的条件，右指针停止；
4. 4. 交换左右指针指向的元素，然后指针向内移动；
5. 5. 循环持续到指针相遇，最终结果：字节数组被完全反转。
• 第一次反转后字节数组：)、(、*、&、^、%、$、#、@、!。

补充：如果字符串包含字母的执行逻辑（帮助理解）

举个例子：输入a!b@c

1. 第一次reverse（判断：是字母）：
- • 跳过字母，只交换特殊字符？不，逻辑是：满足条件（是字母）就跳过，不满足（特殊字符）就停下交换；
- • 最终效果：字母的相对顺序整体反转，放回原位置，特殊字符位置不变；示例：a!b@c → 字母反转后 → c!b@a。

步骤3：第二次调用 reverse 函数（处理特殊字符）

• 判断条件：不是小写字母（即特殊字符）
• 执行逻辑：
1. 1. 此时字节数组是)、(、*、&、^、%、$、#、@、!；
2. 2. 遍历所有元素：全是特殊字符，都满足“不是小写字母”的条件；
3. 3. 双指针会直接遍历到相遇，没有任何字符需要交换；
• 第二次反转后字节数组：保持)、(、*、&、^、%、$、#、@、!不变。

步骤4：将字节切片转回字符串

最终得到字符串：)(*&^%$#@!，与题目要求的输出一致。

二、时间复杂度分析

1. 字符串转字节切片：O(n)，n是字符串长度；
2. 第一次reverse函数：双指针遍历整个切片一次，O(n)；
3. 第二次reverse函数：双指针遍历整个切片一次，O(n)；
4. 字节切片转回字符串：O(n)；

总时间复杂度：O(n) + O(n) + O(n) + O(n) = O(n) （线性复杂度，执行时间与字符串长度成正比）

三、额外空间复杂度分析

额外空间指：除了输入数据外，程序额外开辟的内存空间。

1. 代码中将字符串转为字节切片t，开辟了长度为n的字节数组，占用O(n)空间；
2. 所有变量（指针i、j、临时变量等）都是常数级空间，O(1)；

总额外空间复杂度：O(n) （需要额外开辟和输入字符串等长的存储空间）

总结

1. 执行过程：输入全特殊字符→转字节切片→第一次反转字母（实际反转整个字符串）→第二次反转特殊字符（无交换）→转回字符串；
2. 时间复杂度：O(n)（线性复杂度）；
3. 额外空间复杂度：O(n)（需要等长的字节切片存储数据）。

Go完整代码如下：

package main

import (
    "fmt"
)

func reverse(t []byte, f func(byte) bool) {
    i, j := 0, len(t)-1
    for i < j {
        for i < j && f(t[i]) {
            i++
        }
        for i < j && f(t[j]) {
            j--
        }
        t[i], t[j] = t[j], t[i]
        i++
        j--
    }
}

func reverseByType(s string) string {
    t := []byte(s)
    reverse(t, func(ch byte) bool { return 'a' <= ch && ch <= 'z' })
    reverse(t, func(ch byte) bool { return !('a' <= ch && ch <= 'z') })
    return string(t)
}

func main() {
    s := "!@#$%^&*()"
    result := reverseByType(s)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

def reverse(t, condition_func):
    """按条件反转字符序列"""
    i, j = 0, len(t) - 1
    t_list = list(t)  # 转换为列表以便修改
    while i < j:
        # 从左向右找到第一个不满足条件的字符
        while i < j and condition_func(t_list[i]):
            i += 1
        # 从右向左找到第一个不满足条件的字符
        while i < j and condition_func(t_list[j]):
            j -= 1
        # 交换
        t_list[i], t_list[j] = t_list[j], t_list[i]
        i += 1
        j -= 1
    return ''.join(t_list)


def reverse_by_type(s):
    """按字符类型反转字符串"""
    # 第一次反转：对小写字母进行反转
    s = reverse(s, lambda ch: 'a' <= ch <= 'z')
    # 第二次反转：对非小写字母进行反转
    s = reverse(s, lambda ch: not ('a' <= ch <= 'z'))
    return s


def main():
    s = "!@#$%^&*()"
    result = reverse_by_type(s)
    print(result)


if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>

void reverse(std::string& t, bool (*f)(char)) {
    int i = 0, j = t.length() - 1;
    while (i < j) {
        // 从左向右找到第一个不满足条件的字符
        while (i < j && f(t[i])) {
            i++;
        }
        // 从右向左找到第一个不满足条件的字符
        while (i < j && f(t[j])) {
            j--;
        }
        // 交换
        std::swap(t[i], t[j]);
        i++;
        j--;
    }
}

std::string reverseByType(const std::string& s) {
    std::string t = s;  // 复制字符串
    // 第一次反转：对小写字母进行反转
    reverse(t, [](char ch) -> bool {
        return 'a' <= ch && ch <= 'z';
    });
    // 第二次反转：对非小写字母进行反转
    reverse(t, [](char ch) -> bool {
        return !('a' <= ch && ch <= 'z');
    });
    return t;
}

int main() {
    std::string s = "!@#$%^&*()";
    std::string result = reverseByType(s);
    std::cout << result << std::endl;
    return 0;
}