2025-02-22：找出加密后的字符串。用go语言，给定一个字符串 s 和一个整数 k，请使用以下方法对字符串进行加密：

对于字符串 s 中的每个字符 c，将其替换为在字符串中 c 后面的第 k 个字符（以循环的方式进行）。

最终返回加密后的字符串。

1 <= s.length <= 100。

1 <= k <= 10000。

s 仅由小写英文字母组成。

输入： s = “dart”, k = 3。

输出： “tdar”。

解释：

对于 i = 0，‘d’ 后面的第 3 个字符是 ‘t’。

对于 i = 1，‘a’ 后面的第 3 个字符是 ‘d’。

对于 i = 2，‘r’ 后面的第 3 个字符是 ‘a’。

对于 i = 3，‘t’ 后面的第 3 个字符是 ‘r’。

答案2025-02-22：

chatgpt

题目来自leetcode3210。

大体步骤如下：

1.给定输入字符串 s=“dart” 和整数 k=3。

2.计算 k 对字符串长度的取模，因为每个字符需要向后移动 k 个位置，但是超过字符串长度时需要循环移动，所以取模是必要的。在这个例子中，k % len(s) = 3 % 4 = 3。

3.将字符串分成两部分：s[k:] 表示从第 k 个字符到末尾的子字符串（“t”），s[:k] 表示从开头到第 k-1 个字符的子字符串（“dar”）。

4.加密后的字符串是这两部分连接起来的结果，即 “t” + “dar” = “tdar”。

整体时间复杂度：

• 计算 k % len(s) 的时间复杂度是 O(1)。

• 字符串的连接操作的时间复杂度为 O(n)，n 是字符串的长度。

所以总的时间复杂度为 O(1) + O(n) = O(n)。

额外空间复杂度：

• 除了存储输入字符串 s 和整数 k 的空间外，需要存储两个子字符串 s[k:] 和 s[:k]，它们的长度分别为 len(s) - k 和 k。

• 加密后的字符串需要存储，长度为 len(s)。

所以总的额外空间复杂度是 O(n)。

Go完整代码如下：

package main

import "fmt"

func getEncryptedString(s string, k int) string {
	k %= len(s)
	return s[k:] + s[:k]
}


func main() {
	s := "dart"
	k := 3
	result := getEncryptedString(s, k)
	fmt.Println(result)
}

Rust完整代码如下：

fn get_encrypted_string(s: &str, k: usize) -> String {
    let len = s.len();
    let k = k % len; // 计算有效的 k 值
    let (first, second) = s.split_at(k);
    format!("{}{}", second, first) // 组合新的字符串
}

fn main() {
    let s = "dart";
    let k = 3;
    let result = get_encrypted_string(s, k);
    println!("{}", result);
}

Python完整代码如下：

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

def get_encrypted_string(s: str, k: int) -> str:
    k %= len(s)  # 计算有效的 k 值
    return s[k:] + s[:k]  # 组合新的字符串

def main():
    s = "dart"
    k = 3
    result = get_encrypted_string(s, k)
    print(result)

if __name__ == "__main__":
    main()