459.重复的子字符串

力扣链接： https://leetcode.cn/problems/repeated-substring-pattern/

题目：给你一个字符串 s，判断它是否能由某个子串重复多次（至少两次）构成。例如 abab 是 ab 重复两次，aba 则不行。

思路

核心结论：

s 是重复子串构成 ⟺ s 会出现在 (s+s) 去掉首尾各一个字符后的串里

为什么要掐头去尾：s+s 里一定能在「中间拼缝」找到整段 s（第二个 s 的开头），这不能说明有重复模式。去掉首尾后，合法起点只剩 1 .. n-1，这时还能找到完整的 s，才说明存在周期。

等价写法：

ss := s[1:] + s[:len(s)-1]   // 就是 (s+s)[1 : 2n-1]
strings.Contains(ss, s)

小例子

s = "abab"，n = 4

• s[1:] → "bab"
• s[:3] → "aba"
• ss = "bababa"，包含 "abab" → true

s = "aba"，n = 3

• ss = "ba" + "ab" = "baab"，不包含 "aba" → false

问题：切片为什么是 len(str)-1

一开始会想：是不是因为「左开右闭」才写成 len(str)-1？

其实 Go / 多数语言切片是 左闭右开：

s[a:b]  ⟺  a ≤ i < b

所以：

end 写成 n-1，正是因为右端点不包含；想排除下标 n-1，就要把开区间右端停在 n-1

Code

少一次 []byte 来回转换，直接切片即可：

func repeatedSubstringPattern(s string) bool {
	n := len(s)
	if n == 0 {
		return false
	}
	return strings.Contains((s + s)[1:2*n-1], s)
}

也可以写成掐头去尾再拼：

func repeatedSubstringPattern(s string) bool {
	str := []byte(s)
	ss := string(str[1:]) + string(str[:len(str)-1])
	return strings.Contains(ss, s)
}

第二种多了 []byte / string(...) 分配，逻辑一样，常数更差一点。

问题：Contains 和手写暴力性能为什么不一样

搜索范围其实一样。手写版等价于在 dummy = s+s 上从 i = 1 扫到 i < n：

func repeatedSubstringPattern(s string) bool {
	dummy := s + s

	for i := 1; i < len(dummy)-len(s); i++ {
		isEqual := true
		for j := 0; j < len(s); j++ {
			if dummy[i+j] != s[j] {
				isEqual = false
				break
			}
		}
		if isEqual {
			return true
		}
	}
	return false
}

时间复杂度怎么记

容易踩的坑：

1. 觉得暴力「应该是 2n」——那是 早退时的实际比较次数，不是最坏复杂度。
2. dummy 长度是 2n，只说明串长，不等于比较次数是 2n。
3. benchmark 里两者有时都像线性，差在常数；难匹配输入上暴力才可能突然变慢。

一句话收束

• 判定：(s+s) 掐头去尾后是否 Contains(s)
• 切片：左闭右开，所以去尾写 [:n-1]
• 复杂度：Contains 按 O(n) 记；暴力最坏 O(n²)，常见因早退接近 O(n)

写在前面

做题的时候, 使用 For 写出了一个很诡异的代码

问题总结

For 第一层声明

对于声明区间 只能选择声明一次 。

对于

for j := i ,cursor := 1 ; j < n - i ; j ++ , cusror ++ {

这种写法应该优化成

for j, cursor := i, 1 ; j < i + k; j ++ , cursor ++ 

For 第三层自增

对于这种写法， Cursor处会报错 是因为 Golang 中 没有逗号运算符

如果想要处理的话 同样需要改成 j, cursor = j+1, cursor+1

for j, cursor := i, 1 ; j < i + k; j ++ , cursor ++ 

String 不可改

对于 String 类型，默认是只读的 并不可以更改， 要将字符串变成 []byte 之后才可以进行读写操作

344.反转字符串

力扣链接：https://leetcode.cn/problems/reverse-string/

题目：给你一个字符串，字符串存在数组里面，翻转字符串，不能用额外空间

思路

题目要求很简单

1. 不能使用额外空间
2. 反转字符串

因此我们直接进行首尾交换即可

Code

func reverseString(s []byte)  {
    for i :=0 ; i < len(s) / 2 ; i ++ {
        s[i] , s[len(s) - i - 1] = s[len(s) - i - 1] , s[i]
    }
}

541. 反转字符串II

力扣链接：https://leetcode.cn/problems/reverse-string-ii/

题目：给你一个字符串和k，每到2k个字符，就翻转前k个字符。如果剩余字符少于k个则全部翻转，如果小于2k但大于等于k，则翻转前k个

思路

根据题意进行模拟即可

1. 每次走 2*k 个步长

2. 使用 l,r 进行区间交换 。 如果当前区间的 右区间 > n 那么缩小区间到可交换的地方即可

func reverseStr(s string, k int) string {
	b := []byte(s)
	n := len(b)
	for i := 0; i < n; i += 2 * k {
		l, r := i, i+k-1
		if r >= n {
			r = n - 1
		}
		for l < r {
			b[l], b[r] = b[r], b[l]
			l++
			r--
		}
	}
	return string(b)
}

2. 541. 反转字符串II

力扣链接：https://leetcode.cn/problems/reverse-string-ii/

题目：给你一个字符串和k，每到2k个字符，就翻转前k个字符。如果剩余字符少于k个则全部翻转，如果小于2k但大于等于k，则翻转前k个

思路

很无聊的一个题，使用 strings.ReplaceAll 即可

Code

func pathEncryption(path string) string {
    return strings.ReplaceAll(path, ".", " ")
}

剑指Offer58-II.左旋转字符串

力扣链接： https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/

题目：给你一个字符串和一个k，把字符串前k个字符截取放到字符串末尾。abcd 2.-----cdab

思路

1. 我这里引用了 额外的空间 来进行解决

2. 另外一种思路 是直接进行切片操作

Code

func dynamicPassword(password string, target int) string {
    dummy := make([]byte, 0 , len(password))
    for i := target ; i < len(password) ; i ++  {
        dummy = append(dummy, password[i])
    }

    for i := 0 ; i < target ; i ++ {
        dummy = append(dummy, password[i])
    }
    return string(dummy)
}

func reverseLeftWords(s string, n int) string {
    return s[n:]+s[:n]
}

两数之和

力扣链接 : https://leetcode.cn/problems/two-sum/description/

题目 : 给定一个数组 和 Target, 询问数组里面哪两个元素之和等于 target, 如果等于则返回下标

思路

顺序遍历数组, 把元素存入到 Map 中 。每次访问的时候 判断 Map 中是否存在对应的 Target - cur 的 Key

如果存在则说明出现过

Code

func twoSum(nums []int, target int) []int {
    mp := make(map[int]int)
    res := make([]int, 0, len(nums))

    for i , v := range nums {
        if mp[target - v] != 0 {
            res = append(res, mp[target - v] - 1, i)
        }
        mp[v] = i + 1
    }
    return res 
}

454 四数相加

力扣链接 : https://leetcode.cn/problems/4sum-ii/description/

题目 : 给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

思路

1. 一开始没什么思路， 直接暴力的做法 是 200^4 = 1e8 的 肯定会超时

2. 考虑使用两数之和的思路来优化， 前两个数组相加 和 后两个数组相加 然后跑一边两数之和

   • 这里会遇到 多计算 多情况, 因为最后我们跑循环的时候，会额外计算一部分 一半数组的情况

3. 因此考虑优化，我们维护两个 Map, 在处理计算的时候 我们就统计对应的 和数量

4. 最后在 Match 的时候就是一个 乘法交换 的过程

历程

func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {

    m1 := make([]int, 0, len(nums1) * len(nums2) + len(nums3) * len(nums4))
    for _ ,v1 := range nums1 {
        for _, v2 := range nums2 {
            m1 = append(m1, v1 + v2)
        } 
    }
    
    for _ ,v1 := range nums3 {
        for _, v2 := range nums4 {
            m1 = append(m1, v1 + v2)
        } 
    }
    

    mp := make(map[int]int)
    cnt := 0 
    for _ ,v := range m1 {
        if v, ok := mp[-v] ; ok {
            cnt += v
        }
        mp[v] ++
    }
    return cnt 
}

Code

func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {

    m1 := make(map[int]int)
    m2 := make(map[int]int)
    for _ ,v1 := range nums1 {
        for _, v2 := range nums2 {
            m1[v1 + v2] ++ 
        } 
    }
    
    for _ ,v1 := range nums3 {
        for _, v2 := range nums4 {
            m2[v1 + v2] ++ 
        } 
    }
    
    cnt := 0 

    for k, v := range m1 {
        if _ , ok := m2[-k] ; ok {
            cnt += v * m2[-k]
        }
    }
    return cnt 
}

383.赎金信

力扣链接 : https://leetcode.cn/problems/ransom-note/description/

题目 : 给你两个字符串 ransomNote 和 magazine ，如果 ransomNote 能由 magazine 里面的字符构成，则返回 true ；否则返回 false 。

思路

这个和之前做过的的 字符串匹配 不是很像 。 因为这个允许 不规则数量匹配

无非是代码上需要额外处理一下

Code

func canConstruct(ransomNote string, magazine string) bool {
    st := make(map[rune]int)
    for _ ,  v := range magazine {
        st[v - 'a'] ++ 
    }

    for _, v := range ransomNote {
        if _ , ok := st[v - 'a'] ; ok {
            st[v - 'a']  -- 
        }
    }

    for _, v := range ransomNote {
        if _, ok := st[v - 'a'] ; !ok {
            return false 
        }
        if st[v - 'a'] < 0 {
            return false 
        }
    }
    return true 
}

15.三数之和

题目链接 : https://leetcode.cn/problems/3sum/description/

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

思路

1. 考虑枚举 i , 那么题目就变成了 nums[j] + nums[k] = nums[i] , 即两数之和的版本

2. 因为我们题目给出的数组是无序的，所以我们可以考虑排序优化一下，这样子对于

   • nums[i] + nums[k1] + nums[k2] > 0 或者 nums[i] + nums[k1] + nums[k2] < 0 的时候可以更好的进行移动

Code

func threeSum(nums []int) [][]int {
    slices.Sort(nums)
    n := len(nums)
    ans := make([][]int,0)
    for i := 0 ; i <  len(nums) - 2 ; i ++ {
        x := nums[i]
        if i > 0 && x == nums[i-1] {
            continue 
        }
        if x + nums[i + 1] + nums[i+2] > 0 {
            break 
        }
        if x + nums[n - 2] + nums[n - 1] < 0 {
            continue 
        }

        l , r := i + 1, n - 1
        for l < r {
            s := x + nums[l] + nums[r]
            if s > 0 {
                r -- 
            }else if s < 0 {
                l ++ 
            }else {
                ans = append(ans, []int{x,nums[l],nums[r]})
                for l ++ ; l < r && nums[l] == nums[l-1] ; l ++ {} 
                for r -- ; l < r && nums[r] == nums[r+1] ; r -- {}
            }
        }
    }
    return ans 
}

18. 四数之和

题目链接 : https://leetcode.cn/problems/4sum/description/

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n a、b、c 和 d 互不相同 nums[a] + nums[b] + nums[c] + nums[d] == target 你可以按 任意顺序 返回答案 。

思路

1. 根据三数之和的步骤， 我们可以尝试固定 a,b 那么就变成了 c + d = target - a - b 即是我们的两数之和模板
2. 那么就是去重的问题，无非就是 Continue 一下相等的数据

Code

func fourSum(nums []int, target int) [][]int {
    res := make([][]int, 0)
    n := len(nums)
    if n < 4 {
        return res
    }

    slices.Sort(nums)

    for i := 0; i < n-3; i++ {
        if i > 0 && nums[i] == nums[i-1] {
            continue
        }

        for j := i + 1; j < n-2; j++ {
            if j > i+1 && nums[j] == nums[j-1] {
                continue
            }

            l, r := j+1, n-1
            for l < r {
                sum := nums[i] + nums[j] + nums[l] + nums[r]
                if sum < target {
                    l++
                } else if sum > target {
                    r--
                } else {
                    res = append(res, []int{nums[i], nums[j], nums[l], nums[r]})
                    l++
                    r--

                    for l < r && nums[l] == nums[l-1] {
                        l++
                    }
                    for l < r && nums[r] == nums[r+1] {
                        r--
                    }
                }
            }
        }
    }

    return res
}

02.07 链表相交

力扣链接: https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/

题目: 给你两个链表，让你返回两个链表的交点，如果相交则输出，否则返回 Nil

过程

一开始以为是个暴力的做法

我们遍历链表 A，对于每个节点都额外走一遍链表 B. 当我们 Value 相等的时候 我们额外判断一下 两个节点的 Next 是否相等

如果相等则说明相交

这个思路有很大的问题

1. 整个时间复杂度过高
2. 代码很复杂 ，这个 dummy 我还是根据习惯写出来的

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    
    dummyA := &ListNode{Next: headA}
    dummyB := &ListNode{Next: headB}

    prevA := dummyA 
    for prevA != nil {
        if prevA.Next == nil {
            break 
        }
        prevB := dummyB
        for prevB != nil {
            if prevA.Next != prevB.Next{  // 当前节点相等
                prevB = prevB.Next
                continue 
            }
            if prevA.Next.Next == prevB.Next.Next {
                return prevA.Next.Next
            }
            prevB = prevB.Next
        }
    
        prevA = prevA.Next 
    }
    return nil 
}

