所有文章

416 partition equal subset sum

dp := make([]bool, target + 1) dp[0] = true

interview-questions2025年9月3日

fundamentals

Redis 是一个**开源的内存数据存储系统**，简单来说，它是一个非常快的数据管理工具。它通常被用作：

redis2025年9月3日

common operations

以下命令操作环境均为 WSL 上的 Ubuntu

redis2025年9月3日

os fundamentals

**Shell**：是一个**命令解释器**，负责将用户输入的命令翻译为系统能够执行的操作，提供了一种与操作系统内核交互的方式，Linux中使用的是**Bash**（Bouren Again Shell，是Bouren Shell的增强版，广泛用于Unix和类Unix操作系统中），Windows中使用的是**PowerShell**

other2025年9月3日

md grammars

[链接名](链接)

other2025年9月3日

computer graphics

A：**帧同步**是指所有客户端在相同时间步长也就是同一帧上同步输入指令或操作，然后每个客户端在本地根据这些输入来运算游戏逻辑，生产相同的状态，比如一个客户端将自己本帧内的操作发送到服务器，服务器在同步时刻将所有玩家的输入打包发送给所有客户端，

UE5

A：

interview-questions2025年9月3日

cpp

A：通过使用 atomic 头文件引入原子变量实现原子操作，保证引用计数同一时刻只能有单个线程操作，从而实现线程安全；一般来说其开销相对不高，基本上是硬件级别的低消耗，但在高并发场景下遇到多个线程对引用计数频繁修改时，可能会遇到瓶颈

interview-questions2025年9月3日

Garbage Collector

go 官方文档：https://tip.golang.org/doc/gc-guide?utm_source=chatgpt.com

GMP model scheduler

Go 语言的轻量级执行单元，你在代码中 `go f()` 启动的就是一个 `G`

switch

在 Go 语言中，`switch` 语句是比传统的 `if–else` 更加简洁、灵活、功能丰富的多分支控制结构

struct

在 Go 语言中，`struct`（结构体）是一种最常用、最基础的复合数据类型，用来**将若干个不同类型或相同类型的字段组合在一起**，形成一个新的整体

slice

`slice` 是对数组的一个**抽象视图**，它不存储数据，而是**指向一个底层数组**，与固定大小的数组不同，`slice` 的长度可以动态改变，这使得它在实际应用中非常灵活

map

在 Go 语言中，`map` 是一种内置的**引用类型**，用来将“键”（`key`）映射到“值”（`value`），本质上是一种**哈希表**

for loop and range

通过不同的写法和变体，`for` 能够完成所有循环需求

defer

作用：让“收尾工作”与逻辑代码紧密绑定，减少因过早 `return` 或中途出错而忘记清理资源的风险

context

官方文档：https://pkg.go.dev/context

channel

在 Go 语言里，`channel`（通道）是核心的并发原语之一，用于在不同的 `goroutine` 之间安全地传递数据

common operations

`go env -w GOPROXY=https://goproxy.cn,direct`

common concepts

GORM（全称「Go Object Relational Mapping」）是 Go 语言最常用的 ORM 框架之一，它能够让我们使用 Go 语言的结构体来映射数据库中的表、字段等，从而更方便地进行数据库的增删改查操作

fundamentals

Ubuntu 会自带 git

git2025年9月3日

common operations

需要注意的是GitHub默认上传的文件不能大于100M，如果比这个大就会上传失败，需要使用一些别的方法，比如gitignore什么的（但我是直接不传那么大的了哈哈哈，所以别的方法具体我也没试过）

git2025年9月3日

common instructions

sudo apt update sudo apt install code sudo apt install code-insiders （如果code命令不可用就用这个）

Linux2025年9月3日

epoll and multiplexing I O

文件描述符（fd）是一个非负整数，用于**标识和访问操作系统中的资源**（如文件、网络连接、设备等）。**每个进程都有一个文件描述符表，进程可以通过文件描述符来操作这些资源**。

Linux2025年9月3日

file pkg management tools

`apt` 是较新的工具，可以看作是 `apt-get` 的升级版，输出信息会更直观易读，下载速度也会更快，在现代 Linux 系统中是首选命令

Linux2025年9月3日

muduo

one loop per thread的含义： one loop per thread是muduo的一个设计理念，即每个EventLoop只在它所属的单独线程中运行。这意味着同一个EventLoop的所有操作都在同一个线程中完成，从而简化了并发问题，不需要锁来保护EventLoop本身的数据结构。主线程（main reactor）只处理新连接事件，然后分发

back-end2025年9月3日

array

示例：

list

它实现了**双向链表**（Doubly Linked List）的数据结构

map multimap unordered map

也是一种关联式容器，有没有multi的机制也跟set相同。

pair

通常用法为 `std::pair<T1, T2>`，其中 `T1` 和 `T2` 表示两个不同的数据类型

set multiset

