1
func twoSum(nums []int, target int) []int {
2
    mp := map[int]int{}
3
    for i, val := range nums {
4
        if index, exist := mp[target-val]; exist {
5
            return []int{index, i} // 找到配对
6
        }
7
        mp[val] = i // 记录当前值
8
    }
9
    return []int{}
10
}

1
func romanToInt(s string) int {
2
    ans := 0
3
    for i := range s {
4
        value := symbolValues[s[i]]
5
        if i < n-1 && value < symbolValues[s[i+1]] {
6
            ans -= value // 小的在前，减去（如 IV 的 I）
7
        } else {
8
            ans += value
9
        }
10
    }
11
    return ans
12
}

1
for i := 0; i < n; i++ {
2
    for nums[i] >= 1 && nums[i] <= n && nums[i] != nums[nums[i]-1] {
3
        nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1] // 交换到正确位置
4
    }
5
}
6
// 找第一个不在位置的
7
for i := 0; i < n; i++ {
8
    if nums[i] != i+1 { return i + 1 }
9
}
10
return n + 1

1
for _, str := range strs {
2
    arr := strings.Split(str, "")
3
    sort.Strings(arr)
4
    key := strings.Join(arr, "") // 排序后的字符串作 key
5
    m[key] = append(m[key], str)
6
}

1
mp := map[int]bool{}
2
for _, v := range nums { mp[v] = true }
3
for key := range mp {
4
    if !mp[key-1] { // 只从起点开始数
5
        count := 1
6
        for mp[key+1] { count++; key++ }
7
        res = max(res, count)
8
    }
9
}

1
single := 0
2
for _, num := range nums { single ^= num }
3
return single

1
count := 0; maj := nums[0]
2
for i := 1; i < n; i++ {
3
    if count == 0 { maj = nums[i] }       // 换候选人
4
    if nums[i] == maj { count++ } else { count-- }
5
}

1
answer[0] = 1
2
for i := 1; i < n; i++ { answer[i] = answer[i-1] * nums[i-1] } // 左累积
3
temp := 1
4
for i := n-1; i >= 0; i-- {
5
    answer[i] *= temp // 乘右累积
6
    temp *= nums[i]   // 更新右累积
7
}

1
l := 0
2
for r := 0; r < len(nums); r++ {
3
    if nums[r] != 0 { nums[l], nums[r] = nums[r], nums[l]; l++ }
4
}

1
m := map[int]int{0: 1}; pre := 0; count := 0
2
for _, num := range nums {
3
    pre += num
4
    count += m[pre-k] // 之前有多少个前缀和 = pre-k
5
    m[pre]++          // 记录当前前缀和出现次数
6
}

1
for _, num := range nums { right += num }
2
for i, num := range nums {
3
    right -= num        // 先减当前元素
4
    if left == right { return i }
5
    left += num         // 再加到左侧
6
}

1
mp := map[int]int{}
2
for _, v := range arr { mp[v]++ }      // 第一次：统计频次
3
mp2 := map[int]bool{}
4
for _, v := range mp {                  // 第二次：检查频次是否重复
5
    if mp2[v] { return false }
6
    mp2[v] = true
7
}

1
maxVal := candies[0]
2
for _, v := range candies { if v > maxVal { maxVal = v } }
3
for i, v := range candies { res[i] = v + extraCandies >= maxVal }

1
cnt := map[int]int{}
2
for _, x := range nums {
3
    if cnt[k-x] > 0 { cnt[k-x]--; ans++ } // 找到配对
4
    else { cnt[x]++ }
5
}

1
h := 0
2
for _, g := range gain { h += g; ans = max(ans, h) }

1
func findDifference(nums1 []int, nums2 []int) [][]int {
2
    m1 := make(map[int]bool)
3
    for _, num := range nums1 { m1[num] = true }  // nums1 → 集合
4
    m2 := make(map[int]bool)
5
    for _, num := range nums2 { m2[num] = true }  // nums2 → 集合
6
    ans := make([][]int, 2)
7
    for k := range m1 { if !m2[k] { ans[0] = append(ans[0], k) } }  // nums1 独有
8
    for k := range m2 { if !m1[k] { ans[1] = append(ans[1], k) } }  // nums2 独有
9
    return ans
10
}

1
func equalPairs(grid [][]int) int {
2
    mp := make(map[string]int)
3
    for i := 0; i < len(grid); i++ {        // 每行序列化
4
        s := ""
5
        for j := 0; j < len(grid[0]); j++ { s += strconv.Itoa(grid[i][j]) + " " }
6
        mp[s]++
7
    }
8
    ans := 0
9
    for j := 0; j < len(grid[0]); j++ {     // 每列查询
10
        s := ""
11
        for i := 0; i < len(grid); i++ { s += strconv.Itoa(grid[i][j]) + " " }
12
        ans += mp[s]  // 加上匹配的行数
13
    }
14
    return ans
15
}