正确思路

我们考虑 PA 和 PB 两个指针， 当我们 PA 遍历完成之后尝试 从 headB 进行遍历

保证两个指针都走 M+N 个步长, 那么如果他们相交的话，就一定会存在相等的情况

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    if headA == nil || headB == nil {
        return nil
    }

    pA, pB := headA, headB
    for pA != pB {
        if pA == nil {
            pA = headB
        } else {
            pA = pA.Next
        }

        if pB == nil {
            pB = headA
        } else {
            pB = pB.Next
        }
    }
    return pA
}

142.环形链表II

见 环形链表专题

242.有效的字母异位词

力扣链接：https://leetcode.cn/problems/valid-anagram/

题目：给你两个字符串，如果这两个字符串的每个字符出现的次数都一样，返回true

思路

因为只有 26个字母 使用标记数组进行统计，然后在进行删除

func isAnagram(s string, t string) bool {
    st := make([]int,27)
    for _ , v := range s {
        st[v - 'a'] ++ 
    }        

    for _, v := range t {
        st[v - 'a'] -- 
    }
    for i := 0 ; i <= 26; i ++ {
        if st[i] != 0 {
            return false 
        }
    }
    return true 
}

349. 两个数组的交集

力扣链接：https://leetcode.cn/problems/intersection-of-two-arrays/

题目：求两个数组的交集

思路

1. 同样使用 一个 Map 进行统计
2. 不过需要注意的是，对于第一个数组需要判断是否为0 防止重复计算，对于第二个数组需要判断不等于0 防止重复计算

Code

func intersection(nums1 []int, nums2 []int) []int {
    mp := make(map[int]int)
    for _ ,v := range nums1 {
        if mp[v] == 0 {
            mp[v] ++ 
        }
    }
    for _, v := range nums2 {
        if mp[v] != 0 {
            mp[v] -- 
        }
    }

    res := make([]int,0,len(nums1))
    for k ,v := range mp {
        if v != 1 {
            res = append(res, k)
        }
    }
    return res 
}

第202题. 快乐数

力扣链接： https://leetcode.cn/problems/happy-number/

题目： 重复计算：数字各个位 的 平方 的 和 ，直到和为1，则返回true，如果不可能为1，返回false

思路

模拟即可

code

func isHappy(n int) bool {
    mp := make(map[int]bool)
    for  {
       res :=  calc(n)
       if res == 1 {
            return true 
       }else if mp[res] == true {
            return false 
       }
       mp[res] =true 
       n = res 
    }
    return false 
}

func calc(n int) int {
    res := 0 
    for n != 0  {
        wv := n % 10
        res += wv * wv 
        n /= 10 
    }
    return res 
}

// 111 , 3 , 9 
// 222 , 12 , 5, 25

142.环形链表II

力扣链接： https://leetcode.cn/problems/linked-list-cycle-ii/

题目： 给你一个链表，其尾部可能成环，让你返回入环的第一个节点 .

思路

题目要求 :

1. 判断是否有环

2. 判断环的入口

判断是否有环

1. 使用快慢指针，快指针比慢指针多走一步 。 如果有环的话 ，那么这多走的 1 步 会在多次重复的时候相遇

判断环的入口

head ----a----> 入口 E ----b----> 相遇点 M ----c----> 入口 E
                 └──────── 环长 C = b + c ────────┘

• $a$：头到环入口的距离
• $b$：入口沿环走到相遇点
• $c$：相遇点再走回入口
• $C = b + c$：环长

推导步骤

1. 快慢指针相遇
   慢每次走 1，快每次走 2。相遇时：

   • 慢走过：$a + b$
   • 快走过：$a + b + mC$（多绕了 $m$ 整圈，$m \ge 1$）
     注意：$mC = m(b+c)$，多走的是整圈，不是只多走 $c$。

2. 用「快 = 2 × 慢」列方程

（因为 $C - b = c$，所以 $mC - b = (m-1)C + c$）

3. 同余含义
   $a = (m-1)C + c$ 就是 $a \equiv c \pmod{C}$：
   $a$ 和 $c$ 相差整数个环长。
   在环上走时，走 $a$ 步 和 走 $c$ 步 终点相同（多走的整圈等于原地转圈）。

4. 找入口的做法
   相遇后：

   • 一个指针放回 head
   • 另一个留在相遇点 $M$
   • 两个都每次走 1 步

   从头走 $a$ 步 → 到入口。
   从 $M$ 走 $a$ 步 = 走 $c + (m-1)C$ 步 → 先空转 $(m-1)$ 圈，再走 $c$ → 也到入口。

   再次相遇的点就是环入口。

小例子

1 → 2 → 3 → 4
         ↑   ↓
         6 ← 5

入口是 3，环长 $C=4$。若在 5 相遇：$a=2,\ b=2,\ c=2$。
检查：$a+b=4=1\cdot C$，且 $a=c=2$。
从头：1→2→3；从 5：5→6→3。两步后都到入口。

Code

func detectCycle(head *ListNode) *ListNode {
    slow,fast := head,head 
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
        if slow == fast {
            for head != slow {
                head = head.Next
                slow = slow.Next
            }
            return slow 
        }
    }
    return nil 
}

日程规划

10-2日 : 出发, 预计晚上 20.45 到

10-3日 : 完整的一天

10-4日 : 完整的一天

10-5日 : 完整的一天

10-6日 : 准备返程 抢票中

一些日期的规划

10-3日

去步步高吃个饭, 然后去几多全买点零食 用于在酒店摆烂

1. 买点蛋糕
2. 麻辣
3. 锅巴
4. 干果什么的

10-4 | 10-5 日

暂时没有想法, 可以考虑在酒店学习 然后晚上跑步

10-5日晚上 预计去河边散散步

10-6 日

准备返程

去满意饭店或者是哪个饭店再吃一顿 然后走人

想做的事

1. 去一次 KTV . 这次就是真唱歌了

2. 做爱

   i. 持久性 和 勃起兴药物尝试

   ii. 更多动作的尝试

3. 河边散步（晚上）

4. 吃一顿好吃的 (煲)

5. 一起去拔罐

先说结论

很多人第一次看到下面这段 Go 代码，都会以为输出应该是 100：

package main

import "fmt"

type Node struct {
	Val int
}

func changePointer(n *Node) {
	n = &Node{Val: 100}
}

func main() {
	x := Node{Val: 1}
	changePointer(&x)
	fmt.Println(x.Val) // 1
}

实际输出却是 1。

这不是 Go 的指针“失效”了，也不是编译器做了什么特殊优化。真正的原因只有一句话：

Go 的函数参数永远是值传递，指针也只是“一个值”。

这里最容易产生认知误差的地方在于：

1. 我们确实传入了指针
2. 但传入的是“地址值的一份拷贝”
3. 你在函数里改的是这份拷贝，不是外面的变量本身

第一层理解：你改的是谁

先不要急着想“指针不是能改外部对象吗”，先把这行代码看清楚：

func changePointer(n *Node) {
	n = &Node{Val: 100}
}

这里的 n = ... 改的不是 *n，而是 n 这个局部变量。

也就是说：

• n.Val = 100 是“顺着指针去改它指向的内容”
• n = &Node{Val: 100} 是“让局部指针变量重新指向别的对象”

这两个动作看起来都和指针有关，但影响范围完全不同。

上图里发生的事情可以概括成：

1. main 里有一个变量 x
2. &x 产生一个地址值
3. 调用 changePointer(&x) 时，Go 把这个地址值复制给形参 n
4. 函数内部把 n 指向了新对象
5. 外面的 x 从头到尾都没变

所以最终输出还是 1。

第二层理解：Go 里“传指针”不等于“引用传递”

很多人之所以会在这里绕住，是因为脑子里默认有这样一个联想：

传入指针 = 可以改外面的东西

这句话只说对了一半。

更准确地说应该是：

传入指针后，你可以通过这份指针副本，修改它当前指向的那块内存。

但是你不能仅靠修改这份“副本指针变量”，去修改外面的指针变量本身。

看两个对照例子就清楚了。

例子一：修改指针指向的内容

package main

import "fmt"

type Node struct {
	Val int
}

func changeValue(n *Node) {
	n.Val = 100
}

func main() {
	x := Node{Val: 1}
	changeValue(&x)
	fmt.Println(x.Val) // 100
}

这里输出 100，因为：

• n 和 &x 虽然不是同一个变量
• 但它们一开始保存的是同一个地址
• n.Val = 100 改的是那块地址上的内容
• 所以外面的 x 会一起变化

例子二：修改局部指针变量自己的指向

package main

import "fmt"

type Node struct {
	Val int
}

func changePointer(n *Node) {
	n = &Node{Val: 100}
}

func main() {
	x := Node{Val: 1}
	changePointer(&x)
	fmt.Println(x.Val) // 1
}

这里输出 1，因为 n = ... 只是把 n 这份地址副本改掉了，外面的 x 仍然是原来的对象。

第三层理解：如果真想改“外面的指针本身”，要传二级指针

如果你的目标不是“改对象内容”，而是“让外面的指针改为指向新对象”，那就不能只传 *Node，而要传 **Node。

package main

import "fmt"

type Node struct {
	Val int
}

func replacePointer(n **Node) {
	*n = &Node{Val: 100}
}

func main() {
	x := &Node{Val: 1}
	replacePointer(&x)
	fmt.Println(x.Val) // 100
}

为什么这里就能改掉？

