今天是day7
题目一：反转字符串：本题较简单：
func reverseString(s []byte) {
left:=0
right:=len(s) - 1
for left < right {
s[left],s[right] = s[right],s[left]
left++
right--
}
}
class Solution:
def reverseString(self,s:List[str]) -> None:
left,right = 0,len(s) - 1
while left < right:
s[left],s[right] = s[right],s[left]
left+=1
right-=1
本题也可用栈解决：
class Solution:
def reverseString(self,s:List[str]) -> None:
stack = []
for char in s:
stack.append(char)
for i in range(len(s)):
s[i] = stack.pop()
题目二：反转字符串二：每2k个字符就反转前k个字符
func reverseStr(s string, k int) string {
ss:=[]byte(s) // 用以备用的存储byte断言后的数组
length:=len(s)
for i:=0;i<length;i += 2*k{ // 开始记数是否达到2k
if i + k <= length {
reverse(ss[i:i+k]) //从字符串开头算起，每计数至 2k 个字符，反转这 2k 字符中的前 k 个字符。如果剩余字符少于 k 个，则将剩余字符全部反转
}else{
reverse(ss[i:length]) //这个条件处理剩余字符少于 k 个的情况，或者剩余字符在 k 和 2k 之间。
}
}
return string(ss)
}
//反转函数，用以将一个byte数组首尾交换数值
func reverse(b []byte) {
left:=0
right:=len(b) - 1
for left < right {
b[left],b[right] = b[right],b[left]
left++
right--
}
}
class Solution:
def reverseStr(self, s: str, k: int) -> str:
def reverse_substring(text):
left,right = 0,len(text) - 1
while left < right:
text[left],text[right] = text[right],text[left]
left+=1
right-=1
return text
res = list(s)
for cur in range(0,len(s),2 * k):
res[cur:cur + k] = reverse_substring(res[cur:cur + k])
return ''.join(res)
"将一个字符串列表（或其他可迭代对象）中的元素以指定的字符连接起来，生成一个新的字符串"
class Solution:
def reverseStr(self, s: str, k: int) -> str:
p = 0
while p < len(s):
p2 = p + k
s = s[:p] + s[p:p2][::-1] + s[p2:]
"s[:p] 表示从字符串的开头到索引 p-1 的部分（不包括索引 p）。"
"s[p:p2] 表示从索引 p 到索引 p2-1 的部分（不包括索引 p2)"
"s[p:p2][::-1] 表示将上一步得到的部分进行反转。"
"最后，s[p2:] 表示从索引 p2 开始到字符串的末尾的部分。"
p = p + 2 * k
return s
题目三：反转字符串里的单词：
func reverseWords(s string) string {
//先将字符串s转为byte数组以供操作
b := []byte(s)
//这段代码的主要思路是遍历字符串的每个字符，当遇到非空格字符时，将其复制到合并后的字符串中，并在非空格字符后面添加一个空格（除了第一个非空格字符）。这样就实现了 将连续的空格合并为一个空格的功能。
slow:=0
for i:=0;i<len(b);i++{
//检查当前字符是否是空格字符。
if b[i] != ' '{
//如果 slow 不为 0（说明不是第一个字符），则在合并后的字符串中添加一个空格，并将 slow 指针移动到下一个位置
if slow!=0 {
b[slow] = ' '
slow++
}
//开始内部的循环，用于找到连续的非空格字符。
for i < len(b) && b[i] != ' '{
//将非空格字符复制到合并后的字符串中。
b[slow] = b[i]
slow++
i++
}
}
}
b = b[0:slow]
reverse(b)
last:=0
for i:=0;i<=len(b);i++{
if i == len(b) || b[i] == ' '{
reverse(b[last:i])
last = i + 1
}
}
return string(b)
}
//双指针翻转函数备用
func reverse(b []byte) {
left:=0
right:=len(b) - 1
for left < right {
b[left],b[right] = b[right],b[left]
left++
right--
}
}
import (
"fmt"
)
func reverseWords(s string) string {
//1.使用双指针删除冗余的空格
slowIndex, fastIndex := 0, 0
b := []byte(s)
//删除头部冗余空格
for len(b) > 0 && fastIndex < len(b) && b[fastIndex] == ' ' {
fastIndex++
}
//删除单词间冗余空格
for ; fastIndex < len(b); fastIndex++ {
if fastIndex-1 > 0 && b[fastIndex-1] == b[fastIndex] && b[fastIndex] == ' ' {
continue
}
b[slowIndex] = b[fastIndex]
slowIndex++
}
//删除尾部冗余空格
if slowIndex-1 > 0 && b[slowIndex-1] == ' ' {
b = b[:slowIndex-1]
} else {
b = b[:slowIndex]
}
//2.反转整个字符串
reverse(b)
//3.反转单个单词 i单词开始位置，j单词结束位置
i := 0
for i < len(b) {
j := i
for ; j < len(b) && b[j] != ' '; j++ {
}
reverse(b[i:j])
i = j
i++
}
return string(b)
}
func reverse(b []byte) {
left := 0
right := len(b) - 1
for left < right {
b[left], b[right] = b[right], b[left]
left++
right--
}
}
class Solution:
def reverseWords(self, s: str) -> str:
"移除空白字符"
s = s.strip()
"实现自身反转"
s = s[::-1]
"对给定字符串s进行切割，并将遍历结果以此以空白打头的join拟合"
s= ' '.join(word[::-1] for word in s.split())
return s
class Solution:
def reverseWords(self, s: str) -> str:
"先对s进行去空格操作"
words = s.split()
"左右指针被用于进行双指针法交换元素"
left,right = 0,len(words)-1
while left < right:
words[left],words[right] = words[right],words[left]
left+=1
right-=1
"最终将其拟合"
return " ".join(words)
题目4：右旋转字符串
package main
import "fmt"
//反转函数
func reverse(strByte []byte,l,r int){
for l < r {
strByte[l],strByte[r] = strByte[r],strByte[l]
l++
r--
}
}
func main(){
//声明与获取键盘输入
var str string
var target int
fmt.Scanln(&target)
fmt.Scanln(&str)
//声明一个空的byte数组将str放入
strByte := []byte(str)
//三次反转
reverse(strByte,0,len(strByte) - 1)
reverse(strByte,0,target - 1)
reverse(strByte,target,len(strByte) - 1)
fmt.Printf(string(strByte))
}
"获取输入的数字K和字符串"
k = int(input())
s = input()
"使用切片来反转第一段和第二段字符串"
s= s[len(s) - k:] + s[:len(s) - k]
print(s)
func intersection(nums1 []int, nums2 []int) []int {
//键的类型是 int，值的类型是一个空的结构体 struct{}。这种结构体通常被称为 "占位符" 或 "标记"，它没有任何字段，只是作为一个占位符存在，用于表示值的存在与否，通常用于实现集合或者标记某个键是否存在的需求。
set := make(map[int]struct{},0)
res := make([]int,0)
//忽略了键而只关心值并对此遍历，其次if仅判断值是否存在而不关心值为何数，所以使用忽略符和ok来判断，ok为一个bool类型，其后！ok代表的是一旦不ok即v不存在，就将v放入set中,在 Go 语言中，map 的键是无序唯一的，而值则可以是任意类型。在这种情况下，我们只关心键而不关心值，我们只是想利用 map 中键的唯一性来实现去重的功能。
for _,v:=range nums1{
if _,ok := set[v];!ok{
set[v] = struct{}{}
}
}
//此时已经实现了一个拥有v的set集,再对nums2遍历，判断逻辑同上，只要存在相同的元素就将其加入res中并同步从set中剔除v从而达到仅将相同的元素放入res中
for _,v:= range nums2{
if _,ok := set[v];ok{
res = append(res,v)
delete(set,v)
}
}
return res
}
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
"空字典"
table = {}
"遍历nums1，复用的遍历并把值赋入，这样table的值就有了"
for num in nums1:
table[num] = table.get(num,0) + 1
"空集合res"
res = set()
"遍历nums2"
for num in nums2:
"在table里有相同的元素，将其加入空res并删除掉table里的"
if num in nums2:
if num in table:
res.add(num)
del table[num]
"再返回一个list转换后的res"
return list(res)