1
func smallestNumber(n int, t int) int {
2
    for {
3
        n1 := 1; num := n
4
        for num > 0 {
5
            n1 = num % 10 * n1   // 取每一位相乘
6
            num /= 10
7
            if n1 == 0 { break } // 含 0 则乘积为 0，一定能被整除
8
        }
9
        if n1 % t == 0 { return n }
10
        n++
11
    }
12
}

1
func findMissingElements(nums []int) []int {
2
    slices.Sort(nums)  // 排序
3
    ans := []int{}
4
    for i := 0; i < len(nums)-1; i++ {
5
        for j := nums[i]; j != nums[i+1]-1; j++ {  // 填充缺失的间隙
6
            ans = append(ans, j+1)
7
        }
8
    }
9
    return ans
10
}

1
l, r := 0, len(height)-1
2
for l < r {
3
    if height[l] < height[r] {
4
        res = max(res, (r-l)*height[l]); l++
5
    } else {
6
        res = max(res, (r-l)*height[r]); r--
7
    }
8
}

1
sort.Ints(nums)
2
for l := 0; l < n; l++ {
3
    if nums[l] > 0 { break }                    // 最小值 > 0 不可能有解
4
    if l > 0 && nums[l] == nums[l-1] { continue } // 去重
5
    m, r := l+1, n-1
6
    for m < r {
7
        sum := nums[l] + nums[m] + nums[r]
8
        if sum == 0 {
9
            res = append(res, []int{nums[l], nums[m], nums[r]})
10
            m++; r--
11
            for m < r && nums[m] == nums[m-1] { m++ }   // 去重
12
            for m < r && nums[r] == nums[r+1] { r-- }   // 去重
13
        } else if sum > 0 { r-- } else { m++ }
14
    }
15
}

1
cur, lst := 0, len(nums)-1
2
for cur <= lst {
3
    if nums[lst] == val { lst-- }
4
    else if nums[cur] == val { nums[cur] = nums[lst]; lst-- }
5
    else { cur++ }
6
}
7
return lst + 1

1
l, r := 0, len(height)-1
2
maxLeft, maxRight := 0, 0
3
for l < r {
4
    maxLeft = max(maxLeft, height[l])   // 先更新当前位置左侧最大值
5
    maxRight = max(maxRight, height[r]) // 先更新当前位置右侧最大值
6
    if height[l] < height[r] {
7
        res += maxLeft - height[l]; l++   // 左侧矮 → 水位由 maxLeft 决定
8
    } else {
9
        res += maxRight - height[r]; r--  // 右侧矮/相等 → 水位由 maxRight 决定
10
    }
11
}

1
// p1 指向 nums1 有效元素末尾，p2 指向 nums2 末尾，tail 指向合并后写入位置
2
for p1, p2, tail := m-1, n-1, m+n-1; p1 >= 0 || p2 >= 0; tail-- {
3
    if p1 == -1 {                       // nums1 已用完，只能填 nums2
4
        nums1[tail] = nums2[p2]; p2--
5
    } else if p2 == -1 {                // nums2 已用完，只能填 nums1
6
        nums1[tail] = nums1[p1]; p1--
7
    } else if nums1[p1] > nums2[p2] {   // 两数组都还有，谁大填谁（从后往前保证有序）
8
        nums1[tail] = nums1[p1]; p1--
9
    } else {
10
        nums1[tail] = nums2[p2]; p2--
11
    }
12
}

1
k %= len(nums)      // 防止 k > n，轮转 k 等价于轮转 k%n
2
reverse(nums)       // ① 整体反转：末尾 k 个被翻到最前（顺序反了）
3
reverse(nums[:k])   // ② 前 k 个再反转回正序
4
reverse(nums[k:])   // ③ 后 n-k 个再反转回正序

1
l, r := 0, len(s)-1
2
b := []byte(s)
3
for l < r {
4
    for l < r && !vowels[b[l]] { l++ }
5
    for l < r && !vowels[b[r]] { r-- }
6
    b[l], b[r] = b[r], b[l]; l++; r--
7
}

1
i, j := 0, 0
2
for j < len(t) {
3
    if i < len(s) && s[i] == t[j] { i++ }
4
    j++
5
    if i == len(s) { return true }
6
}

