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