是一种关联式容器，set不允许容器中有重复的元素，即使调用插入不会报错，但实际并不会被插入，但multiset允许存在重复的元素。

test your skills

通过vector和deque容器，实现对于五个人的随机打分（**共十位评委**），在去掉一个最高分和一个最低分后，得出每个人最终的平均分，并打印输出

vector

与传统的数组不同，vector 的大小可以**动态调整**，能够根据需要自动扩展或缩小

common operations

function's pointer

它保存了函数的地址，并允许**通过指针来调用函数**

move semantics and lambda

>左值和右值都是表达式的属性，通常出现在表达式的左侧和右侧 > >左值：表示**对象的身份**，如变量、函数名 > >右值：表示**对象的值**，如代数运算表达式、匿名的lambda表达式（临时对象）

异常处理（待细分）

异常安全（Exception Safety）：指的是在发生异常时，程序或组件仍能维持良好状态，不会泄漏资源或处于不一致状态。RAII的广泛使用也有助于实现异常安全。当异常抛出时，栈展开会调用对象的析构函数，从而确保资源释放，保证程序不崩溃或资源不遗失。

algorithm

对于不能随机访问的数据结构来说，sort算法是不能使用的，此时应使用该种容器自带的排序算法。

atomic

不可分割性：一个原子操作在执行时被视为一个整体，期间不会被其他操作打断。无论是成功还是失败，整个操作要么全部完成，要么全部不发生。

chrono

functional

它允许你将**任何可调用对象**（如普通函数、lambda表达式、函数指针、成员函数指针等）存储在一个对象中。`std::function`可以接受多种类型的函数，并提供了**统一的调用接口**。

memory

智能指针是封装了原始指针的类，提供了自动内存管理的机制，它们通过 **RAII**（Resource Acquisition Is Initialization，资源获取即初始化）原则，确保资源在不再需要时自动释放，从而避免手动管理内存的复杂性和错误

mutex

互斥锁是

random

相比传统的 `rand()`，这种方式具有：

auto

例如：

constexpr

constexpr 是“constant expression”（常量表达式）的缩写。它用于声明和定义可以在编译时求值的变量和函数。这意味着这些变量和函数的值在编译阶段就已确定，不需要在运行时计算，从而提高了程序的性能和效率。

explicit

在C++中，explicit关键字用于构造函数或者单参函数声明处，以防止编译器进行隐式类型转换。当我们在类的头文件中声明构造函数时，如果希望该构造函数不能被隐式调用（例如不能用ClassName c = value;这种隐式转换方式来构造对象），就需要在声明时加上explicit。

forward

`std::forward` 和其他类似工具（如`std::move`）都在 **`<utility>`** 头文件中，使用时需要包含。

if

// 普通写法： int x = someFunction(); if (x > 0) { // ... }

new

`new int[10]` 会在堆上分配一个大小为 10 的整型数组，并返回一个指向数组第一个元素的指针。

`noexcept` 详解

如果函数声明为 `noexcept`，它表示函数内部不会抛出异常。

template

模板是 C++ 提供的**泛型**编程工具，用来**编写通用代码**，通过模板，你可以为不同的数据类型编写通用的算法或类，而无需重复代码

typedef

typedef std::function<void()> Function;

常见算法思想与方法

主要思想是利用两个指针（或称“变量索引”）在数据结构（通常为数组、链表或字符串）上进行遍历

search

它的目标是**快速定位一个目标元素在数组中的位置**，基本前提是数组必须已经排序，否则二分查找无法正确地工作

sort

在一个待排序序列里，元素往往不仅有用来比较大小的“关键字”，还附带其他属性，例如一组学生记录按成绩排序，成绩相同的同学原本在名单中的先后顺序就体现了他们在班级花名册中的位置

time and space complexity

换句话说，时间复杂度告诉我们一个算法运行多少步（或基本操作次数）随着问题规模 n 变化的**趋势**

array

* **连续内存存储**：数组在内存中占用一块**连续**区域，每个元素的存储位置可以通过起始地址加上偏移量计算得到 * 所以我们不能单独删除数组中的某个元素，只能**覆盖**，也就是**移动其他元素的地址** * **下标**：数组的下标是**从0**开始的 * **固定大小**：在大多数**静态数组**实现中（如 C 语言的数组、C++ 中的传统数组

binary tree

它的**基本特性**包括：

hash table

需要将 `key` 映射到 `[0, N)` 的整数范围，其中 `N` 是哈希表的桶（bucket）数量

linked list

主要类型有：

stack and queue