因为这次你拿到的不是“Node 的指针”，而是“外部指针变量 x 的地址”。

所以：

• n 指向的是外部变量 x
• *n = ... 等价于“给外部的 x 重新赋值”
• 这时外面的指针本身就真的被改掉了

这个例子也说明了一个很重要的区分：

• n = ... 改的是局部变量
• *n = ... 改的是外部变量

第四层理解：为什么你会觉得 C++ 里能改

这个误区很常见，因为 C++ 里确实有一种写法会让外部指针发生变化，但那通常不是“普通指针传参”，而是“指针的引用”。

先看 C++ 里和 Go 当前行为等价的写法：

struct Node {
    int val;
};

void changePointer(Node* n) {
    n = new Node{100};
}

这段 C++ 和 Go 一样，外面也不会变。

因为本质上还是：

• 把一个地址值复制给形参 n
• 然后在函数内部修改 n 这份副本

真正能改外部指针的是这种写法：

struct Node {
    int val;
};

void changePointer(Node*& n) {
    n = new Node{100};
}

这里的 Node*& 是“指针的引用”，它更接近 Go 里的 **Node 效果。

所以如果你记忆里“我在 C++ 这么写能改掉”，大概率你当时写的是：

• 引用 T&
• 或者指针引用 T*&
• 或者二级指针 T**

而不是单纯的“指针按值传递”。

一张表记住这件事

如果只记一句话，可以记这个：

Go 永远是值传递。传指针，只是把“地址值”复制了一份。

最容易写错的三组实验

下面这三组代码建议你自己跑一遍，认知会非常稳定。

实验一：修改字段

package main

import "fmt"

type Node struct {
	Val int
}

func f(n *Node) {
	n.Val = 200
}

func main() {
	x := Node{Val: 1}
	f(&x)
	fmt.Println(x.Val) // 200
}

这里你改的是“地址里的内容”。

实验二：重新绑定局部指针

package main

import "fmt"

type Node struct {
	Val int
}

func f(n *Node) {
	n = &Node{Val: 200}
}

func main() {
	x := Node{Val: 1}
	f(&x)
	fmt.Println(x.Val) // 1
}

这里你改的是局部变量 n 的指向。

实验三：传二级指针

package main

import "fmt"

type Node struct {
	Val int
}

func f(n **Node) {
	*n = &Node{Val: 200}
}

func main() {
	x := &Node{Val: 1}
	f(&x)
	fmt.Println(x.Val) // 200
}

这里你拿到了外部指针变量的地址，因此能把外部指针重新绑定到新对象。

实战里怎么判断该用哪一种

如果你在业务代码里遇到类似场景，可以按目的来选：

只想改对象内容

用 *T 就够了。

func fillUser(u *User) {
	u.Name = "Alice"
	u.Age = 18
}

这类写法最常见，也最符合直觉。

想在函数里“创建对象并回填出去”

可以考虑返回值，通常比 **T 更自然：

func newNode() *Node {
	return &Node{Val: 100}
}

大多数情况下，Go 更鼓励这种写法，而不是到处传二级指针。

必须修改外部指针本身

这时再考虑 **T：

func reset(n **Node) {
	*n = nil
}

但要注意，**T 会显著增加阅读成本，除非这个语义非常明确，否则优先考虑返回值。

最后，把认知纠正成一句完整的话

错误直觉通常是：

我传的是指针，所以函数里改了它，外面一定会变。

更准确的理解应该是：

Go 中参数总是值传递。即使传入的是指针，也只是把地址值复制给形参。
通过这个地址可以修改它指向的内容，但不能仅靠修改形参本身，去改变外部变量。

当你把“指针”和“引用传递”这两个概念拆开后，这类问题基本就不会再绕住了。

如果以后再遇到类似代码，先问自己两个问题：

1. 我现在改的是 n，还是 *n？
2. 我想改的是对象内容，还是外面的指针变量本身？

这两个问题一旦分清，答案通常就直接出来了。

小谈

今天是入职的 第二周，第一天。 可以认为 我在这家公司待了 4 天了, 今天中午吃饭的时候遇到了之前一起入职的一个大哥 @李鸣波

简单交流了一下，他是做 数据开发 的

1. 问我当初说要走为什么没走
2. 当初一起入职的一个 13年 工作经验的老哥已经走了
3. 沟通加班情况
4. 沟通 Leader 散养情况

反问 :

1. 你为什么不走呢

问我当初说要走为什么没走

我一开始没有给出很好的回答，但是刚刚睡午觉的时候 脑子里面还在想，或许我可以给出几个回答

房租问题

1. 我的房租是 押一付三的 , 并且北京房租昂贵，而且还被收了一笔 暖气费 和 中介费 ， 导致我一次性付了 1w3 多 。

当然我这个也并不是没有办法, 解决办法如下 :

1. 房屋转租出去
2. 但是我付的 1000 块钱 暖气费 和 1200 块钱中介费 以及我来北京大概花了 1000 块钱的交通费 还有买了一些物品的无非 也可以预估在 1000
3. 总共估计 4000 块钱 ！ 另外还有一个问题就是 我要回哪里，应该去哪里。回去又要一笔费用 又要花 1000 块钱

损失成本貌似太高了 。 但是一直有一句话是这么说的 沉默成本不参与重大决策, 不过看样子 我并不是很好的一个践行者

何去何从问题

我这次社招 可以说并没有找到 一份好工作。 或者说 我没有找到其他工作， 可能是因为市场原因 也可能 是因为我 个人原因

因此我只能被动的选择来到北京， 如果我立马跑路就会有新的问题

1. 我该去哪里 ？ 我家里农村的，只能回大山里去，我女朋友还在考研 我不能打扰他

2. 我该怎么办 ？

   i. 继续面试 ？ 可是我岗位都投的差不多了，面试也没多少啦

   ii. 如果没有找到工作怎么办？

懒惰！

1. 首先我的Leader是散养我们外包人员的，而且一开始也没安排什么开发任务。 虽然电脑不能摸鱼，但是也很轻松，这倒是我想歇息一下
2. 另外我组的其他同事并没有出现加班的情况，所以我感觉很安逸

当初一起入职的一个 13年 工作经验的老哥已经走了

这个老哥 周二入职的，周五就跑了 。 说是他本来就有好几个Offer，而且说 我们这里团队氛围不行，没有 Leader 带，组内也没合作

不得不承认 工作经验丰富的人 行事就是迅速果断 , 我虽然骂遍了北京和工作，但是还是没能走

1. 我要经验没经验
2. 要存款没存款

所以我留了下来

沟通加班情况

他们组是 10:00 上班，然后下午 20:00 下班，但是中午人均弄到 14:00 才上班

虽然规定是 13:00 上班，但是实际上很多人都是 14:00 才开始上班

但是我们组更夸张

1. 9:30 来，18:30走，中间可能午休到 14:00 。

我有时候不太相信命，但是好像又不得不相信？ 这么空的时间 难道是为了让我好好准备再次跳吗

沟通 Leader 散养情况

他和我一样，都是 Leader 第一天发了一个文档过来，然后就没有后续了

直接开始散养，也没有每天的工作安排 也没有任务什么的

反问 : 你为什么不走呢

他说 :

1. 我是做数据开发的，字节可以说是全中国最大的数据中心了。 我想要刷点经验再走

其他

说实话 我也想要偷个项目再走，因为我并没有直接离开的决心和勇气

不过刚刚看了一下最近的日报，我看之前比我先来的两个同事 都没有干较为 完整的活。 或者说至少没有我上家公司一样，有几个完全属于自己的模块

谁会为你的选择买单

我一直在想一个点，市场是冰冷的，谁会为你的错误选择买单，貌似只有我自己能买单

1. 一开始选择了 就业面窄 的 Web3，同时还选择了 CEFI 而不是 DEFI 。 另外还是小公司 还是 远程
2. 现在又选择了外包

我表面上对外说，那家给的钱多所以我才去的，但是钱多又有什么用，我感觉我在自寻死路，自觉坟墓

不可能出现一份工作 我看你好可怜，你的履历真波折，那你就跟我干吧 市场是冰冷的 我或许只能为我自己买单

我究竟是哪一步走错了

往近了说

1. 裁员之后第一个月 我去单独写一个项目，用于C端面试 做了 支付、登陆、短信、Feed、热榜 等设计 还补了 一个 Ai-Agent 用于丰富简历

   i. 但是其实这里被问的概率很小，大部分人都问 你上家工作干嘛了，做了什么事

我感觉我这一步走错了，我那一个月应该 整理代码模块，把我负责的内容，梳理成多个项目

但是我最终梳理成了好几个 Backlog ？ 例如 优化数据库表、AsyncFlow 什么的内容 看着只是一个需求 而不是一个任务

2. 社招的时候看着也走错了好几步

   i. 八股文背的太少啦，或者是时间太短了

   ii. 算法题 有一些还是不熟悉

   iii. 项目写完其实也忘的差不多了，公司的也是。导致语言上说话有漏洞，或者说听上去观感不佳，而且反问的时候 不能立马回应，而需要思考

3. 选择工作的时候也是

   i. 如果我提前来过北京，我肯定是不会去北京的

   ii. 我可能会继续找 深圳广东长沙 的工作，不应该这么着急 或者说 投递北京的岗位的

我记得当初我选择来北京，自己骗自己说是 为了见见世面 可是现在好了，世面见到了，我反而不好脱身了

下一步应该怎么办

不知道 TBD

标准

1. 颜值: 较为简约 颜色不需要要鲜艳，外形好看 满足日常上班通勤
2. 底部: 不需要较为大的缓震的底，因为在公园路不太好跑，容易崴脚
3. 价格: 500左右

李宁

李宁看下来只有 赤兔9 PRO 合适，毕竟初中的时候 穿过 赤兔1 感觉挺不错的

不过还没有试过脚感

安踏

看着 C202 和 二区心率 90都挺不错

特步

看着 160x 8.0 和 两千公里 5 PRO 都挺好的6

160x8.0 800+了 ，感觉可以看看 3.0 5.0pro

Nike

迈柔 18 ， 大概 500左右

Adidas

波士顿13 和 EVO SL

Prompts

我现在的跑鞋是 Nike 迈柔Plus，我身高 165， 体重140 ，前脚掌着地

最近跑步场地变为公园跑，公园有一些高低不平的地，对于 Nike 迈柔Plus 这种顶缓 会导致我可能崴脚，感觉很考验我的脚踝力量

所以我想要更换一个跑鞋，有以下几个选择，满分100分，请你给他们打分，并且按照优先级输出

1. 李宁 - 赤兔9 PRO
2. 安踏 C202 7代
3. 二区心率 90
4. 特步 160x 8.0pro
5. 特步 两千公里5 Pro
6. 特步 160x 3.0 5.0pro这种系列
7. Nike 迈柔18 非plus
8. Adidas 波士顿13
9. Adidas EVO SL

Deepseek

ChatGpt

gork

Summary

根据下面提供的3个表格，其中 DeepSeek 权重 3，ChatGpt 权重2.5，Gork权重 1 来进行整合数据

权重越高越优先

下面按“权重越高越优先”整合：

• 综合优先级分 =（DeepSeek优先级×3 + ChatGPT排名×2.5 + Gork优先级×1）÷ 参与来源权重和，分数越低越优先。
• 缺失来源不参与该鞋款计算；Gork 的“特步 160x 3.0 / 5.0pro”为合并项，我同时映射到 5.0pro 与 3.0/3.0 PRO。
• 同分时，参考“加权评分”更高者优先。加权评分因各表评分尺度不同，仅作参考。