1
mp := map[rune]int{}
2
for idx, ch := range s { mp[ch] = idx }  // ① 记录每个字母最后出现的下标
3
start, end := 0, 0
4
for idx, ch := range s {
5
    if mp[ch] > end { end = mp[ch] }      // ② 扩展右边界：当前字母还会更靠后，片段必须延伸到那
6
    if idx == end {                        // ③ 到边界了：片段内字母都不会再出现，可以切分
7
        ans = append(ans, idx+1-start)    //    长度 = 右边界 - 左边界 + 1
8
        start = idx + 1                    //    下一个片段从左边界+1 开始
9
    }
10
}

1
i, j := 0, 0
2
for i < m && j < n { sb.WriteByte(word1[i]); sb.WriteByte(word2[j]); i++; j++ }
3
if m > n { sb.WriteString(word1[i:]) } else if n > m { sb.WriteString(word2[j:]) }

1
mp := map[byte]int{}; l, res := 0, 0
2
for r := 0; r < len(s); r++ {
3
    if idx, exists := mp[s[r]]; exists && idx >= l {
4
        l = idx + 1  // 左指针跳到重复字符之后
5
    }
6
    mp[s[r]] = r
7
    res = max(res, r-l+1)
8
}

1
tmap := map[byte]int{}            // t 中各字符需要的数量
2
for _, ch := range t { tmap[ch]++ }
3
count := len(tmap)               // 还需要满足的字符种类数
4
smap := map[byte]int{}
5
l, ansL, ansR := 0, 0, len(s)
6
for r := 0; r < len(s); r++ {
7
    smap[s[r]]++
8
    if smap[s[r]] == tmap[s[r]] { count-- }   // 这种字符刚凑够 → 少一种待满足
9
    for count == 0 {                          // 窗口合法，尽量往里收缩
10
        if r-l < ansR-ansL { ansL, ansL = l, r } // 更新最短
11
        smap[s[l]]--
12
        if smap[s[l]] < tmap[s[l]] { count++ }  // 收缩后这种字符不够了 → 待满足+1
13
        l++
14
    }
15
}

1
q := []int{} // 存下标（不是存值！方便判断过期）
2
for i, val := range nums {
3
    // ① 弹出队尾所有 ≤ 当前值的旧下标：它们以后都不可能当最大值
4
    for len(q) > 0 && nums[q[len(q)-1]] <= val { q = q[:len(q)-1] }
5
    q = append(q, i)                 // ② 当前下标入队尾
6
    if q[0] < i-k+1 { q = q[1:] }    // ③ 队首下标已滑出窗口，弹出
7
    if i >= k-1 { ans = append(ans, nums[q[0]]) } // ④ 窗口满，队首即最大值
8
}

1
cnt := [26]int{}; diff := 0
2
// ① 初始化：先把 s 前 len(p) 个字符的窗口与 p 比较
3
for i := 0; i < len(p); i++ {
4
    cnt[s[i]-'a']++   // 窗口多一个
5
    cnt[p[i]-'a']--   // p 多一个（相减得到差值）
6
}
7
for i := 0; i < 26; i++ { if cnt[i] != 0 { diff++ } }
8
if diff == 0 { res = append(res, 0) }
9
// ② 窗口右滑：左出右进，增量更新 cnt 和 diff
10
for i := len(p); i < len(s); i++ {
11
    out := s[i-len(p)] - 'a' // 滑出的字符
12
    cnt[out]--
13
    if cnt[out] == 0 { diff-- } else if cnt[out] == -1 { diff++ } // 由不平衡→平衡 / 由平衡→更缺
14
    in := s[i] - 'a'          // 滑入的字符
15
    cnt[in]++
16
    if cnt[in] == 0 { diff-- } else if cnt[in] == 1 { diff++ }    // 由多→平衡 / 由平衡→更多
17
    if diff == 0 { res = append(res, i-len(p)+1) }               // 平衡即异位词
18
}

1
for i := 0; i < k; i++ { sum += nums[i] }
2
ans := float64(sum) / float64(k)
3
for i := k; i < len(nums); i++ { sum += nums[i] - nums[i-k]; ans = max(ans, float64(sum)/float64(k)) }

1
for right := 0; right < n; right++ {
2
    if nums[right] == 0 { zeroCnt++ }
3
    for zeroCnt > k { if nums[left] == 0 { zeroCnt-- }; left++ }
4
    maxLen = max(maxLen, right-left+1)
5
}

1
for i := 0; i < k; i++ { if vowels[s[i]] { count++ } }
2
ans := count
3
for i := k; i < len(s); i++ {
4
    if vowels[s[i-k]] { count-- }
5
    if vowels[s[i]] { count++ }
6
    ans = max(ans, count)
7
}