int main() { std::stack<int> st; // 底层默认是 deque<int> st.push(10); // 压入元素 st.push(20); std::cout << "栈顶元素: " << st.top() << "\n"; // 20 st.pop(); // 弹出 20 std::cout << "弹出后栈顶: " <<

string

从最底层来看，字符串其实就是**一段有序的字符序列**（在计算机中通常用字节序列或 Unicode 码点序列来表示），并且会以某种方式标明“结束”或“长度”

209 min len sub array

class Solution { public: int minSubArrayLen(int target, vector<int>& nums) { int slow = 0; int sum = 0; int results = INT_MAX; //宏 int length = 0;

26 delete reduplicative elements in a sorted array

class Solution { public: int removeDuplicates(vector<int>& nums) { int slow = 0; //没有修改初始值，导致数组索引越界 for (int fast = 0; fast < nums.size(); fast++) //没有修改初始值，导致数组索引越界 { if (nums[fas

27 delete elements

class Solution { public: int removeElement(vector<int>& nums, int val) { int slow = 0; //创建慢指针 for (int fast = 0; fast < nums.size(); fast++) { if (nums[fast] != val) //快指针先遍历 { nu

283 remove zero

class Solution { public: void moveZeroes(vector<int>& nums) { int slow = 0; for (int fast = 0; fast < nums.size(); fast++) { if (nums[fast] != 0) { swap(nums[slow], nums[fast]); //

34 find the first and last position of elements in a sorted array

class Solution { public: vector<int> searchRange(vector<int>& nums, int target) { int Left = findLeftBoundary(nums, target); int Right = findRightBoundary(nums, target); if (Left =

35 search insert location

class Solution { public: int searchInsert(vector<int>& nums, int target) { int left = 0; //和上一题代码基本没有什么大变化 int right = nums.size() - 1; while (left <= right) { //为了防止int越界，先计算左右边界的

367 valid perfect square numbers

class Solution { public: bool isPerfectSquare(int num) { int square = 0; if (num < 2) { square = num; } int left = 1; int right = num / 2; while (left <= right) { int mid = left +

59. spiral matrix ii

class Solution { public: vector<vector<int>> generateMatrix(int n) { // 初始化一个二维数组，这里是嵌套的，仔细分析即可弄清楚逻辑 // 有 n 行个 vector，每个 vector 有 n 列，每列都初始化为 0 vector<vector<int>> matrix(n, vector

69 x's square root

class Solution { public: int mySqrt(int x) { if (x < 2) //此时无论什么数都会直接返回1 { return x; } int left = 1; //防止出现0在分母 int right = x / 2; //提前缩小范围，提升效率 int result = 0; while (left <= righ

704 binary search

class Solution { public: int search(vector<int>& nums, int target) { int left = 0; int right = nums.size() - 1; //通过vector自带的size函数得到数组终点位置 while(left <= right) { // (right - left)

977 square of a sorted array

class Solution { public: vector<int> sortedSquares(vector<int>& nums) { int i = 0; while (i < nums.size()) { nums[i] = nums[i] * nums[i]; //溢出越界了 } int right = 0, left = 1; while (

array reflections

这道题主要是对**二分查找**概念的检验，以及如何在 cpp 中实现二分查找算法，通过将基本想法转化一下可得下面的细分步骤： - 创建 left、right 变量用于记录数组起始和结束位置 * left 初始为 0 * right 初始为数组长度减一 - 利用 while 循环，仅当 **left <= right** 时才进入 * 这里考虑使用左闭右闭区间

131 palindrome partitioning

func backtrack(s string, results *[][]string, path []string, start int) { if start == len(s) { temp := make([]string, len(path)) copy(temp, path) *results = append(*results, temp)

17 letter combinations of a phone number

mapping := map[byte]string{ '2': "abc", '3': "def", '4': "ghi", '5': "jkl", '6': "mno", '7': "pqrs", '8': "tuv", '9': "wxyz", }

216 combination sum iii

return results }

332 reconstruct itinerary

```

37 sudoku solver

```

39 combination sum

func combinationSum(candidates []int, target int) [][]int { sort.Ints(candidates)

40 combination sum ii

func combinationSum2(candidates []int, target int) [][]int { sort.Ints(candidates)

46 permutations

func backtrack(nums, path []int, res *[][]int, used []bool) { if len(path) == len(nums) { temp := make([]int, len(path)) copy(temp, path) *res = append(*res, temp) }

47 permutations ii

func permuteUnique(nums []int) [][]int { sort.Ints(nums) var res [][]int var path []int used := make([]bool, len(nums)) backtrack(nums, path, &res, used) return res }

491 non decreasing subsequences

func backtrack(nums, path []int, res *[][]int, start int) { if len(path) >= 2 { temp := make([]int, len(path)) copy(temp, path) *res = append(*res, temp) }

51 n queens

```

77 combinations

return results }

78 subsets

func backtrack(nums, path []int, res *[][]int, start int) { temp := make([]int, len(path)) copy(temp, path) *res = append(*res, temp)

90 subsets ii

func subsetsWithDup(nums []int) [][]int { var res [][]int var path []int sort.Ints(nums) backtrack(nums, path, &res, 0) return res }

93 restore ip addresses

func restoreIpAddresses(s string) []string { var results []string var path []string backtrack(&results, path, 0, s) return results }

backtracking reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/backtracking/77-combinations.md)

101 symmetric tree

return isMirror(root.Left, root.Right) }

102 binary tree level order traversal

var results [][]int queue := []*TreeNode{root} // 由于传入的 root 就是指针类型，这里也要用指针类型

104 maximum depth of binary tree

queue := []*TreeNode{root} depth := 0

105.construct binary tree from preorder and inorder traversal

idxMap := make(map[int]int, n) for i, v := range inorder { idxMap[v] = i }

106 construct binary tree from inorder and postorder traversal

idxMap := make(map[int]int, n) for i, v := range inorder { idxMap[v] = i }

107 binary tree level order traversal ii

var results [][]int queue := []*TreeNode{root}

108 convert sorted array to binary search tree

func build(nums []int, l, r int) *TreeNode { if l > r { return nil }

110 balanced binary tree

func checkHeight(node *TreeNode) int { if node == nil { return 0 }

111 minimum depth of binary tree

queue := []*TreeNode{root} depth := 0 levels := 0

112 path sum

remaining := targetSum - root.Val

113 path sum ii

return results }

116 populating next right pointers in each node

func connect(root *Node) *Node { if root == nil { return nil }

117 populating next right pointers in each node ii

func connect(root *Node) *Node { if root == nil { return nil }

144 binary tree preorder traversal

return results } ```

145 binary tree postorder traversal

var results []int results = append(results, postorderTraversal(root.Left)...) results = append(results, postorderTraversal(root.Right)...) results = append(results, root.Val)

199 binary tree right side view

var results []int queue := []*TreeNode{root}

222 count complete tree nodes

count := 0 queue := []*TreeNode{root}

226 invert binary tree

queue := []*TreeNode{root}

235 lowest common ancestor of a binary search tree

func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode { for root != nil { if p.Val < root.Val && q.Val < root.Val { root = root.Left } else if p.Val > root.Val && q.Val > root.

236 lowest common ancestor of a binary tree

l := lowestCommonAncestor(root.Left, p, q) r := lowestCommonAncestor(root.Right, p, q)

257 binary tree paths

import "strconv"

404 sum of left leaves

var sum int

429 n ary tree level order traversal

func levelOrder(root *Node) [][]int { if root == nil { return nil }

450 delete node in a bst

if key < root.Val { root.Left = deleteNode(root.Left, key) return root } if key > root.Val { root.Right = deleteNode(root.Right, key) return root }

501 find mode in binary search tree

func bfs(node *TreeNode, arr *[]int) { if node == nil { return }

513 find bottom left tree value

var v int queue := []*TreeNode{root}

515 find largest value in each tree row

var results []int queue := []*TreeNode{root}

530 minimum absolute difference in bst

import "math"

common operations

npm create vite@latest moonlight-radiance-web -- --template react-ts

front-end2025年9月3日

617 merge two binary trees

if root2 == nil { return root1 }

637 average of levels in binary tree

var results []float64 queue := []*TreeNode{root}

654 maximum binary tree

maxIdx := 0 for i, _ := range nums { if nums[maxIdx] < nums[i] { maxIdx = i } }

669 trim a binary search tree

if root.Val < low { return trimBST(root.Right, low, high) } if root.Val > high { return trimBST(root.Left, low, high) }

700 search in a binary search tree

switch { case root.Val == val: return root case root.Val > val : return searchBST(root.Left, val) default: return searchBST(root.Right, val) } } ```

701 insert into a binary search tree

if root.Val > val { root.Left = insertIntoBST(root.Left, val) } else { root.Right = insertIntoBST(root.Right, val) }

94 binary tree inorder traversal

var results []int results = append(results, inorderTraversal(root.Left)...) results = append(results, root.Val) results = append(results, inorderTraversal(root.Right)...)

98 validate binary search tree

var prev *TreeNode

binary tree reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/binary-tree/144-binary-tree-preorder-traversal.md)

1035 uncrossed lines

for i := 1; i <= n; i++ { pre := 0

1049 last stone weight ii

dp := make([]bool, cap + 1) dp[0] = true for _, w := range stones { if w > cap { continue }

1143 longest common subsequence

for i := 1; i <= n; i++ { pre := 0

115 distinct subsequences

for i := 0; i < len(s); i++ { for j := m; j >= 1; j-- { if s[i] == t[j - 1] { dp[j] += dp[j - 1] } } }

121 best time to buy and sell stock

for i := 1; i < len(prices); i++ { if profit < prices[i] - minPrice { profit = prices[i] - minPrice }

122 best time to buy and sell stock ii

for i := 1; i < len(prices); i++ { preCash, preHold := cash, hold cash = max(preCash, preHold + prices[i]) hold = max(preHold, preCash - prices[i]) }

123 best time to buy and sell stock iii

buy1, sell1 := -prices[0], 0 buy2, sell2 := -prices[0], 0

139 word break

for i := 1; i <= n; i++ { for _, w := range wordDict { lw := len(w) if i >= lw && dp[i - lw] && s[i - lw : i] == w { dp[i] = true } } }

188 best time to buy and sell stock iv

if k >= n / 2 { ans := 0 for i := 1; i < n; i++{ diff := prices[i] - prices[i - 1] if diff > 0 { ans += diff } } return ans }

198 house robber

return pre1 } ```

213 house robber ii

a, b := r(nums[1 :]), r(nums[: n - 1]) if a > b { return a } return b }

279 perfect squares

for i := 1; i <= n; i++ { for j := 1; j * j <= i; j++ { if dp[i] > dp[i - j * j] + 1 { dp[i] = dp[i - j * j] + 1 } } }

300 longest increasing subsequence

dp, ans := make([]int, n), 0

309 best time to buy and sell stock with cooldown

hold, sold, rest := -prices[0], -prices[0], 0

322 coin change

for _, c := range coins { for j := c; j <= amount; j++ { if dp[j] > dp[j - c] + 1 { dp[j] = dp[j - c] + 1 } } }

337 house robber iii

func dfs(node *TreeNode) (notTake, take int) { if node == nil { return 0, 0 }

343 integer break

for i := 2; i <= n; i++ { max := 0 for j := 1; j < i; j++ { if max < j * (i - j) { max = j * (i - j) } if max < j * dp[i - j] { max = j * dp[i - j] } } dp[i] = max }

377 combination sum iv

for j := 1; j <= target; j++ { for _, n := range nums { if j >= n { dp[j] += dp[j - n] } } }

392 is subsequence

return i == len(s) } ```

fundamentals

它并不是编程性质的语言，所以相对来说上手会很快（即使没有学过cpp之类的），它更多的还是跟CSS和JavaScript一起对整个网页进行排版、布局和美化

front-end2025年9月3日

474 ones and zeroes

for _, s := range strs { zeros, ones := 0, 0 for _, ch := range s{ if ch == '0' { zeros++ } else { ones++ } }

494 target sum

if (target + s) % 2 != 0 || abs(target) > s { return 0 } p := (target + s) / 2 dp := make([]int, p + 1) dp[0] = 1

509 fibonacci number

a, b := 0, 1 for i := 2; i <= n; i++ { a, b = b, a + b } return b } ```

518 coin change ii

for _, c := range coins { for j := c; j <= amount; j++{ dp[j] += dp[j - c] } }

53 maximum subarray

if currSum > maxSum { maxSum = currSum } } return maxSum } ```

583 delete operation for two strings

for i := 1; i <= n; i++ { pre := 0

62 unique paths

for i := 1; i < m; i++ { for j := 1; j < n; j++ { dp[i][j] = dp[i - 1][j] + dp[i][j - 1] } }

63 unique paths ii

for i := 1; i < m; i++ { if obstacleGrid[i][0] == 0 && dp[i - 1][0] == 1 { dp[i][0] = 1 } } for j := 1; j < n; j++ { if obstacleGrid[0][j] == 0 && dp[0][j - 1] == 1{ dp[0][j] = 1 }

647 palindromic substrings

for i := 0; i < n; i++ { t[i] = s[n - 1 - i] }

674 longest continuous increasing subsequence

return ans } ```

70 climbing stairs

a, b := 1, 2 for i := 3; i <= n; i++ { a, b = b, a+ b }

714 best time to buy and sell stock with transaction fee

cash, hold := 0, -prices[0] for i := 1; i < n; i++{ newCash, newHold := cash, hold

718 maximum length of repeated subarray

for i := 1; i <= n; i++ { for j := m; j >= 1; j-- { if nums1[i - 1] == nums2[j - 1] { dp[j] = dp[j - 1] + 1

72 edit distance

// 空串 -> word2[:j]：插 j 次 for j := 0; j <= m; j++ { dp[j] = j }

746 min cost climbing stairs

for i := 2; i < n; i++{ a, b = b, min(a, b) + cost[i] } return min(a, b) }

96 unique binary search trees

for i := 2; i <= n; i++ { total := 0 for j := 1; j <= i; j++ { total += dp[j - 1] * dp[i - j] } dp[i] = total }

dynamic programming reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/dynamic-programming/509-fibonacci-number.md)

1005 maximize sum of array after k negations

func largestSumAfterKNegations(nums []int, k int) int { sort.Ints(nums) for i := 0; i < len(nums) && nums[i] < 0 && k > 0; i++ { nums[i] = -nums[i] k-- } sort.Ints(nums) sum := 0 i

122 best time to buy and sell stock ii

return earn } ```

134 gas station

for i := 0; i < len(gas); i++ { gSum += gas[i] cSum += cost[i]

135 candy

sum, right := 0, 1 for i := n - 1; i >= 0; i-- { if i < n - 1 && ratings[i] > ratings[i + 1] { right++ } else { right = 1 }

376 wiggle subsequence

count, prediff := 1, 0 for i := 1; i < len(nums); i++ { diff := nums[i] - nums[i - 1] if (diff > 0 && prediff <= 0) || (diff < 0 && prediff >= 0) { count++ prediff = diff } }

406 queue reconstruction by height

func reconstructQueue(people [][]int) [][]int { sort.Slice(people, func(i, j int) bool { if people[i][0] != people[j][0] { return people[i][0] > people[j][0] } return people[i][1]

435 non overlapping intervals

func eraseOverlapIntervals(intervals [][]int) int { if len(intervals) == 0 { return 0 }

45 jump game ii

end, f, count := 0, 0, 0 for i, v := range nums { if f < i + v { f = i + v }

452 minimum number of arrows to burst balloons

func findMinArrowShots(points [][]int) int { if len(points) == 0 { return 0 }

455 assign cookies

func findContentChildren(g []int, s []int) int { sort.Ints(g) sort.Ints(s)

53 maximum subarray

if currSum > maxSum { maxSum = currSum } } return maxSum } ```

55 jump game

56 merge intervals

func merge(intervals [][]int) [][]int { if len(intervals) == 1 { return intervals }

738 monotone increasing digits

func monotoneIncreasingDigits(n int) int { s := strconv.Itoa(n) digits := []byte(s) mark := len(digits) for i := len(digits) - 1; i > 0; i-- { if digits[i] < digits[i - 1] { digits

763 partition labels

res, start, end := make([]int, 0), 0, 0 for i := 0; i < len(s); i++ { if last[s[i] - 'a'] > end { end = last[s[i] - 'a'] } if i == end { res = append(res, end - start + 1) start =

860 lemonade change

for _, v := range bills { switch v { case 5: five++ case 10: if five == 0 { return false } five-- ten++ case 20: if ten > 0 && five > 0 { ten-- five-- } else if five > 2 { five -=

968 binary tree cameras

var dfs func(node *TreeNode) int dfs = func(node *TreeNode) int { if node == nil { return COVERED }

greedy algorithm reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/greedy-algorithm/455-assign-cookies.md)

1 two sum

```go func twoSum(nums []int, target int) []int { seen := make(map[int]int, len(nums))

1002 find common characters

```go func commonChars(words []string) []string { counts := make([]int, 26)

15 3sum

```go import "sort"

18 4sum

```go import "sort"

202 happy number

```go func isHappy(n int) bool { visited := make(map[int]struct{})

242 valid anagram

```go func isAnagram(s string, t string) bool { counts := make([]int, 26)

349 intersection of two arrays

```go func intersection(nums1 []int, nums2 []int) []int { if len(nums1) > len(nums2) { return intersection(nums2, nums1) }

383 ransom note

```go func canConstruct(ransomNote string, magazine string) bool { if len(magazine) < len(ransomNote) { return false }

454 4sum ii

```go func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int { sum12 := make(map[int]int, len(nums1))

hash table reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/hash-table/242-valid-anagram.md)

1

front-end2025年9月3日

142 linked list cycle ii

```go /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func detectCycle(head *ListNode) *ListNode { fast, slow := head, head

160 intersection of two linked lists

```go /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func getIntersectionNode(headA, headB *ListNode) *ListNode { pA, pB := hea

19 remove nth node from end of list

```go /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func removeNthFromEnd(head *ListNode, n int) *ListNode { dummy := &ListNod

203 remove linked list elements

```cpp /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {

206 reverse linked list

```go /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func reverseList(head *ListNode) *ListNode { cur := head var pre *ListNode

24 swap nodes in pairs

```go /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */

707 design linked list

```cpp class MyLinkedList { private: class MyNode { public: int val; MyNode* next;

linked list reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/linked-list/203-remove-linked-list-elements.md)

42 trapping rain water

l, r := 0, n - 1 lM, rM := 0, 0 water := 0

496 next greater element i

for _, x := range nums2 { for len(stack) > 0 && x > stack[len(stack) - 1] { v := stack[len(stack) - 1] stack = stack[: len(stack) - 1] next[v] = x } stack = append(stack, x) } for

503 next greater element ii

for i := 0; i < n; i++ { ans[i] = -1 }

739 daily temperatures

for i := 0; i < n; i++ { for len(stack) > 0 && temperatures[i] > temperatures[stack[len(stack) - 1]] { j := stack[len(stack) - 1] stack = stack[: len(stack) - 1] ans[j] = i - j } s

84 largest rectangle in histogram

st := []int{} max := 0

monotonic stack reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/monotonic-stack/739-daily-temperatures.md)

1047 remove all adjacent duplicates in string

for i := 0; i < len(s); i++ { v := s[i]

150 evaluate reverse polish notation

func evalRPN(tokens []string) int { stack := make([]int, 0, len(tokens))

20 valid parentheses

if length % 2 == 1 { return false }

225 implement stack using queues

func (q *myQueue) Push(v int) { q.data = append(q.data, v) }

232 implement queue using stacks

func (s *myStack) Push(val int) { s.data = append(s.data, val) }

239 sliding window maximum

dq := make([]int, 0, k) results := make([]int, 0, length - k + 1)

347 top k frequent elements

for _, v := range nums { freq[v]++ }

stack and queue reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/stack-and-queue/232-implement-queue-using-stacks.md)

fundamentals

Elasticsearch是一个**搜索和分析工具**，基于Lucene（一个搜索库）开发。它特别适合：

elasticsearch2025年9月3日

28 find the index of the first occurrence in a string

if m == 0 { return 0 } if n < m { return -1 }

344 reverse string

```go func reverseString(s []byte) { left, right := 0, len(s) - 1

459 repeated substring pattern

if length < 2 { return false }

541 reverse string ii

```go func reverse(ch []byte) { left, right := 0, len(ch) - 1

844 compare strings having backspace

错误代码1：

string reflections

[我的解答](https://github.com/EthanQC/my-learning-record/blob/main/data-structure-and-algorithm/problems-record/string/344-reverse-string.md)

common operations

* 安装 Java（Elasticsearch 是基于 Java 的）：`sudo apt install openjdk-11-jre` * 检查是否成功安装 Java：`java -version` * 导入公钥并安装 APT 仓库：

elasticsearch2025年9月3日

FAQ

MySQL 在登录时会根据用户的不同而有不同的权限限制，比如 root 用户可能被限制**只能通过 sudo 方式登录**

database2025年9月3日

common operations

创建一个用户表：

database2025年9月3日

factory

using namespace std;

design-mod2025年9月3日

single instance

using namespace std;

design-mod2025年9月3日

2025.8.23

是时候复盘一下最近的情况了

碎碎念2025年8月23日

2025.8.21

好久没有写点什么了

碎碎念2025年8月21日

2025.7.31

从老家回来了

碎碎念2025年8月1日

2025.7.17

周一就从沈阳回来了，想写点自己对于这座城市的感受

碎碎念2025年7月17日

2025.7.16

从沈阳回来啦

碎碎念2025年7月16日

2025.7.9

好久不见！

碎碎念2025年7月9日

2025.5.30

终于辞职了！

碎碎念2025年5月27日

2025.5.7

五一我是放飞自我地玩了五天，所以这周刚好相当于过渡，恢复一下正常的学习生活节奏，刚好也做做心理准备什么的

碎碎念2025年5月6日

Back End Daily Internship First Round Experience

A：好的，面试官您好，我是来自深圳大学 27 届的某某，我目前是大二在读，然后我是在一家主营业务是海外网文平台的公司做后端开发岗位的实习生，我主要是负责公司的几个代码仓的维护和开发一些新接口

面经2025年4月26日

How To Prepare For An Interview

* **简历上自己写的东西一定要非常熟悉**，面试官问了不能答不出来也不要含糊不清 * 面经具有多样性，仅供参考，重心还是要自己的基础扎实，再去看别人的面经 * 可以用 ai 模拟面试

面经2025年4月10日

IEG Timi Game Client Development Daily Internship First Round Failure

A：面试官您好，我是来自深圳大学电子信息工程学院的大二学生xxx，我目前是在一家小厂的后端开发岗位实习，另外还参加了清华人机交互实验室的水木心育项目的游戏开发实习，是远程的，同时我自己还有一个独立游戏项目正在开发

面经2025年4月9日

2025.4.13

上周回家了

碎碎念2025年4月7日

2025.4.7

公司搬到了我小学和初中旁边

碎碎念2025年4月7日

2025.3.31

我真是没救了

碎碎念2025年3月31日

2025.3.30

周末降温了

碎碎念2025年3月30日

2025.3.23

幸福的上午

碎碎念2025年3月24日

2025.3.22

这周的心情挺奇怪的

碎碎念2025年3月22日

2025.3.17

e宝，e宝

碎碎念2025年3月18日

2025.3.18

坐我旁边的前端实习生的 mentor 经常带着口罩，坐在工位上也带

碎碎念2025年3月18日

2025.3.16

感觉自己最近的阅读量好大

碎碎念2025年3月15日

2025.3.9

要学的 * cpp ⭐⭐⭐⭐ * 现代 cpp 特性复习，包括智能指针、Lambda 表达式、移动语义、性能分析、内存优化、原子操作、并发与多线程编程等 * 熟悉封装、继承、多态等 OOP 特性以及 STL 常用容器（如 vector、map、set） * 考虑要不要看底层实现，尽量把这些东西都用到项目中 * go ⭐⭐⭐⭐ * map， struct， s

碎碎念2025年3月9日

2025.3.4

深圳其实哪都挺好的，就是有三点我一直很讨厌

碎碎念2025年3月4日

2025.3.3

三月快乐

碎碎念2025年3月3日

2025.2.28

终于！周五了！！

碎碎念2025年2月28日

2025.2.27

又是无聊的一天

碎碎念2025年2月27日

2025.2.26

让自己意识到自己其实不喜欢给别人敲代码

碎碎念2025年2月26日

2025.2.25

随着上班的进行，虽然只是第二天，但我已经熟练掌握了一些摸鱼的技巧

碎碎念2025年2月25日

2025.2.24

今天是我上班的第一天

碎碎念2025年2月24日

2025.2.23

寒假要结束啦，明天就开学了

碎碎念2025年2月22日

2025.2.18

今天收到了密纸科技，就是我之前说线下面试然后面试官人很好的那家创业小厂，的实习生offer

碎碎念2025年2月18日

2025.2.15

我又来啦，最近做了挺多事情的，心情和状态也起起伏伏，但总体还是在慢慢走向正轨的

碎碎念2025年2月15日

2025.2.11

抱歉啊啊啊啊，又这么久没更新

碎碎念2025年2月11日

2025.2.3

新年快乐！！最近在过年所以没有写也没有更新这个仓库，整体来说这个年过得还是很开心的~ 红包收了不少，好吃的也吃了不少，哈哈哈哈哈哈哈哈哈哈

碎碎念2025年2月3日

Information

开源2025年1月26日

2025.1.26

好几天没写了啊啊

碎碎念2025年1月26日

2025.1.22

今天总算把昨天的内容弄完了啊啊啊，搞的我昨天都忘记写这个了

碎碎念2025年1月22日

2024.10.29

今晚啃的是C++ primer plus，之前是就看过前面一点的，所以现在是到了第三章，然后下午是在啃计网，目前到第四章，还没开始看第四章网络层的内容

2024.11.7

昨晚半夜十二点突发奇想，跟舍友一起去吃海底捞，回到宿舍睡觉已经是三点多了，然后今天早上十点又去上课，在课上复习大物，下午是大物实验，做完实验就去买了杯瑞幸，因为中午也没来得及睡觉

2024.11.5

今天上午和中午把昨天剩的两道题同步完了，然后下午去上计网，在课上把第四章啃完啦，开心！！哈哈哈哈哈哈，今天下午效率还不错，我甚至还想继续看第五章，感觉计网还是很有意思的，只是有些知识确实有点晦涩而且描述的也很抽象，然后有点难记住，所以我是准备这周之后吧（或者周天期中考完），就开始看计网的八股并同步记录，本来是想看计网书上每章对应的复习题来准备的，但貌似不如直

2024.11.4

今天效率比较慢，主要还是因为！早八！啊啊啊啊啊啊啊！！！

2024.11.27 28

关于tennis项目，准备是有空的话再抽时间去看一下安卓端的代码，然后慢慢学，目前不准备把重心放这个上面啦，因为本身这个项目重点也偏算法，更何况他们已经用Java重写了一遍，这就导致跟我的方向和技术栈完全不匹配了，但我也不会直接退出，还是会看他们后面需要人做什么，然后我再做一些力所能及的事情吧

2025.1.17

终于想起来这个仓库了，从7号考完期末之后就一直玩到现在，满打满算竟然刚好十天，也确实该恢复学习的节奏了

碎碎念2025年1月17日

2025.1.20

今天把操作系统目前有的知识都整理好啦，就是epoll、多路复用I/O那些，后面会随着学习进度慢慢扩充的！

Back End Daily Internship Second Round Failure

A：面试官您好，我叫某某，我来自深圳大学，我是 27 届，我的专业是电子信息工程，目前我是在一家主营业务是海外网文平台的公司做后端开发岗位的实习生，我个人目前的技术栈的话，我是学 C++ 出身，然后大概在去年十一月十二月的样子接触到 go 语言，我个人主要是想往后端发展，所以开始用 go 语言写一些项目，然后我目前实习的这个公司他们的项目主要是用 php 来

面经2024年12月8日

IEG LightSpeed Game Client Development Daily Internship First Round Failure

A：面试官您好，我是来自深圳大学 27 届的某某，我的专业是电子信息工程，我目前是大二在读，然后在一家主营业务是海外网文平台的公司做后端开发的实习生，然后我自己也参加了清华大学人机交互实验室的远程实习项目，在里面主要是做心理学和游戏开发相关的东西，然后我自己目前的话也有一个独立游戏正在早期开发阶段，大概情况就是这样

面经2024年12月8日

2024.10.26

今天主要是学习了set和map这两个容器，并敲了一个小练习。

Open Source Events That I'M Trying To Engage

开源2024年12月8日

2025.1.19

今天还在逐步适应和恢复状态中~

2024.12.8

今天另一个重大举动是，决定了webServer项目后续的方向，我是准备采用一种**站在巨人的肩膀上**的方式，对服务器的各个模块进行评估，然后选择当前业界内最好的解决方案，进行学习和使用，包括阅读源码、编写统一接口、微服务什么的，我是感觉只有这样才能真正拯救这个已经烂到不能再烂大街的项目，而且真正写好之后，也能给我自己用来做游戏后端