今天是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)