1
for right := 0; right < n; right++ {
2
    if nums[right] == 0 { zeroCnt++ }
3
    for zeroCnt > 1 { if nums[left] == 0 { zeroCnt-- }; left++ }
4
    maxLen = max(maxLen, right-left)  // 注意是 right-left 不是 +1
5
}

1
left, right := 0, n-1
2
for left <= right {
3
    mid := left + (right-left)/2
4
    if nums[mid] == target { return mid }
5
    if nums[mid] >= nums[left] {              // 左半有序
6
        if target >= nums[left] && target < nums[mid] { right = mid - 1 }
7
        else { left = mid + 1 }
8
    } else {                                   // 右半有序
9
        if target > nums[mid] && target <= nums[right] { left = mid + 1 }
10
        else { right = mid - 1 }
11
    }
12
}

1
// 左边界 = 第一个 >= target 的位置
2
leftBound := func() int {
3
    l, r := 0, len(nums)-1
4
    for l <= r {
5
        mid := l + (r-l)/2
6
        if nums[mid] < target { l = mid+1 } else { r = mid-1 }
7
    }
8
    return l   // 第一个 >= target
9
}
10
// 右边界 = 第一个 > target 的位置 - 1 = 第一个 >= target+1 的位置 - 1
11
rightBound := func() int {
12
    l, r := 0, len(nums)-1
13
    for l <= r {
14
        mid := l + (r-l)/2
15
        if nums[mid] <= target { l = mid+1 } else { r = mid-1 } // 注意是 <=
16
    }
17
    return l - 1
18
}

1
for left <= right {
2
    mid := left + (right-left)/2
3
    if nums[mid] == target { return mid }
4
    else if nums[mid] > target { right = mid - 1 }
5
    else { left = mid + 1 }
6
}
7
return left // left 就是插入位置

1
// 把 (r,c) 映射到一维下标 idx = r*cols + c，整体二分
2
m, n := len(matrix), len(matrix[0])
3
l, r := 0, m*n-1
4
for l <= r {
5
    mid := l + (r-l)/2
6
    val := matrix[mid/n][mid%n]   // 一维下标还原成二维坐标
7
    if val == target { return true }
8
    else if val < target { l = mid+1 } else { r = mid-1 }
9
}
10
return false

1
if nums[mid] >= nums[left] { left = mid + 1; ans = min(ans, nums[left]) }
2
else { right = mid - 1; ans = nums[mid] }

1
r, c := 0, len(matrix[0])-1
2
for r < len(matrix) && c >= 0 {
3
    if matrix[r][c] == target { return true }
4
    if matrix[r][c] > target { c-- } else { r++ }
5
}

1
slow, fast := 0, 0
2
for { slow = nums[slow]; fast = nums[nums[fast]]; if slow == fast { break } }
3
head := 0
4
for slow != head { slow = nums[slow]; head = nums[head] }
5
return slow

1
for {
2
    mid := left + (right-left)/2
3
    res := guess(mid)
4
    if res == 0 { return mid }
5
    else if res == 1 { left = mid + 1 } else { right = mid - 1 }
6
}

1
left, right := 1, maxPile // 速度范围 [1, 最大堆]
2
for left <= right {
3
    mid := left + (right-left)/2
4
    total := 0
5
    for _, p := range piles { total += (p + mid - 1) / mid } // 向上取整
6
    if total <= h { ans = mid; right = mid - 1 } else { left = mid + 1 }
7
}

1
func getKth(a, b []int, k int) int {
2
    if len(a) == 0 { return b[k-1] }  // a 耗尽
3
    if len(b) == 0 { return a[k-1] }  // b 耗尽
4
    if k == 1 { return min(a[0], b[0]) }  // 只剩1个
5
    midA := min(k/2-1, len(a)-1)  // 防越界
6
    midB := min(k/2-1, len(b)-1)
7
    if a[midA] < b[midB] {
8
        return getKth(a[midA+1:], b, k-(midA+1))  // a 前半段跳过
9
    } else {
10
        return getKth(a, b[midB+1:], k-(midB+1))  // b 前半段跳过
11
    }
12
}
13

14
func findMedianSortedArrays(a, b []int) float64 {
15
    total := len(a) + len(b)
16
    if total%2 == 1 {
17
        return float64(getKth(a, b, (total+1)/2))  // 奇数取中间
18
    }
19
    return float64(getKth(a,b,total/2)+getKth(a,b,total/2+1)) / 2.0  // 偶数取平均
20
}