整合后综合排名

203.移除链表元素

力扣链接： https://leetcode.cn/problems/remove-linked-list-elements/submissions/

题目： 给你一个链表和一个val，删除所有节点值等于val的节点，返回链表

第一次

func removeElements(head *ListNode, val int) *ListNode {
    cur := head 
    for  ; cur != nil ; cur = cur.Next {
        if cur.Val == val {
            if cur.Next != nil  {
                cur.Next = cur.Next.Next
            }else {
                cur = nil 
            }
        }
    }
    return cur  
}

第一次 fail , 因为我们在 cur = nil 处理空的时候，当前的 cur.Next 会判断 Nil

然后我想着，我们是不是不需要这么额外处理 只需要处理 cur.Next = Cur.Next.Next 即可

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x8 pc=0x4c398b]
main.removeElements(...)
solution.go, line 10
main.__helper__(...)
solution.go, line 25
main.main()
solution.go, line 66

第二次

第二次更改的时候 发现返回的结果都是 空

是因为 我返回的是Cur, 循环里 Cur != nil, 循环结束 Cur == nil

func removeElements(head *ListNode, val int) *ListNode {
    cur := head 
    for  ; cur != nil ; cur = cur.Next {
        if cur.Val == val {
            if cur.Next != nil  {
                cur.Next = cur.Next.Next
            }
        }    
    }
    return cur  
}

正确思路

所以我们需要考虑 额外创建一个 结果 ListNode，然后通过 temp 指针进行处理

思路如下

1. 创建一个 dummy 输出， 创建一个 prev 用于移动 2. 判断前驱节点 即 pre.next 是否为空, 判断是否到尾节点 3. 如果前驱节点 == val, 那么前驱节点指向下一个 4. 否则的话 保留当前节点，往前走动一个格

func removeElements(head *ListNode, val int) *ListNode {
	dummy := &ListNode{Next: head}
	prev := dummy
	for prev.Next != nil {
		if prev.Next.Val == val {
			prev.Next = prev.Next.Next
		} else {
			prev = prev.Next
		}
	}
	return dummy.Next
}

707.设计链表

感觉有点困难 TBD

206.反转链表

力扣链接： https://leetcode.cn/problems/reverse-linked-list/

题目： 给你一个链表，翻转一下，返回头节点

思路

对于链表操作不太熟悉，遍历的时候 喜欢使用 cur = cur.Next 进行遍历

导致我尝试使用 cur.Next = prev 操作的时候不太好进行操作

这里我们可以尝试将 next = cur.next 记录下来，然后再将节点更改，然后再移动到下一个节点

func reverseList(head *ListNode) *ListNode {
    var prev *ListNode 
    cur := head 

    for cur != nil {
        next := cur.Next
        cur.Next = prev
        prev = cur
        cur = next
    }
    return prev
}

24. 两两交换链表中的节点

力扣链接：https://leetcode.cn/problems/swap-nodes-in-pairs/

题目：给你一个链表，每两个节点，进行交换。比如 1-2-3-4。 改为 2-1-4-3

第一次

func swapPairs(head *ListNode) *ListNode {
    cnt := 0 

    cur :=  head 
    var last *ListNode
    for cur != nil {
        cnt ++ 
        next := cur.Next // 记录一下一次操作

        if cnt % 2 == 0 {
            cur.Next = last 
            last.Next = next
        }
        last = cur 
        cur = next 
    }
    
    return head 
}

type MyLinkedList struct { 
 	 Val int 
 	 Next *MyLinkedList 
 	 Len int 
 } 
 
 
 func Constructor() MyLinkedList { 
 	 return MyLinkedList{ 
 	 	 Val: 0, 
 	 	 Next: nil, 
 	 } 
 } 
 
 
 func (this *MyLinkedList) Get(index int) int { 
 	 if index  + 1  > this.Len { 
 	 	 return -1 
 	 } 
 	 cnt := 0 
 
 	 for  cur := this ; cur != nil ; cur = cur.Next { 
 	 	 if cnt == index { 
 	 	 	 return cur.Val 
 	 	 } 
 	 	 cnt ++ 
 	 } 
 	 return 0 
 } 
 
 
 func (this *MyLinkedList) AddAtHead(val int)  { 
 	 newLinkedList := &MyLinkedList{ 
 	 	 Val: val, 
 	 } 
 	 newLinkedList.Next = this 
 	 newLinkedList.Len = this.Len + 1 
 	 this = newLinkedList 
 } 
 
 
 func (this *MyLinkedList) AddAtTail(val int)  { 
 	 tail := this.Get(this.Len - 1) // 获取末尾 
 	 this.AddAtIndex(this.Len - 1, val) // 插入在末尾前 
 	 this.DeleteAtIndex(this.Len - 1) // 删除末尾 
 	 this.AddAtIndex(this.Len - 1, tail) // 插入在末尾前 
 } 
 
 
 func (this *MyLinkedList) AddAtIndex(index int, val int)  { 
 	 if index > this.Len { 
 	 	 return 
 	 } 
 	 if index == 0 { 
 	 	 this.AddAtHead(val) 
 	 } 
 	 dummy := &MyLinkedList{Next:this} 
 	 prev := dummy 
 	 cnt := 0 
 	 for prev.Next != nil { 
 	 	 if cnt - 1 == index { 
 	 	 	 new := &MyLinkedList{Val:val} 
 	 	 	 new.Next = prev.Next 
 	 	 	 prev.Next = new 
 	 	 } 
 	 	 prev = prev.Next // 1->2 
 	 	 cnt ++ 
 	 } 
 	 this = dummy.Next 
 } 
 
 
 func (this *MyLinkedList) DeleteAtIndex(index int)  { 
 	 if index > this.Len { 
 	 	 return 
 	 } 
 	 if index == 0 { 
 	 	 this = this.Next 
 	 } 
 
 	 cur := this 
 	 cnt := 0 
 	 for cur != nil { 
 	 	 cur  = cur.Next 
 	 	 cnt ++ 
 	 	 if cnt == index { // 上一个 
 	 	 	 cur.Next = cur.Next.Next 
 	 	 } 
 	 } 
 } 
 

修正后

type Node struct {
	Val  int
	Next *Node
}

type MyLinkedList struct {
	head *Node
	size int
}

func Constructor() MyLinkedList {
	return MyLinkedList{}
}

func (this *MyLinkedList) Get(index int) int {
	if index < 0 || index >= this.size {
		return -1
	}
	cur := this.head
	for i := 0; i < index; i++ {
		cur = cur.Next
	}
	return cur.Val
}

func (this *MyLinkedList) AddAtHead(val int) {
	this.head = &Node{
		Val:  val,
		Next: this.head,
	}
	this.size++
}

func (this *MyLinkedList) AddAtTail(val int) {
	this.AddAtIndex(this.size, val)
}

func (this *MyLinkedList) AddAtIndex(index int, val int) {
	if index < 0 {
		index = 0
	}
	if index > this.size {
		return
	}
	if index == 0 {
		this.AddAtHead(val)
		return
	}

	prev := this.head
	for i := 0; i < index-1; i++ {
		prev = prev.Next
	}
	prev.Next = &Node{
		Val:  val,
		Next: prev.Next,
	}
	this.size++
}

func (this *MyLinkedList) DeleteAtIndex(index int) {
	if index < 0 || index >= this.size {
		return
	}
	if index == 0 {
		this.head = this.head.Next
		this.size--
		return
	}

	prev := this.head
	for i := 0; i < index-1; i++ {
		prev = prev.Next
	}
	prev.Next = prev.Next.Next
	this.size--
}

22:27 的感想

今天发生了很多事，唯独没有学习，明明什么都没有改变，但是我感觉到了我的存在

早上

早上起来其实还是很焦虑的, 因为上班的这三天确实没学到什么东西，或者说没感觉学会什么东西

但是我其实有一个 疑问

我其实渴望的是有人带我, Leader 或者是其他同事，但是其实有一个问题就是，我的前Leader来公司的时候，他又是谁带的呢

Leader 的上级只有产品经理和CTO，那么他也没人带，他只能自己读代码，自己看文档，自己体验系统 。

我上家公司有几个特点

1. 代码比较统一 前端后端代码在一起，容易从接口找到对应的实现
2. 系统比较统一 系统就只有 stage preprod prod 线上 等环境，而且功能比较通俗易懂
3. 文档很少，或者说几乎没有

我当前这家公司有几个特点

1. 仅仅只有后端代码，前端代码不知道在哪个项目 我也找不到 只能找到后端接口
2. 系统换进很多，什么 BOE 、stable、新加坡，plus 啥的好像有8个环境，每个环节都需要单独申请，也没有对应的URL访问
3. 文档很多，多到杂乱无章

所以我Leader是怎么学习的，他也没人带啊，为什么我不能学习，为什么我学不会呢，我感觉我应该也要学会 ？

所以早上其实压力很大，本来计划学习3天的，但是早上起来的时候拉肚子了，我感觉是吃鸭腿饭拉的肚子

昨天没设置闹钟，今天不是 8:30 起来的，而是 9:00 肚子闹醒的，特别拉肚子

拉肚子之后，然后回床上躺着，躺着很舒服，躺到了 10:30左右吧，然后开始点早饭

今天不知道是压力大还是不开心，早上点了两份饭

1. 一份是过桥米线
2. 一份是小笼包10个+混沌

吃完过桥米线就吐了，因为保持体重，不得不说，我喜欢这种吃了就吐的感觉

然后吃小笼包+混沌。北京这里的小笼包谈不上难吃，但是也没有好吃到哪里去，不过我喜欢面泡汤的感觉 非常好吃

吃完之后，然后就躺床上 和 女朋友聊天了

哦 然后途中又起来吃了两个鸭腿，然后又吐掉了 期间还吃了一个玉米

聊天，睡觉，刷抖音

我 12:00 左右定了一个计划，就是清理一下我抖音的点赞 大概4000多个视频

我之前都有一个习惯就是 定期清理点赞的内容 要么取消点赞 要么移步到收藏。但是最近找工作太忙，加上其他事情

导致我的喜欢暴涨了，我约定是看到 13:00 。结果看到 12:30 其实就没看进去了

因为我发现 我确实 这几个视频都是我喜欢看的，但是他又没有那么值得进收藏，所以就没什么兴趣继续看了

下午

13:00 睡觉，本来想要睡个 20分钟的，但是眼睛一闭 各种想法从脑海里面冒出来

例如 “某个学弟或者是朋友 保研啊 找到好工作什么的”“北京为什么这么烂”“我的下一份工作怎么办”“我跟我女朋友的未来怎么办”

然后没睡着，大概继续刷抖音到了14:00左右 洗了个头

然后打算出门，我前几天买的单肩包很好背，我本来只是打算出门买个瑞幸喝的，因为我女朋友今天生理期 在中午喝了奶茶 所以我想着我也喝点

洗了个头，然后穿个衣服背个包出去了

一走出门 突然就想吃个雪糕，因为之前来北京的时候 看到过好几个没见过的雪糕，正好今天节日 正好去买

买了一个 巧克力的雪糕 5 块钱，还买了一包呀土豆，和香肠 打算去旁边的公园 坐着 。然后去拿我的瑞幸

在公园坐着 1个小时，很爽，一天最爽的时候了

