1
func collisionPointers(nums []int) {
2
    left := 0
3
    right := len(nums) - 1
4

5
    for left < right { // 根据题意，有时可能是 left <= right
6
        // 1. 计算当前左右指针组合的状态/结果
7
        // ...
8

9
        // 2. 根据状态决定移动哪个指针
10
        if /* 需要更大的值 */ {
11
            left++
12
        } else if /* 需要更小的值 */ {
13
            right--
14
        } else {
15
            // 找到目标，执行后续逻辑（如记录结果、去重或退出）
16
            // left++
17
            // right--
18
        }
19
    }
20
}

1
func fastSlowPointers(nums []int) int {
2
    slow := 0
3

4
    for fast := 0; fast < len(nums); fast++ {
5
        if /* 满足特定条件，需要保留当前 fast 指向的元素 */ {
6
            // 将 fast 的值赋给 slow（或进行交换）
7
            nums[slow] = nums[fast]
8
            slow++ // slow 推进，准备接收下一个有效元素
9
        }
10
    }
11
    // 返回有效元素的长度或最终 slow 的位置
12
    return slow
13
}

1
func slidingWindowVariable(s string) int {
2
    // 1. 定义数据结构维护窗口内的状态 (通常是 map, slice, 计数器等)
3
    window := make(map[byte]int)
4
    left, right := 0, 0
5
    res := 0 // 或者 math.MaxInt32，取决于求最长还是最短
6

7
    for right < len(s) {
8
        // 2. 将 s[right] 加入窗口，更新状态
9
        c := s[right]
10
        window[c]++
11

12
        // 3. 判断当前窗口状态是否触发了“收缩”条件
13
        for /* 满足收缩条件 (例如窗口内出现了重复字符，或者和超出了限制) */ {
14
            // (可选) 在此处更新求【最短】子串的答案
15

16
            // 4. 准备将 s[left] 移出窗口，更新状态
17
            d := s[left]
18
            window[d]--
19
            left++ // left 右移，窗口收缩
20
        }
21

22
        // 5. 在此处更新求【最长】子串的答案 (因为此时窗口一定满足条件)
23
        // res = max(res, right - left + 1)
24

25
        right++ // right 右移，窗口继续扩张
26
    }
27
    return res
28
}

1
func slidingWindowFixed(nums []int, k int) int {
2
    left, right := 0, 0
3
    // 定义状态变量...
4

5
    for right < len(nums) {
6
        // 1. 将 nums[right] 加入窗口，更新状态
7

8
        // 2. 如果窗口长度达到 k，说明窗口已经成型
9
        if right - left + 1 == k {
10
            // 3. 记录或更新答案
11

12
            // 4. 将 nums[left] 移出窗口，为下一个新元素腾位置
13
            left++
14
        }
15
        right++
16
    }
17
    return res
18
}

1
func binarySearchTemplate1(nums []int, target int) int {
2
    left, right := 0, len(nums)-1
3
    // 可选：ans := -1 // 如果是找边界/找极值，用外部变量记录最近一次符合条件的答案
4

5
    for left <= right {
6
        mid := left + (right - left)/2
7

8
        if nums[mid] == target {
9
            return mid
10
            // 如果是找左边界：ans = mid; right = mid - 1
11
            // 如果是找右边界：ans = mid; left = mid + 1
12
        } else if nums[mid] < target {
13
            left = mid + 1 // target 在右侧，砍掉左半边
14
        } else {
15
            right = mid - 1 // target 在左侧，砍掉右半边
16
        }
17
    }
18

19
    return -1 // 或 return ans
20
}

1
func binarySearchTemplate2(nums []int) int {
2
    left, right := 0, len(nums)-1
3

4
    // 注意：这里绝对不能写等号，否则在某些收缩逻辑下必死循环
5
    for left < right {
6
        mid := left + (right - left)/2
7

8
        if nums[mid] < nums[right] {
9
            // 举例：判断条件满足，说明右半边是平稳上坡，极值不可能在右边。
10
            // 但 mid 本身可能是极值，绝不能踢掉！
11
            right = mid
12
        } else {
13
            // 举例：发生了断层跌落，极值必定在 mid 右侧的悬崖下。
14
            // mid 本身处于悬崖上方，已被洗脱嫌疑，果断跨过！
15
            left = mid + 1
16
        }
17
    }
18

19
    // 循环结束时，left 和 right 撞在一起，就是那个唯一的极值
20
    return nums[left]
21
}