下午有太阳，公园，吃零食，和女朋友聊天，没有蚊子也不算很热

本来想再坐会的，但是16:30左右没太阳了 太冷了，而且蚊子也出来了

然后我就回去了

晚上

回去的时候 点了一份鸡公煲， 和女朋友聊天的时候 不小心水洒到笔记本上了 不过还好我是 MAC 笔记本放水

鸡公煲不算特别好吃，但是也要20+，北京的外卖就是这么贵

下午的时候 我记得我坐了40个哑铃弯举

吃完饭 刷了会抖音，期间刷了5个算法题，都是比较简单的 算法题单

题目来源于 我购买的一个后端训练营的 算法打卡内容，不是按类别进行分类的，而是按照周和天出的题

断断续续大概刷了1个小时 涉及 暴力模拟、快慢指针、滑动窗口、二分什么的，都是为了处理面试的

然后晚上休息了一个小时 出去跑步了，今天就是想跑所以去跑了，因为今天除了去公园走走还没什么运动

而且我想看看那个公园晚上能不能跑步，毕竟我想知道我下班后还能不能运动，如果不行的话 可能需要找另外一个路线了

没想到竟然可以跑步，而且配速还能接受，我感觉我配速可能慢到 8分配了，因为担心崴脚，，可是实际还是在 6分配的范围

跑完步，我母亲突然找我，问我一些家常，然后我和女朋友吐槽了5分钟

说什么我母亲自私，没有在我需要她的时候 给予关怀，我现在不需要了又来嘘寒问暖。 而且给一些傻逼都知道的话 例如 不要去跑太黑的地方，吃饭没有，放假几天什么的

我反正对我父母没什么好感，我无非是他们生出来养儿防老的工具，可是说实话 为什么是我，为什么是我来吃这个苦，如果我家有钱，我可以养儿防老，但是为什么没钱还要帮你们养老

跑完步之后回去洗澡，洗衣服

和女朋友打视频，打完之后又和我母亲打视频

因为她说她明天有空给我打，我并不想明天空出某一些时间跟她扯什么话，所以我洗完澡就给她打了，这次没说什么

就说 “一个人在北京有没有钱”“累不累”什么的，至于那些家常 和 什么时候结婚，多存钱什么的话 倒是没说 。而且说了一些欣慰的话 例如 “我也没什么好说的，那些常说的话 你也听烦了我就不说了”

挺好的，然后我就挂了电话 。 继续和女朋友打视频

后面又做了一组无氧，然后上了个厕所，写了一下题解，随便看了一下抖音什么的 ，23:00之后开始写我这篇日记，同时优化一下我的这个项目的内容

总结

从课题分离的角度看 我今天既没有在股市赚钱 也没有在 学习方面努力 理论上来说 我是悲观的一天

但是 我下午在公园吃零食，晚上跑步 然后和 父母沟通 同时今天还和女朋友打视频打了很久 说了很多，而且今天还不用上班

我感觉 我至少存在了某一段时间，这就是我，我感觉很爽，或许这就是生活的意义

704.二分查找

力扣链接：https://leetcode.cn/problems/binary-search/

题目：给你一个升序数组 nums 和一个目标值 target ，返回目标值 target 在数组 nums 中的下标，如果不存在则返回-1

思路

标准的二分查找，可以直接通过 左区间 或者是 右区间的方式找出来

问题

一开始 Code 写错了，我在区间移动的时候 认为 如果答案在 nums[mid] >= target 的时候 那么答案肯定在 左边，因为左边有相等

所以这时候 我就直接 l = mid 但是有一个问题就是，如果 第一次计算出来的答案比他小，那么 r = mid - 1 永远也计算不出来答案

所以我尝试把思路转变成 ，求 小于等于的第一个数， 保证在区间第一次缩小的时候能够正确缩小

func search(nums []int, target int) int {
    l := 0 
    r := len(nums) - 1
    for l < r {
        mid := (l+r+1)>>1 
        if nums[mid] >= target {
            l = mid 
        }else {
            r = mid - 1; 
        }
    } 
    if nums[l] == target {
        return l ;
    }else {
        return -1;
    }
} 

Code

  for l < r {
        mid := (l+r+1)>>1 
        if nums[mid] <= target {
            l = mid 
        }else {
            r = mid - 1; 
        }
    } 

27. 移除元素

力扣链接：https://leetcode.cn/problems/remove-element/​

题目：给你一个数组 nums 和一个值 val，要求你把数组中值为 val 的元素全部删掉，而且不允许你使用额外的数组来辅助解决这题，返回移除 val 后数组的长度

问题

一开始思路便 ，我以为是移动元素到后面，而且我还一直在纠结 如何不使用额外空间进行移动 ,所以一直在纠结 [val,val , 1,2,3] 的情况

但是题目要求并不是移动到后面，而是只需要保证前 k 个不包含几个

思路

使用快慢指针，对于慢指针，当快指针扫过val的时候 慢指针停止移动，下次快指针进行更新

Code

func removeElement(nums []int, val int) int {
    fi := 0 
    n := len(nums)
    for i := 0 ; i < n ; i ++  {
        if nums[i] != val {
            nums[fi] = nums[i]
            fi ++ 
        }
    }
    return fi 
}

977.有序数组的平方

力扣链接： https://leetcode.cn/problems/squares-of-a-sorted-array/

题目： 给你一个递增数组 nums（包含负数），返回一个数组，且数组要求里面的元素是给定数组 nums 里面元素的平方，还要求递增

思路

这题之前做过有印象，因为原数组就是排序之后的数组，所以我们通过 左右指针，即可保证 正负的最大值判断

但是在插入的时候有问题，因为我们要求是从小到大的输出的。 因为 如果我们顺序插入会导致乱序 ，因为我们并不能保证当前的两个极大值一定是最小值

因此需要考虑反向插入

Code

func sortedSquares(nums []int) []int {
    l , r := 0, len(nums) - 1
    
    res := make([]int ,len(nums))

    k := 0 
    for ; l <= r ; {
        lv := nums[l] * nums[l]
        lr := nums[r] * nums[r] 
        if lv < lr {
            res[k] = lv 
            l ++ 
         }else {
            res[k] = lr
            r -- 
         }
         k ++ 
    }
    return res 
} 

209.长度最小的子数组

力扣链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

题目：给你一个数组和 target，求出一个连续子数组，并且这个子数组相加要大于 target，返回子数组最短的长度

思路

一眼就能看出解法的题目，需要使用滑动窗口，或者说每次能够 >= target 的时候 需要维护一个左指针 保证最小区间

但是这里有一个问题就是我们是 ans >= target 的时候需要计算 而不是 ans > target 一开始写这个题目的时候 还是有很多卡点

Code

func minSubArrayLen(target int, nums []int) int {
    n := len(nums)

    ans := 0 
    l := 0 
    res := n 
    find := false 
    for i := 0 ; i < n ; i ++ {
        ans += nums[i]
        // 1 ->
        // 1 + 4 -> (5 - 1) -> (l = 1, i = 1)
        for ans - nums[l] >= target {
            ans -= nums[l]
            l ++ 
        }

        if ans >= target {
            res = min(res, i - l + 1)
            find = true 
        }
    }

    if !find {
        return 0
    }

    return res 

5. 螺旋矩阵II

力扣链接： https://leetcode.cn/problems/spiral-matrix-ii/

题目： 给你一个n，生成NxN的矩阵，并且要求你顺时针填入 1，2，3，4，5...

思路

单纯的模拟，没有什么优化空间， 一开始以为是构造，是个什么数学公式

但是发现就算数学公式，你也需要 n^2 的时间复杂度 进行补充数据

所以我们只能通过 模拟，模拟 n^2 次行为，当我们走到边界的时候尝试进行转向

Code

func generateMatrix(n int) [][]int {
    dx := []int{0,1,0,-1}
    dy := []int{1,0,-1,0}

	res := make([][]int, n)
	for i := 0; i < n; i++ {
		res[i] = make([]int, n)
	}

    cur := 1 
    x , y := 0 , 0 
    k := 0
    for i := 0 ; i < n * n ; i ++  {
        res[x][y] = cur 
        cur ++ 
        tx , ty := x + dx[k],y + dy[k]
        if tx >= n ||tx < 0 ||  ty >= n || ty  < 0 ||  res[tx][ty] != 0 {
            k = (k  + 1) %4 // 顺时针
        }
        x += dx[k] 
        y += dy[k]
    }
    return res 
}

现有的问题

1. Leader 属于放养的状态
2. 项目主流程走不通
3. 甚至找不到业务前端界面，不能从业务出发 然后找到对应的 Rest 页面从而找到对应的代码
4. 整个业务内容太大了

解决 (分而治之)

先根据 LTC(系统新人文档) 看了一下我们系统的相关模块

根据文档中的 系统地址，尝试进行一些 业务操作的熟悉

系统地址
- 商品：https://noah-b.bytedance.net/comm/commodity/product
- 报价：https://quote.sre-boe.bytedance.net/quote-list
- CRM：https://eps-crm-boe.bytedance.net/quote/list

一些问题

对于 报价 系统，访问的时候表示没有权限，昨天询问 Leader 的时候，说我不负责这个模块，我先 SKIP 了

然后我尝试去访问 CRM 页面，因为商品页面也不是我负责的

CRM 问题

1. 访问 CRM 创建合同流程的时候 页面空白 也没有权限报错
2. 访问在线协同合同的时候 页面 404

没有什么比较好的 IDEA 直接去问了 ，第一天入职的时候 Leader @带我的负责人

负责人叫我询问 CRM 相关的开发同学，询问后暂时无果

后续 :

给我提供了一个 New 360 版本的平台，但是给我开通的权限是 直销 权限

没有看到创建合同 和 合同流程 的操作。

没什么想法 感觉更复杂了

CRM_360

名词解释

CRM (Creator Recommendation Matchmaking) 达人定向货盘推荐系统，仅 TikTok 内部使用

实际体验下来感觉是一个多纬的后台管理系统

包括管理 (商机、管理报价、管理合同、管理客户)

看着是一个 面向销售 或者是 客户成功 这一类的人使用的

看不懂还是看不懂，我该怎么入门，应该怎么看 。。。。。。。。。。。。。。。。。。。。。。。。。。。。

怎么办怎么办，我的人生完蛋了

写在前头

我昨天入职了，昨天忙了一天今天理论上来说应该是安稳学习，走完新人学习文档的一天

按照我上家公司的流程 今天应该是简单开发一些内容跑通一个主流程

我的规划

1. 就像走一下新人文档
2. 更改代码中的一行日志 走一次开发-自测-PR 主流程

问题

1. 我看新人文档的时候遇到了一大堆问题

各种历史旧文档没内容，没权限，各种名词各种逻辑乱跳

2. 然后我就去走开发主流程

我确实是 创建了一个branch 然后提交了，但是线上的 CI 环境一直没有通过 不是他妈的 command fail 就是他妈的 no permission 或者是一些更离谱的错误

他妈我之前那家公司怎么要这么离谱，我草你妈的，他妈开发就开发，而且这个不应该找运维吗，他妈这个运维又是谁

然后我把重心转到体验业务上，我打算打开我们业务的网站但是我发现我打不开，提示没有权限，也不跟我说要去和谁申请权限

我他妈又去问了我的leader，我leader回复他妈什么意思

什么叫做 我不需要访问这个业务网页，那他妈发给我的这个文档就是他妈的这个业务的文档啊

这他吗什么意思 我草泥马的 ，就是干看文档 干看代码，不让体验业务 ？？？

@麻伟 这是报价平台。你不用访问吧。权限得 问 @姜晨星 看boe怎么申请
@麻伟 你是要支持的合同域开发，报价只是算是周边上游系统，大概了解一下即可。
重点是从业务链路的角度理解报价是业务流程的上游

情绪

生气

你他妈招我进来，他妈有不管我是他妈什么意思

不舍

他妈的，昨天才到了10多个快递

我刚买的鸡胸肉 刚买的玉米 刚买的护肤品 刚卖的垃圾袋 刚买的茶叶 刚买的洗发水 沐浴露 ....

我他妈刚交的 3个月房租 我草泥马

写在前沿

我在 CAM 工作了两年，可以说毫无收获, 又或者说我没来得及去整理导致我认为我这两年毫无收获？ 可是说实话 我今年写的代码都忘记了，更别提我去年写的代码 CAM :
一家 Web3 ，面向 B 端的 资产管理项目 。 整个项目结构使用package进行拆分业务模块 部署方式通过私有化部署，可以算是一个单体应用 最常见的优化方式就是增加本地缓存因为对实时性并没有这么高 整个技术栈如下 : 开发 : Golang , 本地缓存 ，Redis缓存，pg-sql 监控 : influxdb, grafana 我映像中就没有了 乐观主义相信, "种一棵树最好的时间是十年前，其次是现在" 但是悲观主义的我相信 "温水煮青蛙" ，青蛙被煮死了自然活不过来了 然后我开始找工作，发现市面上的岗位投完，只拿到了 北京的 这个offer ， 而且还是一个外包

入职

今天第一天入职，说实话体验不是很好 主要有以下几点

1. 年假一开始说的 5天，我忍了。 结果到了线下的时候 说是根据工作时间进行动态发放的，例如现在是9月份了，工作到 12月份，那么只有 1.5天还是多少天了

2. 工作可能会出差

3. 我的Leader不是我们公司的，因为是外包公司，我的Leader是字节正式员工，我们不在同一个办公楼

   1. 而且我的 Leader 对我们属于散养形式，并没有特别明确的路线规划

4. 公司福利很少，零食只有一个月发一次，另外组内氛围很差，因为是外包每个人都有每个人自己的事，可以认为每个人都是独立的

5. 公司在18楼 19楼，每次都需要等电梯，每次进出公司都要刷工牌，上班的时候需要等电梯

6. 没有迎新环节，没有组内吃饭，去的楼下食堂吃饭的 人很多很难吃 北京的饭都挺难吃的

入职学习

今天早上 9 : 30 到办公室，然后入职培训到了 12:00 ，主要是 HR 培训，IT部门培训，行政培训

中午的时候自己一个人吃饭

下午的时候很离谱了

我12:40睡觉，睡到 13:00 起来。 我发现我的同事们有的 13:30 才睡觉，有的 14:00 还在睡觉什么的

我们还需要字节那边配合开通字节端的账号，所以14:00前 我都没有什么任务，然后我就出去走了走，大概到了14:00，还是14:30才有账号

开始看一些入职的事情，整个入职文档写的很烂，看着是我们外包同学写的，他也才入职没多久，很多问题都是问了其他小伙伴解决的

大部分就是内网问题 和 权限问题 。 安装软件都很麻烦，然后下班前还在弄 Go仓库依赖，字节那边限制 一天只能下载50个私有仓库，问了其他小伙伴他们都说没遇到过

然后我就直接下班了，我的leader也没有问我什么

我并不感觉我能学到什么，说实话 。 感觉外包 没有明确的需求，现在也没看到明确的测试，更没有完整的开发手册 。。。。 ，感觉整个流程还不如我上家公司，无非是这家公司技术栈更多一点

那我现在应该怎么办？

首先我女朋友在考研，预计明年3月份出分数，而且她明年6月份毕业，我很爱她，她说如果没考上的话 希望我能够回长沙陪她一年。所以到时候可能还要回去

现在我简单想了一下有这几个决策

1. 现在就离职，然后去找一个长沙的工作 或者是找一个深圳的 离长沙近的工作 。

   1. 可是如果找不到怎么办 ？

      1. 找不到就硬找到过年?我女朋友会不会嫌弃我, 而且 gap 时间越拖越久，如果gap一年会不会影响找下一份工作，导致滚雪球 ？然后完全找不到工作

2. 现在离职，然后去考研

   1. 这样子我可以很好的和 我女朋友同一届，如果考上的话
   2. 但是问题是没考上怎么办，而且考上了读研还要脱产3年，到时候毕业出来年龄很大了怎么办
   3. 考上研的话，到时候还可以重新实习 重新以应届生的身份参加秋招，相当于改命

3. 工作6个月，到明年2月份 然后离职，或者说开始找新工作

   1. 保证不会gap太久，而且期间还有工资可以拿
   2. 但是6个月可能不会有太出色的内容能写到简历上，我工作了2年 写到简历上都感觉没什么好写的，更别提6个月了，那么我这6个月的意义不是浪费时间吗

4. 现在就开始投，然后用入职的这不忙的一个月开始准备跳槽

   1. 这个看上去很好，但是会有公司收吗，他们可能会问是否在职，我说在职，又会问会什么立马就跳？
   2. 而且我第一轮面试下来确实结果不好，我是不是要花钱报班或者是找人辅导封装一下才行

我貌似没有路可以走了，我不知道该怎么办

我貌似想进大厂，又想要稳定的陪女朋友，想要稳定的工作

但是我面试的时候 要么没有垂直经验，要么工作经验不匹配，要么就是KPI面，要么就是没有C端经验 。。。。

个人介绍

大家好，我是18年毕业的三本计算机专业的本科生。在个人介绍里我会大概说一下在校经历、第一段工作经历、第二段工作经历。

在校经历

当时我们学校即是本科中最差的三本，也几乎是三本中垫底的一所，再少几分就可以落到专科学校的那种。

所以学习氛围自然不如985，211这些学校，我大一、大二也是玩过来的，没怎么学习。

直到大三才幡然醒悟，开始为自己做 未来的职业规划以及恶补技术知识，所以当时在大三参加了师兄师姐开的Java课程（类似于黑马编程培训班之类的课程）。

课程结束后对自己的技术信心满满，课程结束也恰逢大三暑假开始，就直接投了社招进了家外包公司。

为什么投的社招？

当时对于我们学校来说投校招的氛围不是很足（当然学习氛围也很差，大部分人都是混混日子），

大家甚至日常在学校也不会谈论到校招、社招这些话题（可能这就是三本和985、211学校的区别吧😅）。

所以当时我对校招、社招的也没什么理解，也不知道有什么不同。

再有一点我看我们学校以往的校招职位都是很low那种，我都不确定有没有IT公司的，印象中都是那些什么销售、厂工...

校招没什么好机会，再加上当时对自己技术能力的自信，于是大三暑假就开始了投社招。

为什么去了外包公司？

其实当时也有投其他私企和国企，可是在社招渠道还是挺在意工作经验的，再加上学历也不是很好。

即使写了课程中做的项目，对于社招渠道还是捉襟见肘，几乎都没给面试机会。

只有那家外包公司给了面试机会，最后也面过了。当时觉得自己还是蛮厉害的，但是现在回头看或许除了比在校其他三本学生技术强点之外，也许外包技术能力要求比较低吧😅。

第一段工作经历（外包）

严格来讲我在这家外包公司工作差不多待了四年，因为大四一整年我除了考试回去，其他时间都在公司里，大学课程都是舍友帮我举手。

为什么外包公司也能待四年？

当时我很少看网上的职场信息，也是因为在那四年里我感觉我每天都有在学到东西，而不是重复性的无脑工作。

我在刚入职2个月后被叫去研究当时热门的新技术（区块链），而且当时公司没人懂，只能靠自己在网上查资料学习，还要学会安排项目时间，由区块链发展历史开始学起，从0到1帮助公司落地区块链项目。

所以四年里，我做了包括产品经理、PM、后端开发、运维这些职位的工作。 也参与了很多比赛拿了奖，参与了很多开源社区的聚会，尽管忙碌，但是每天都感觉充实。

从外包裸辞

尽管在第四年我提了加工资，也顺利给我加了。但感觉项目已经趋于成熟，也要开始做一些重复性的工作了，加之自己想去更大的平台发展，就选择了裸辞。

因为在外包公司很忙，比较少时间在工作的同时学习跳槽需要的知识，再加上当时家里经济情况也允许我裸辞（我想到最坏的情况下我2-3个月没有收入也不会怎么样），于是就这么做了。

裸辞后开始面试

当时大、中、小公司都面过，印象中没人问起第一家公司是不是外包。我当时裸辞的2-3个月里有刷算法，和部分八股，但是八股只看了一点点，经不起细问（特别是MySQL八股没怎么细看）。

印象比较深的有两家：

1. 面领星，首先要做笔试题，我感觉我写的都挺好。但是 MySQL 没答好就挂了

2. 面菜鸟的时候，面试官有句话让我印象特别深：==“即使你会运维、开发还有其他的技术，即使你技术横向扩展很厉害。==但工程技术纵向不够深还是不行啊。你想想对于开发人员来说，开发能力重要还是运维能力重要。”

   当时菜鸟面试官那句话对我的打击挺大，也算是点醒了我吧。因为当时还不知道其实在大点的公司，开发与运维有专门的职位，他们都只要在各自的职位的技术栈上够深就行了（当时自己VM玩的还挺溜，其实也不是坏事啦）。

   不过这确实是自己的经历，也是这些经历塑造了今天我，他们不需要那就下一家吧！面试有时候还是讲缘分的。

第二段工作经历（中小厂）

当时在外包是做Java的，当时接触到区块链后对 Go 挺感兴趣，这家中小厂也接受Java转Go，就去了。

这家中小厂的规模最多人的时候应该在500-600人左右，虽然人数不及大厂，但是里面很多工作模式，和工作思想都是参考大厂的，可以说是小而美吧。

在这家公司的3年了，我也拿到了公司颁发的一些奖项，和领导的好评。

其实第三年开始对我的成长已经不高了，然后我一直都想去大厂看看世面，再加上第三年绩效有个C的指标要给我背，就加速了我跳槽的进度。

面试经历

刚开始面试会比较结巴，然后语言也不够精简，给面试官的体验就不是很好。

有面试官在我反问不足的时候也直接说我的回答有时间很啰嗦，不够简练。

不过随着面试多起来，以及我每次都会反问我的不足并克服它，后面就越来越顺利了。

比如有两个印象比较深的场景：

投了很多，很多也没给面试机会的，包括阿里和字节都没有面试机会，是比较可惜。我都是在BOSS上投的，另外BAT我在官网上也投了一份。

关于投递 回复率 和 约面率 ：我感觉对于中小厂来说投给HR和开发都差不多；

但是如果大厂投给HR就比较低了（虽感觉是学历+过往经历的原因），如果能直接投到开发甚至是组长就会高一些。

写在前头

明天就要入职了，睡个中午觉起来，发现比我小一届的学弟竟然跳槽到网易了有点惘然

我的朋友可以说没有，所以只能把他们称作伙伴

当我毕业了，换了工作，离开某个城市。我所谓的朋友就自然的断连了，所以可以认为我没有什么朋友

我的朋友们看着都过的很好，我有点嫉妒有点茫然

Numpy

Numpy 我想想 毕业于 重庆理工大学，双非 机械专业

自学了 C++，PAT甲级满分，蓝桥杯B组国二

一开始入职的是恒生，薪资 15k 还是 11k base 杭州。后面恒生 开始加班 然后他开始跑路

边工作边面试。他不喜欢海投，后面跳槽到了百度的搜推 薪资 22k

他跟我说工作内容，沟通下来比较像是运维，某周需要加班 on call . 不过活大部分都是配置相关的内容

恒生工作2年，跳槽到百度，百度工作了快2年

然后百度裁员，和我差不多一个月被裁了。现在社招一个半月

裁员的时候 就被其他 hr 加上了 推了 拼多多，字节，oppo子公司 这几家看着都挂了，oppo子公司走完hr面后没后续

现在在走腾讯的 Wxg 预计 offer，总共面了5轮了，2面技术面，2面面委面，1面hr面。 等待 offer 中

YangHongYi

YangHongYi 我的学弟跟我一个学校 ，实习的时候 我辅导过他一阵子，他的实习简历我记得和我的差不多

或者说他比我多了一个 mit6.824 。我们学校支持外出实习一年，这应该是一个很不错的红利

他在上海游卡实习，然后转正，毕业薪资 17k

我工作了两年，那么他应该是工作了1年2个月 。 现在跳槽去了网易

我不知道这一年他发生了什么，他之前在游戏公司工作，所以经验match到了网易？

他获取到 算法比赛奖项和差不多的，但是我是软件工程 他是电子信息工程 专业不同。其他都差不多

我们都没有选择研究生 而是直接工作，貌似他现在混的比我好

Guenhao

Guenhao 我学弟的学弟 。 现在在美团实习

他研毕了一年，因为挂科了导致没保研上，现在应该是正好在研毕。干的 Agent 实习，他的论坛我完全看不懂了，看着涉及到一些 AI 的论文

我们同一个专业 学的同一个专业课，但是现在工作的内容完全看不懂

其他人

其他人，大部分都保研去了，我认为他们读了研出来肯定有更好的生活的 不像我

我

我始终不知道我走错了哪一步

有一句话是这么说的 "选择比努力更重要"，

如果说我高考失利并没有错误，那么跟我同校或者是学校弱于我，甚至专业弱于我的人，他们貌似都过的比我好

那么你说我实习的时候错了吗？ 没有找到好的公司，去了一家 加密货币的小公司 ？

可是我这个公司也有很多 985 ，211 啊都是硕士 。不过从竞争力上来说，我选择了这家公司确实没有什么竞争力，B圈 web3 在国内就很少有工作

那么我实习选择错了，为什么我选择错了，因为我不努力，所以我在找实习的时候没有好选择，所以我没办法选，我只能这么选吗，我看是的

但是为什么简历，同样的学校，不同专业，过了一年 我学弟就可以去中小公司 我就不行 。是我不够努力？我太笨了，我表达不清楚？我背东西不够熟练？还是说时运不济 ？

我工作了2月2个月，找工作了2个月，面试12家，最终失败，选择了外包，虽然涨薪了40%，但是我高兴不起来

这时候，我貌似更想看中title，而不是工资

他们貌似有更美好的未来，但是我貌似已经没有了

我应该怎么办呢 报个班吗，报班就能好起来吗

简历包装一下吗

补充

嫉妒，无比的嫉妒 。 Numpy 现在通知 Wxg OC了。 明明大家都是在用 Ai 编程

无非是履历不同，明明大家都差不多，为什么他们可以这么成功 ？为什么我不行

我感觉我从小到大都是失败的，我脑子里面又有一种声音了 “为什么事情又变成这样了”，为什么又变成这样了！！为什么，为什么，为什么，为什么，为什么

就因为我父母不是小学都没毕业？就因为我是农村人？就因为我没有接受过良好的教育？小时候没有被好好爱过？

为什么他妈会这样子！我操你妈，为什么

YangHongYi 是福建人，家里有国外的亲戚，Guenhao 是山东人家里开理发店的， Numpy 在重庆省会有个房子 ，其他保研的家里也不错

为什么 我不行，为什么，为什么事情又变成这样子了，我到底做错了哪一步？从一出生就错了？我日你妈，草你妈的生活

为什么我他妈甚至记不得我上个月准备的面试，为什么我他妈面试不通过，为什么大厂没有HC，为什么我简历不通过

为什么我都这么努力的工作了，裁员还要把我裁掉，为什么明明我才和女朋友确认关系，我就要分别，为什么，为什么

Prompts

你现在是 @CAM 项目的 CTO 技术总负责人

问题 :

我想要知道 @cam 中有没有什么模块或者是内容可以用来丰富我的简历

背景 : 我在 CEFI组工作，主要负责 cefiacc/, tradeaccbiz/, tradeacc/, exg/, custody/, histoytradev2/ 这几个模块

我工作了2年之后被裁员了，我复盘我整个2年过程，我发现我的工作大多都是重复的，在 exg/和custody/对接交易所和托管行，然后在historytradev2/处理记录

然后我总结了一下我下面的这个简历

简历如下 :

负责 CAM 交易所资产管理平台后端：覆盖多交易所账户快照、流水记录、对账与数据修复，支撑资产展示、投组配置与风控告警。

- **异步补齐链路（asyncFlow）**：从 0 到 1 搭建两套高可用流程（申请 → 轮询 → 下载 → 入库），兼容 REST 抓取与交易所 Async 下载，并与账户回溯打通，支撑历史缺口补齐与对账前数据治理
- **Auth 核心表平滑迁移**：针对历史库表设计缺陷，采用双写兼容 + 平滑迁移 + 降级回退，配合灰度发布，一季度内完成核心模块重构并上线
- **用户状态机重构**：改造库表与组内核心逻辑，分迭代推进后台任务，并通过 MQ 同步其他业务组，在兼容旧状态的前提下完成快速上线
- **存储与性能优化**：基于 I/O、Memory 监控定位窄表膨胀，引入 blob + slim 压缩与 blob_format 零停机迁移，一季度内关键路径性能提升约 40%，显著降低存储增长斜率
- **对账与修复工程化**：维护通用快照 / 记录修复 Job 框架，支持按交易所扩展订正逻辑；优化账户状态维护、限流与鉴权；支持 Excel / 大文件导入补齐，并兼容对账模块

面试情况 :

但是我在一轮面试周期下来，我发现每个任务单独拆并不是一个模块，可以说是一次任务。并不像大厂一样 一个人负责多个模块，导致对于问题“你负责过什么模块，流程是什么样的，难点xx"这种问题很难答上来

同时对于一些C端岗位又会问你这几个项目中是否有并发的需求，怎么处理的，但是实际上工作中也没有

其次面对现有Ai的发展，我们公司也没有主动推进AI的相关需求，所以也没有相关的需求

目标 :

我想要提高我的竞争力，增加我面试通过概率，希望能够优化我简历的内容，补充一些高可用的模块或者是内容

CC

结论先说：你的问题不是没有内容，而是你把一个平台讲成了一堆任务，而且把最值钱的那块完全漏掉了。

我用 git 数据核了一遍你的真实产出：1923 次提交，后端净增约 38.3 万行，时间跨度 2023-05 到 2026-07。你现在这份简历，严重低估了自己。

一、诊断：为什么面试官觉得你"没负责过模块"

你那 5 条 bullet，全部是动词开头的任务描述：搭建、迁移、重构、优化、维护。没有一条告诉面试官"我负责的系统长什么样、边界在哪、谁依赖我"。

面试官问"你负责什么模块"，本质是在问三件事：这个系统的边界是什么 / 它的架构是你定的吗 / 别人怎么接入你。你答不上来，不是因为没做过，是因为你自己也没把它当成模块看。

有一个数据能直接推翻你的自我认知：你改动 back/ec/（整个交易所接入层的核心接口定义层）达 265 次。ec.IAccService 这个 40+ 方法的接口、ExgErrorProcessor 限流器、统一签名抽象都在这里。改接口定义的人是平台 owner，只实现接口的人才是干体力活的。 你是前者，但你的简历把自己写成了后者。

二、你实际拥有的三个模块（按 git footprint 划分）

这三块任何一块单拎出来，在大厂都是一个正经模块。你欠缺的只是用架构语言把它们描述出来。

三、你漏掉的最强素材：实时链路与并发

你说"工作中没有并发需求"——这是本次分析里最大的误判。

素材 A：balance_update_processor.go（441 行，你写的）

这是一份教科书级别的并发面试素材，几乎覆盖了所有八股考点，而且全是真实生产代码：

func (p *balanceUpdateProcessorImpl) Process(account string, clearTime int64, balanceDelta string) {
	p.once.Do(p.start)
	p.accountMu.RLock()
	events, exists := p.accountMap[account]
	p.accountMu.RUnlock()
	if !exists {
		p.accountMu.Lock()                     // 如果不存在，需要创建新的 accountEvents
		events, exists = p.accountMap[account] // 再次检查，避免重复创建
		if !exists {
			events = &accountEvents{...}
			p.accountMap[account] = events
		}
		p.accountMu.Unlock()
	}
	events.mu.Lock() // 现在可以安全地操作 events
	defer events.mu.Unlock()

能讲的点，每一个都是面试高频题：

• 两级锁降低粒度：全局 accountMu 只保护 map 结构本身，每个账户有独立的 events.mu 保护自己的事件队列。账户之间完全无锁竞争。
• Double-check locking：先读锁查、未命中再升级写锁、拿到写锁后二次确认。
• 削峰聚合：2 分钟聚合窗口 + 50 秒 tick，把同一账户的 N 次 WebSocket 余额变动事件合并成 1 次 REST 查询。这是限流场景下最有效的手段。
• 信号量控制并发：concurrencySem chan struct{} 容量 10，防止瞬时打爆交易所 API 配额。
• 临界区最小化：第 164-167 行复制切片后立即释放锁，再做耗时的网络请求。
• 指数退避：1s / 2s / 4s 三次重试。
• 内存泄漏防护：24 小时不活跃的账户从 map 中清理——这点尤其加分，说明你考虑过长期运行的内存增长。

素材 B：你此刻正在写的 asyn_download_worker.go——背压设计

// enqueueAsynDownload 将已 completed 的任务交给下载 worker；队列满则回灌 Redis，避免丢任务。
func enqueueAsynDownload(detail common.DownLoadIdDetail) {
	startAsynDownloadWorkers()
	job := asynDownloadJob{detail: detail}
	select {
	case asynDownloadJobCh <- job:
		...
	default:
		asyn.Logger.Warn(...)
		store(detail, cam.JsonMarshal(detail), "DownloadQueueFull")
	}
}

有界队列（32）+ 固定 worker（3）+ 队列满时回灌 Redis 而不是阻塞或丢弃。这是标准的背压（backpressure）设计，面试时展开讲"为什么不用无界 channel"、"为什么不阻塞"，非常能体现工程判断力。

素材 C：Binance WebSocket API 强制迁移

这是高可用变更管理的完整案例。Binance 公告 2025-11-10 停用 listenKey 鉴权方式，这是一个不可协商的外部硬 deadline，迁移失败意味着所有 Binance 账户实时数据全部中断。

你的做法（从你写的 WSAPI_MIGRATION.md 和 BUGFIX_20251104.md 里复原）：

• UseWSAPI 开关让新旧两套鉴权路径并存，默认关闭，改一个布尔值即可全量回滚
• 旧路径：REST 取 listenKey → 连 stream.binance.com/ws/{listenKey} → 定期 renew
• 新路径：直连 ws-api.binance.com → 发送带签名的 userDataStream.subscribe.signature 订阅请求 → 无需 keepalive
• 消息处理要新增分流逻辑：响应消息（status 字段）不能透传给业务层，错误消息（-2015 API key 失效）要触发自动重连
• 附带收益：逐仓杠杆（binancem）从"每个 symbol 一条连接"变成"一条连接收全部 symbol"，连接数大幅下降

这条线你踩过的两个坑（方法名要用 .signature 后缀才支持 HMAC/RSA；签名串必须按字母序包含 apiKey 和 timestamp）本身就是很好的面试细节——面试官最喜欢听真实踩坑。

四、"没有并发需求"这个问题，你的话术要换框架

你被问并发时答不上来，是因为你默认"并发 = 高 QPS 扛流量"。但你做的是另一类并发问题，而且更难：

C 端的并发是"入口流量不可控，我要扛住"； 我们的并发是"出口配额被外部硬限制，我要在不被封禁的前提下最大化吞吐"。 前者可以加机器水平扩展，后者加机器反而会更快触发限流和 IP 封禁。

围绕这个框架，你有一整套真实答案：

• 配额感知的预判式限流：bnutil/blockip.go 解析 Binance 响应头 X-Mbx-Used-Weight-1m，到达 95% 阈值就主动禁用 IP 10 秒，而不是等 429 再被动退避
• 多维度限流：按 API key / 账户 / 代理 IP 三个维度独立计数（ec/exgerrorprocessor.go）
• 请求合并：上面说的 2 分钟聚合窗口
• 有界并发：120 goroutine 的抓取请求池（exg_loop/single_call_job.go）、信号量限 10、下载 worker 限 3
• 背压：队列满回灌而非丢弃

把这套讲清楚，比背一遍"如何设计秒杀系统"更能证明你的工程能力。

五、AI 这块，我要给你一个诚实的提醒

我查了仓库里唯一的生产级 LLM 应用（cefiacc 里用 DeepSeek 做账户信息校验，check_account_info.go）——作者是 zhongtaoliu，不是你，不能写进简历。面试官如果追问实现细节你会当场露馅。

但你有两件真实的事可以讲：

1. 你本人就是重度 AI 编码实践者。你写的 WSAPI_MIGRATION.md 结尾明确写着"实现人员：Claude AI"。仓库里 AGENTS.md / CLAUDE.md / back/*/AGENTS.md 的分层规范体系、.github/workflows/scheduled_claude_bug_finder.yml 这个定时 AI Code Review workflow 都是现成的工程实践。
2. 与其编造 AI 业务需求，不如把"AI 辅助研发的方法论"讲成你的差异化。比如：如何用分层 AGENTS.md 约束 AI 在百万行 monorepo 里的输出质量、如何让 AI 处理 166 个交易所这种高度重复但细节各异的适配工作、AI 生成代码的 review 门禁怎么设。这个话题在 2026 年的面试里，比硬凑一个"AI 需求"可信得多。

六、改写后的简历

CAM 加密资产管理平台 · 后端研发（CeFi 组）                        2023.05 - 2026.07

平台服务机构客户的多交易所资产管理，后端为 Go 模块化单体 + 94 个可独立部署进程，
Gin / PostgreSQL / Redis Stream MQ。个人累计提交 1900+，主导三个核心模块。

【模块一】交易所与托管机构统一接入平台（exg / ec，平台注册 255 种账户类型）
- 负责接入层核心抽象设计与演进：Acc（业务编排）/ SC（单次请求）双层模型，
  统一 IAccService 接口（40+ 方法）+ 默认实现基类，新交易所仅需覆写差异方法，
  将单家接入从"全量实现"降为"增量覆写"，累计支撑 160+ 家交易所与托管机构
- 设计多维度限流与熔断体系：按 API key / 账户 / 代理 IP 三维独立计数，
  解析交易所响应头权重实现"预判式限流"（阈值 95% 主动降级），
  替代被动 429 重试，显著降低 IP 封禁与账户风控触发率
- 统一密钥与签名：业务进程不持有 API Key，全部经独立 Auth 服务远程签名，
  支持 HMAC / RSA / Ed25519 多算法与母子（prop）账户签名降级回退

【模块二】交易所实时数据同步链路（exgws，WebSocket 长连接）
- 主导 Binance WebSocket API 鉴权迁移（官方 2025-11-10 停用 listenKey 硬 deadline）：
  设计新旧双路径并存 + 单开关灰度，支持秒级回滚；重构消息分流以区分
  订阅响应、鉴权错误（-2015 自动重连）与业务事件；
  逐仓杠杆由「每 symbol 一条连接」改为「单连接全量订阅」，连接数大幅下降
- 从 0 设计余额变动实时处理器（WS 事件驱动 + REST 补全）：
  两级锁（全局读写锁保护账户表 + 账户级独立锁保护事件队列）消除跨账户锁竞争；
  2 分钟聚合窗口将同账户 N 次事件合并为 1 次 API 查询；信号量限制并发账户数；
  指数退避重试 + 不活跃账户定期回收防止内存无界增长
- 扩展 Coinbase Prime、Panthertrade 等交易所 WS 成交与订单推送接入

【模块三】历史流水与数据治理（historytradev2 / 对账 / 快照修复）
- 负责双通路数据采集架构：实时轮询引擎（120 并发有界请求池 + Redis 进度游标 +
  重叠时间窗防漏）与交易所异步导出管线（申请 → 轮询 → 下载 → 解析 → 入库）
- 设计 13 态任务状态机，状态在 PG / Redis / MQ 三层冗余：
  发版重启自动恢复中断任务、下载 worker 有界队列满时回灌队列防丢任务、
  CSV 按文件序号断点续传、下载链接过期自动刷新重试，实现全链路可恢复
- 存储优化：基于 I/O 与内存监控定位宽表膨胀，引入 blob 压缩（zstd/xz，
  编解码器池化复用）+ 精简热表分离 + 180 天冷数据 S3 归档，
  关键路径性能提升约 40%，存储增长斜率显著下降
- 维护通用数据修复框架与对账引擎（期初快照 + 流水 = 期末快照），
  支持按交易所扩展订正逻辑、幂等重跑与历史快照反算

【其他】Auth 核心表双写平滑迁移与灰度上线；账户状态模型重构并经 MQ 同步下游业务方

改动要点：每个模块先给边界和量级，再给架构决策，最后给结果。并发和高可用从"没有"变成了贯穿全文的主线。

七、三个高频问题的应答骨架

"你负责什么模块，架构是什么样的？" 选模块一。先画三层（Acc / SC / Util）+ 注册表路由，说清楚"我定义接口、160 家交易所实现接口"的关系，然后主动抛出一个设计权衡：为什么新增能力要开独立 interface + 类型断言，而不是往 IAccService 上加方法——因为那个接口有 255 个实现，加一个方法全部编译失败。这个回答能立刻证明你是 owner 而不是使用者。

"有并发场景吗？" 先用第四节的框架重新定义问题，再用 balance_update_processor 展开：两级锁、double-check、聚合窗口、信号量、内存回收。这一个例子足够撑起 15 分钟深挖。

"最有挑战的项目？" 讲 Binance WS 迁移。它同时具备：不可协商的外部 deadline、全量账户受影响的爆炸半径、鉴权协议级改造、灰度与回滚设计、真实踩坑（签名串字段序）、以及意外收益（连接数下降）。这是你手上叙事完整度最高的一个故事。

最后一个提醒：你说"工作了 2 年"，但 git 记录显示你的提交从 2023 年 5 月延续到 2026 年 7 月，跨度 3 年 2 个月（2024 年 2-5 月有一段空档）。如果那段早期提交属于正式工作期，你应该按 3 年写——在简历筛选阶段这是实打实的差别，值得你自己核对一下。

写在开头

我 7月17 号被裁员 ，我的策略是

• 先看一下 邓明的Golang初级开发课程
  • 登陆注册、Feed流、文章模块、支付模块、微服务拆分模块
• 然后补了一下一个 单Agent 的 AI 项目 处理了这两个内容花了我一个月时间，然后我开始投递和准备八股文 。

然后开始投递大概半个月还是1个月时间，或者说面试了2周，9月17号左右到达北京

我只有Golang这个语言栈，导致我能投递的岗位很少，感觉全中国只有 300家。

我投了符合工作经验的 180 家 ，最后约面的 只有 14 家

最终我只拿到了 2 家 或者说 只拿到了一家

一家北京的字节外包，我不确定这个是什么形式的外包。 北京阅安，今年4月份成立的公司。 涨薪40%

一家深圳的Ai公司，但是这家公司比较小。我完成了 CTO面之后，hr面给我鸽了，说是没有HC了. 有些生气，但是也无可奈何 。

xxx，是这样的，坦诚跟你交流， 内部有一个人，总体磨合下来，欠缺了一点。
我收到你短信的时候，我去跟技术口沟通了。
上级还在犹豫，技术口是希望能再给他机会，看看有没有改进的空间。
但是也担心会耽误你，你看这样行不行，您这边也可以再留意一下其他机会。
我们内部也再看下是否要果决一些。

来北京之前

来北京之前呢, 我和我谈了好久的女朋友发生了关系, 她今年还在准备考研时间并不是很多。 我跟她线下见面了好几次

最终发生了关系, 我和她尝试了好多第一次我没尝试过的东西

1. 一起去饭店吃饭
2. 一起在河边散步
3. 一起坐摩天轮
4. 一起吃烧烤
5. 一起亲嘴
6. 一起舌吻
7. 一起住酒店
8. 第一次去KTV
9. 一次喝奶茶
10. 一起吃肉蟹煲
11. 第一次去线下的Switch游玩店
12. 一起骑车
13. 一起拥抱
14. 一起睡觉 ....

说实话我单身了 20多年了，第一次和女孩子做这些内容，我们双方都很喜欢对方，她很信任我，我也很喜欢她

我认为我的后半生都给她了，至少目前是这样的。

虽然不知道是不是上天凑巧，让我在被裁员的时候 她主动加我的联系方式，还是什么 。虽然凑巧 但是也不凑巧

因为她在考研所以我不能打扰她，而且我被裁员了我还要准备我的工作面试 。所以呢 我一个人来到了北京

来到北京

我一个人来到了北京，住在北京海淀区。这里是北京的三环，但是给我的感觉很差，我在北京待了3天，待一天骂一天

首先

1. 地铁。 北京的地铁很多，但是地铁修的并不好，地铁站比较小而且很多
2. 高铁。 北京的高铁站和其他高铁站差不多，而且人很多，我周四下的高铁 人都爆满
3. 住房。 3000块钱只能租到一个合租的地方，如果想要整租需要4000，5000 。我之前在长沙都只要1500啊
4. 吃的。 3环这边全是小区楼没有大的商场，全都是小店铺 也没有地摊，吃的东西都是甜食，人均20+，30+
5. 环境。 健身房死贵，附近没有可以跑步的地方，这里除了胡同就只有胡同。

总之我对北京彻底失望了，我破防了，但是我房租已经交了，其实我来北京那一天我就想过 要不要直接回老家继续面试了，但是没有人理我，我的女朋友没理我，我的群友没理我，我的姐姐没理我。所以我就这么租了

而且北京这里都是押一付3，我怎么都要工作了