首页 on Ruoke Zhang

Kubernetes 基础

Thu, 29 Oct 2026 00:00:00 +0000

Kubernetes（K8s）用于编排容器化应用。一个集群由 Control Plane 和多个 Worker Node 组成：Control Plane 维护集群的期望状态，Worker Node 负责运行实际工作负载。

Reinforcement Learning

Thu, 29 Oct 2026 00:00:00 +0000

AI 整理笔记： 本文由 AI 根据学习过程中的问题辅助整理，并非作者逐字手写。

Optimal Policy 与 Optimal Q-function

Let $\pi^*$ denote an optimal policy, i.e. any policy $\pi^*$ s.t.

$$ Q^{\pi^*}(s,a) \ge Q^\pi(s,a) $$

for every $s \in S$, $a \in A$, and any policy $\pi$.

All optimal policies have the same Q-function, which is called the optimal Q-function and denoted $Q^*$.

Hindsight Experience Replay (HER)

Thu, 22 Oct 2026 00:00:00 +0000

AI 整理笔记： 本文由 AI 根据学习过程中的问题辅助整理，并非作者逐字手写。

30 秒结论

HER 的核心不是修改已经执行过的动作，而是修改观察这段轨迹时所使用的目标：即使 Agent 没有完成原目标，也可以把它实际达到的状态当作替代目标，重新计算奖励，从失败轨迹中构造出有学习信号的经验。

Learning from Hindsight for VLA Reinforcement Learning

Thu, 22 Oct 2026 00:00:00 +0000

研究问题

Learning from Hindsight

Rollout Relabeling

每轮训练开始时，初始化原始数据 Batch、Hindsight Batch 和旧策略：

$$ \mathcal B\leftarrow\varnothing, \qquad \widetilde{\mathcal B}\leftarrow\varnothing, \qquad \pi_{\theta_{\mathrm{old}}}\leftarrow\pi_\theta. $$

之后按以下流程收集并重标记数据：

从任务分布中采样指令 $g$，使用旧策略采集包含 $K$ 条轨迹的 Group：

文生图系统设计

Sun, 31 May 2026 00:00:00 +0000

https://medium.com/pinterest-engineering/building-pinterest-canvas-a-text-to-image-foundation-model-aa34965e84d9

https://arxiv.org/abs/2603.06453?utm_source=chatgpt.com

https://github.com/junfanz1/Awesome-AI-Review/blob/main/System%20Design/GenAI%20System%20Design.md#5-text-to-image

Pinterest Canvas

Text-To-Image

generate images conditioned on both text prompts and reference images

1. text-to-image

Inference
1. 对Text prompt做embedding, 得到text embedding
2. noisy target latent和text embedding一起送进DiT，得到clean target latent
3. clean target latent经过VAE decoder得到图片
Training
- 训练数据(text prompt, real image)
- 只训DiT。text encoder和VAE都用pretrained, 然后freeze
- real image经过VAE encoder得到real latent。训练时根据real latent去生成x_t

2. multimodal image editing tasks

Stage 2 starts from the trained Stage 1 text-to-image model.

Visual Search

Wed, 27 May 2026 00:00:00 +0000

bytebytego tutorial

dataset

一个query image
(n-1)个negative images
一个positive image, 即和query image最像的image.
positive image在所有images中的index label.

build dataset

human judgement: 人去annotate最像的image
user interaction
- noisy
- sparse: may not have click data available for lots of the images
generate similar images

Offline metrics

Mean reciprocal rank (MRR)

MRR=1/m * sum(1/rank_i)

Deep Learning

Mon, 25 May 2026 00:00:00 +0000

Neural Network

terminology

比如有10000个sample，batch size为100

epoch: 10000个sample全部经过forward+back prop。每次epoch之后，都要进行shuffle，来确保每次选的batch由不同的sample组成

AI 模型

Sun, 24 May 2026 00:00:00 +0000

CLIP

paper

# image_encoder - ResNet or Vision Transformer
# text_encoder - CBOW or Text Transformer
# I[n, h, w, c] - minibatch of aligned images
# T[n, l] - minibatch of aligned texts
# W_i[d_i, d_e] - learned proj of image to embed
# W_t[d_t, d_e] - learned proj of text to embed
# t - learned temperature parameter
# extract feature representations of each modality
I_f = image_encoder(I) #[n, d_i]
T_f = text_encoder(T) #[n, d_t]
# joint multimodal embedding [n, d_e]
I_e = l2_normalize(np.dot(I_f, W_i), axis=1) #[n, d_e]
T_e = l2_normalize(np.dot(T_f, W_t), axis=1) #[n, n]
# scaled pairwise cosine similarities [n, n]
logits = np.dot(I_e, T_e.T) * np.exp(t)
# symmetric loss function
labels = np.arange(n)
loss_i = cross_entropy_loss(logits, labels, axis=1) # image-to-text loss
loss_t = cross_entropy_loss(logits, labels, axis=0) 
loss = (loss_i + loss_t)/2

architecture

image encoder

VisionTransformer

输入：[B,3,H,W]
输出：[B,output_dim]

class VisionTransformer(nn.Module):
    def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int):
        super().__init__()
        self.input_resolution = input_resolution
        self.output_dim = output_dim
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False) #width表示Transformer 里每个 token 的隐藏维度。
        # grid=input_resolution/patch_size
        # 经过conv1变成[B, width, grid, grid]
        scale = width ** -0.5
        self.class_embedding = nn.Parameter(scale * torch.randn(width)) #class token, 一个专门负责“收集整张图信息”的特殊 token
        self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width)) # [(input_resolution//patch_size)2+1, width]
        self.ln_pre = LayerNorm(width)

        self.transformer = Transformer(width, layers, heads)

        self.ln_post = LayerNorm(width)
        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))

    def forward(self, x: torch.Tensor):
        x = self.conv1(x)  # shape = [*, width, grid, grid]
        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
        x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1)  # shape = [*, grid ** 2 + 1, width]
        x = x + self.positional_embedding.to(x.dtype)
        x = self.ln_pre(x)

        x = x.permute(1, 0, 2)  # NLD -> LND
        x = self.transformer(x)
        x = x.permute(1, 0, 2)  # LND -> NLD

        x = self.ln_post(x[:, 0, :])

        if self.proj is not None:
            x = x @ self.proj

        return x

text encoder

embedding space

Computer Vision

Sun, 24 May 2026 00:00:00 +0000

ViT

Funnel ViT

paper

Object Detection

slides

Single Object

label是：Cat + (x’, y’, w’, h')
x, y = box 左上角的位置，w = box 宽度，h = box 高度，这些是人工标注的
CNN把图片变成4096维向量
- classification head：Fully connected，4096 -> 1000，输出1000个类别的分数, 做softmax
- localization head：Fully connected: 4096 -> 4，输出predicted box = (x, y, w, h)，这些是连续值，用L2 loss
- Total Loss = Softmax Loss + L2 Loss

R-CNN

R-CNN uses Selective Search to generate around 2000 region proposals, warps each proposal to a fixed 224×224 image, then runs a CNN on each region to classify it and later refine the box.

ML Basic

Wed, 20 May 2026 00:00:00 +0000

https://github.com/andrewekhalel/MLQuestions https://www.1point3acres.com/bbs/forum.php?mod=viewthread&tid=998257&page=1&extra= https://longxingtan.gitbook.io/mle-interview/02_ml

supervised learning

training data includes both the input features and corresponding target labels

classification

Logistic Regression

linear classification，二分
loss function: Binary Cross-Entropy Loss

logistic regression有closed form 解嘛？

没有闭式解。虽然loss function 是convex的，但求导后得到的是含指数项的非线性方程，无法通过求导令其等于 0，解出 w 和 b 的解析表达式，所以只能用gradient decesent

Dynamo

Thu, 05 Mar 2026 00:00:00 +0000

Dynamo

virtual nodes

compared to basic consistent hashing, each node is assigned to multiple points on the ring
advantages
- If a node becomes unavailable, the load handled by this node is evenly dispersed across the remaining available nodes.
- When a new node is added to the system, the new node accepts a roughly equivalent amount of load from each of the other available nodes.
- The number of virtual nodes that a node is responsible for can be decided based on its capacity, accounting for heterogeneity in the physical infrastructure.
solved consistent hashing’s problems

Distributed Systems

Thu, 08 Jan 2026 00:00:00 +0000

RPC Basic

protobuf IDL

define .proto file，定义Request, Response格式，函数签名

protobuf自动生成CalculatorStub

channel = grpc.insecure_channel("服务端IP:端口")

# 客户端Stub（服务端函数的“本地替身”）
stub = CalculatorStub(channel)

# 调用Stub的Add方法（感觉和调用本地函数一样）
request = AddRequest(num1=2, num2=3)
response = stub.Add(request)

server side实现add的具体逻辑

Semantics

At most once

File System

Mon, 05 Jan 2026 00:00:00 +0000

文件系统

inode

每个文件都有唯一的 inode, 只在当前文件系统唯一

存放的信息有

文件权限（File Permissions）：读（r=read）、写（w=write）、执行（x=execute），示例：rw-r–r–（所有者可读可写，所属组和其他用户仅可读）
文件所有者和所属组（File Owner & Group）：
- 所有者 UID（User ID）
- 所属组 GID（Group ID）
文件大小（File Size）：单位字节（Byte），区分普通文件（存储内容大小）和目录文件（存储目录项的大小）
时间戳（Timestamps）：3 个核心时间属性
- ctime（Change Time）：inode 元数据修改时间（如权限、所有者变更）
- mtime（Modify Time）：文件内容修改时间
- atime（Access Time）：文件内容最后访问时间
数据块指针（Data Block Pointers）：最核心字段，直接或间接指向存储文件内容的数据块物理地址
链接数（Link Count）：指向该 inode 的硬链接数量，默认新建文件时 link count = 1

读取普通文件的流程

Java RPC

Tue, 30 Dec 2025 00:00:00 +0000

RPC和HTTP的区别

RPC has small header overhead, 能灵活定制传输格式
服务发现：服务提供者启动时自动注册，消费者通过注册中心动态发现服务地址
负载均衡：RPC 在客户端实现负载均衡
容错机制：我的项目实现了重试（Retry）、熔断（Circuit Breaker）和限流（Rate Limiting）

Serialization

Kyro

速度快，体积小，只支持序列化和反序列化Java对象，线程不安全

读写分离&分表分库

Wed, 17 Dec 2025 00:00:00 +0000

读写分离

常见架构

一主多从
主主互备 + 多从：两个主库互为主从，解决主库单点故障，读请求仍走从库

实现

在业务和数据库之间加一层代理（MySQL Router），由它把读写请求分发给不同节点
第三方组件（sharding-jdbc）

分库分表

单表的数据达到千万级别以上->分表
单库的 CPU/IO/ 连接数达到上限->分库

路由规则

哈希路由（取模）
范围路由（user_id 1~~100 万→库 0，101~~200 万→库 1）
一致性哈希（把 key 和节点映射到同一个哈希环上，key 顺时针找到第一个节点作为归属节点）

数据迁移

停机迁移：在半夜做
双写：所有写操作同时写入旧存储和新存储，后台异步迁移旧存储中双写前的历史数据到新存储，对比新旧存储的数据，修正不一致的数据

分布式事务

分布式ID（订单ID）。比如“订单库写订单 + 库存库扣库存 + 用户库减余额”涉及到三个库，
本地消息表 + 消息队列
- 在一个 MySQL 单机事务里，同时完成两件事：创建订单+扣库存。一是往order表里面添加order，二是在msg_table里添加“扣库存消息”
- 异步线程扫一遍msg_table，把消息都发给message queue
- 消费者执行跨库操作。如果不成功，MQ会自动重试

Kafka

Sat, 06 Dec 2025 00:00:00 +0000

architecture

同一个topic的partition不会跨cluster
一个broker里面可能含有不同topic的partition
partition在存储上可以被看作为一个可追加的日志文件，每条消息加进去的时候带有一个offset
fault-tolerant: 多个节点故障时，集群仍能持续提供服务且数据不丢失。
- 同一个partition会有多个replica,每个replica要么是leader（只有一个）, 要么是follower
- 同一个broker里面不会有同一个partition的多个replica
- 同一个broker里面会有同一个topic的不同的partition
一群broker中有一个是controller,它不负责消息的传递，只负责选举partition的新leader
Zookeeper: 管理broker的状态

partiton

高并发：多个producer可以向多个partition同时写入
Kafka 只保证在单个 Partition 内消息的顺序性
高可用：多个replica

leader

负责读写
Leader 负责管理 In-Sync Replicas（同步副本集）。它要确保 Follower 能跟上自己的进度，将落后的 Follower 踢出 ISR。
- ISR：如果一个 Follower 在replica.lag.time.max.ms时间内没有发送pull request,它就会被踢出ISR
- ISR存放在zookeeper中，controller broker会查看ISR中的信息，以方便知道每个partition的follwer是否跟上了它们的leader

follower

定期向leader发送pull请求

关于

Sun, 07 Sep 2025 00:00:00 +0000

关于我

我正在从软件工程转向机器学习。

目前感兴趣的方向： Agentic AI
喜欢自学，也喜欢探索新工具。

2025-2027: 华盛顿大学，电子与计算机工程，硕士

2021-2024: 俄亥俄州立大学，数学&计算机，双学位学士

Bit Manipulation

Fri, 05 Sep 2025 00:00:00 +0000

常见操作

x.bit_count()：返回x的二进制表示中，有几个1。也可以理解为，x最少需要用几个2的幂次之和来表示。

脑筋急转弯

2749. 得到整数零需要执行的最少操作数

设x = num1 - k * num2，则问题转化为：能否用k个2的幂次（允许重复）表示x？

Math

Mon, 01 Sep 2025 00:00:00 +0000

运算规则

//：向下取zheng
int(): 向0取整

质数

埃氏筛

比如想找到[2, right]中的所有质数

# 时间复杂度 O(right * log log right)

is_prime = [True]*(right+1)
is_prime[0]=is_prime[1]=False

for i in range(2, isqrt(right)+1):
    if is_prime[i]:
        for j in range(i * i, right+1 i):
            is_prime[j] = False

204. 计数质数

p[i]表示小于等于i的质数数量。从i=2开始，p[i]==0 <=> i是质数。则从ii开始，标记i的倍数为合数（通过令p[ik]=-1来实现）。并且，p[i]被赋值为p[i-1]+1

string

Mon, 18 Aug 2025 00:00:00 +0000

题单

KMP

https://www.zhihu.com/question/21923021/answer/37475572

28. 找出字符串中第一个匹配项的下标

模式串：abababzababab

第一步：一边遍历模式串，一边构造next数组。

next[i]表示字符串s[0:i+1]的前缀和后缀最大的公共长度
初始化j=0，i从1遍历到n-1。j的位置表示，此时s[:j]是公共前后缀
遍历时，如果此时有公共前后缀，不断比较s[i]和s[j]，一旦发现他们不同，则在循环中回退j，直到s[:j]成为公共前后缀。回退到此时的次长公共前后缀，将j移动到next[j-1]即可
再次比较s[i]和s[j]，如果相同，则移动j，并且为next[i]赋值

第二步：比较两个字符串
abeababeabf
abeabf

网络

Sat, 29 Mar 2025 00:00:00 +0000

TCP 可靠传输

TCP 重传

超时重传：设置一个计时器，时间应略长于RTT。如果超时了还没有收到ACK，则立即重传
快速重传：当连续收到三个相同的 ACK 时，立即重传
SACK（选择性确认）：接收方可以告诉发送方接收到了哪几个消息，还缺哪个消息
DSACK（重复确认）：接收方收到两个2，就会用DSACK告诉发送方，它有两个 2，别重传了。只是因为网络延迟问题。

流量控制 & 拥塞控制

流量控制

核心机制：滑动窗口（接收窗口 rwnd）
实现逻辑：接收方通过 ACK 报文通告当前可用缓冲区大小（rwnd），发送方实际发送窗口 = min(拥塞窗口 cwnd, 接收窗口 rwnd)
目的：防止发送方速率超过接收方处理能力，避免接收缓冲区溢出

拥塞控制（基于拥塞窗口 cwnd，单位：MSS）

慢启动阶段

系统设计

Sat, 29 Mar 2025 00:00:00 +0000

CAP

Consistency：所有节点同时看到相同的数据（强一致性）。

Availability: 99.999%的成功率，一年之内只有5分钟系统不可用

Partition Tolerance：系统在网络分区时仍能继续工作。

贪心

Fri, 28 Mar 2025 00:00:00 +0000

灵神题单

300. 最长递增子序列

灵神视频

定义 g[i] 表示长为 i+1 的上升子序列的末尾元素的最小值。

反证法可证明：g是一个严格递增的数组

659. 分割数组为连续子序列

tail[i]用来表示，以i结尾的子序列个数。这样在遇到i+1时，就可以放进去了。

MySQL日志

Wed, 26 Mar 2025 00:00:00 +0000

所有DML操作（INSERT/UPDATE/DELETE）都先在Buffer Pool中完成

redo log

视频讲解实现事务的持久性。redo log先刷盘，脏页再刷盘

Redis面试题整理

Tue, 25 Mar 2025 00:00:00 +0000

Zset

压缩列表

当元素数量 ≤ zset-max-ziplist-entries（默认128）且所有元素长度 ≤ zset-max-ziplist-value（默认64字节）时使用，内存紧凑。

MySQL常见面试题

Mon, 24 Mar 2025 00:00:00 +0000

存储引擎对比

InnoDB中主键索引和数据放在一起，主键索引的B+树里放完整的数据行；MyISAM中索引和数据分开放，B树里存索引值和该行的物理地址
InnoDB 支持 ACID 事务，MyISAM 不支持
InnoDB支持行级锁，MyISAM 不支持

InnoDB的可重复读隔离级别下解决幻读

对于快照读(普通SELECT)：通过MVCC，可重复读隔离级别，在事务第一次查询时创建ReadView

Java后端面试

Wed, 19 Mar 2025 00:00:00 +0000

面经

2025.03.19 小红书日常一面

IO和NIO的区别
JVM内存模型，堆里面具体有哪些东西
手写监听者模式/单例模式
ThreadLocal实现原理，并发安全吗，map里面放什么东西，内存泄露如何排查
get请求里面放什么，参数如何区分
讲一下泛型，泛型类的字节码文件是怎样的。
Spring 注解，RequestBody什么用处
ArrayList如何扩容
虚拟机栈有多大？一个栈帧有多大？
SQL的UPDATE语句的准确写法

2025.03.20 SAP日常二面

two sum, three sum
缓存空值有问题，应选择布隆过滤器
限流
Zookeeper 了解吗（因为我讲 Redisson 的时候提到了）
如果用户名+密码登录，如何保证数据安全。如何加密？RSA？
点评项目中，点赞数量太多怎么办。（大 key问题）

2025.03.20 阿里云暑期一面

前缀树：输入法提示
Redis内部有锁吗
讲讲SETNX
sorted set的底层实现
RDB，AOF的优缺点
分布式锁
登录验证，为什么要把token存在redis里面，还有更好的方法吗？了解Oauth2吗？
ThreadLocal 使用的时候需要注意什么问题？
是先拿锁，再判断库存；还是先在 lua 脚本里面判断库存，再拿锁
有对商户列表做缓存吗？如何解决按照不同的条件排序还能做到缓存？

2025.03.21 PayPal上海 full stack 暑期实习一面

合并排序数组
数字符串里面一共有多少个 palindrome

2025.03.22 月之暗面搜推实习一面

协程
讲讲go reduce这个项目的细节
手写单例模式，除了双重检验锁，还有什么别的方法可以实现吗？懒汉/饿汉。为什么加 volatile，禁止指令重排序，开辟空间，（实例化，分配给该对象）。
Redis的数据结构，为什么不用string而是用hash，我说少一步序列化操作

2025.03.24 SAP日常二面

为什么用Kafka？优点；用的是Confluent Kafka吗？
讲讲对分布式锁的理解，项目代码里面如何实现？我回答MultiLock.

2025.03.25 字节暑期一面

如果某条 SQL 执行太慢，怎么排查，用过什么工具。联表查询：小表驱动大表。
EXPLAIN 会出现一个表格，表格最后有一个 extra column，请介绍
方法区里面有什么？
讲一讲 G1
为什么需要四次挥手？client 最后为什么要 wait？
讲一讲建立HTTPS连接的过程
手撕 48 和 3
MySQL主从复制讲一下
讲一下Spring的AOP，并且除了动态代理的实现，还有什么实现方法？ASM 字节码操作。

2025.03.26 PayPal暑期二面

手写快排
为啥要把用户信息存到ThreadLocal里面去
filter和interceptor的区别
interceptor 和 AOP的区别

2025.03.27 字节暑期二面

合并 k个有序数组
讲讲 redo log
讲讲MySQL锁

2025.03.27 初创团队实习

有用过AWS实现多个服务之间通信吗？

2025.04.01 淘天暑期一面

讲SpringMVC如何处理请求
联合索引最左匹配
线程池

2025.12 TT 一面

拓扑排序：

Java反射&动态代理

Tue, 18 Mar 2025 00:00:00 +0000

反射

反射是Java在运行时动态获取类的信息（如类名、方法、属性、构造方法等）并操作类的能力

API

获取Class对象

String str="test";
Class<?> clazz = String.class;

String str = "test"; 
Class<?> clazz = str.getClass();

Class<?> clazz = Class.forName("java.lang.String");

通过反射创建对象

Class<?> clazz = Class.forName("com.example.User");
Object obj = clazz.getDeclaredConstructor().newInstance();

Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
Object obj = constructor.newInstance("Alice", 25);

获取字段

getDeclaredField(“字段名”)

MySQL锁

Mon, 17 Mar 2025 00:00:00 +0000

全局锁

一般在做全库备份的时候用到。会阻塞写操作，只允许读请求。因此一般选在业务低峰期去做全库备份。

`1`	`flush tables with read lock`

表级锁

表锁

表共享读锁。多个线程能同时获取这个锁，获取锁的线程可以读这个表，但不能写这个表。MyISAM 处理读请求时，会获取该表的表共享读锁。而 InnoDB 默认是行锁，通过 MVCC 来处理读请求。
表独占写锁。只有一个线程能获取这个锁，它可以对表进行写操作。其它任何线程都不可以读这张表。

`1`	`lock tables t_student read;`

触发表锁：ALTER/DROP/TRUNCATE TABLE

高可用

Sat, 15 Mar 2025 00:00:00 +0000

主从复制(master - slave replication)

主要优点：数据备份、读写分离，通常和哨兵模式结合使用。主服务器负责读写请求，从服务器默认只负责读请求。
主节点在执行完写请求之后，将写命令同步到从节点，然后从节点再执行这条命令，保证和主节点的数据一致。

Binary Search

Thu, 13 Mar 2025 00:00:00 +0000

https://leetcode.cn/discuss/post/3579164/ti-dan-er-fen-suan-fa-er-fen-da-an-zui-x-3rqn/

闭区间写法

找该数

class Solution:
    # 标准的二分搜索框架，搜索目标元素的索引，若不存在则返回 -1
    def search(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) - 1

        while left <= right:
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                left = mid + 1
            elif nums[mid] > target:
                right = mid - 1
        return -1

找左边界

def search(self, nums: List[int], target: int) -> int:
    left = 0
    right = len(nums) - 1

    while left <= right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            right=mid-1
        elif nums[mid] < target:
            left = mid + 1
        elif nums[mid] > target:
            right = mid - 1
    return left

左闭右开

找左边界

def left_bound(nums: List[int], target: int) -> int:
    left = 0
    right = len(nums)
    
    while left < right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            right = mid
        elif nums[mid] < target:
            left = mid + 1
        elif nums[mid] > target:
            right = mid

    return left

如果 target 不存在，搜索左侧边界的二分搜索返回的索引是大于 target 的最小索引。

黑马点评登录设计

Thu, 13 Mar 2025 00:00:00 +0000

短信验证码登录

登录界面输入手机号，然后点获取验证码。此时后端首先校验手机号格式是否正确，接着生成一个验证码。把手机号和对应的验证码存入 Redis，设置过期时间为 2 分钟。
登录界面填写验证码，然后点击登录。此时后端对比传过来的手机号和验证码。如果一致，则进行下一步。
如果该用户不存在，则创建用户并且保存用户到数据库。
随机生成token，作为登录令牌；并将 User 对象转成 Hash，以 token 为 key，以 hash为 value，存入 Redis。

校验登录状态

前端携带的请求会带有 token，所有请求都会被RefreshTokenInterceptor拦截。如果没有token直接放行
首先获取请求头中的 token，然后基于token获取redis中存储的用户（一个 Map对象）。
如果用户存在，则将Map对象转换为UserDTO，并且把它存储在ThreadLocal中，并且刷新 token 的有效期。

第二个Interceptor：除了指定的（不需要用户登陆的）路径之外，其它请求路径都会被 LoginInterceptor 拦截，如果此时没有登录，（UserHolder里为空—），则无法处理请求。

图

Thu, 13 Mar 2025 00:00:00 +0000

图题单

网格图题单

Notes

能记忆化搜索->一定是有向无环图

邻接表空间复杂度

空间由两部分构成：

每个节点对应一个邻接列表：$O(V)$
邻接列表中保存边的端点：无向图的每条边存两次，因此是 $O(2E) = O(E)$

总空间复杂度为 $O(V + E)$。

异常、泛型

Thu, 13 Mar 2025 00:00:00 +0000

异常

Throwable

Throwable具有 Exception和 Error 两个子类

Error 类代表严重错误，往往不建议我们在程序中用 catch捕获的，我们只能通过优化代码来优化 Error。当出现 Error 时，JVM 一般会选择终止线程。

Java集合

Tue, 11 Mar 2025 00:00:00 +0000

Collection接口

List

ArrayList

基本内容

可以允许null值
内存是连续的，节省内存空间。
插入时间复杂度：插在队头O(n)因为要把后面的元素都往后移动一位；插在队尾，如果不需要扩容，则是 O（1），如果需要扩容则先需要 O(n)把原来的 ArryList复制一遍，再执行O（1）的插入操作。插在队中间，O(n).
删除时间复杂度：与插入的时间复杂度相对应。
并非线程安全。

底层实现

由动态数组实现，随机访问某个节点，只需要计算它的地址值，因此随机访问O(1). 实现了RandomAccess这一个标识借口。
如果没有指定初始容量，那么默认初始容量为0，第一次添加元素时，容量变成10. 每次动态扩容，容量变成原来的1.5倍。

ArrayList与 Array 的区别

ArrayList可以动态扩容；Array则不行，它的长度是固定的，并且需要在初始化数组的时候就指定长度
ArrayList支持泛型
ArrayList只支持对象，对于基本数据类型则需要使用它们的包装类如Integer, Double。Array支持基本数据类型和对象。

LinkedList

底层实现

双向链表实现。在头部/尾部进行插入/删除的时间复杂度均为O(1)
不支持随机访问。每次访问指定元素的时间复杂度为O(n)
性能不如ArrayList, 在实际开发中基本不会用到。
线程不安全。
允许null值
除了数据之外还要存指针，所以占用空间比LinkedList大。

HashMap

实现原理

哈希表+链表/红黑树实现。解决哈希冲突的方法有 chaining/probing，一般使用chaining.
哈希值如何计算？拿到key的hashcode()。将原 hashcode和hashcode右移16位的值进行异或运算。

`1`	`int hash = (key == null) ? 0 : (key.hashCode()) ^ ((key.hashCode()) >>> 16);`

计算数组下标。hash&(length-1)，相当于hash%length. 二进制运算比取模运算更快。
如果遇到碰撞，就在链表或红黑树中找是否存在该key，如果存在则直接替换值，如果不存在，就加到里面去。链表长度为 8，并且哈希表长度大于64时，升级成红黑树。
红黑树节点数少于6时，变回链表。
初始容量16，负载因子0.75，扩容至原来的两倍。
并非线程安全。扩容的时候可能会造成链表成环。

时间复杂度

理想情况下，HashMap 的插入、删除和查找操作平均时间复杂度都是 O (1)。
如果转成红黑树，操作的时间复杂度会稳定在 O (log n)

Process

Fri, 07 Mar 2025 00:00:00 +0000

进程和线程的区别

进程：操作系统资源分配的最小单位，拥有独立的地址空间、文件描述符等。
线程：CPU 调度的最小单位，共享进程的资源，包括代码段、数据段、堆等。线程不共享栈空间。

PCB

操作系统每创建一个进程，都会创建一个 process control block，里面存储进程的 PID 和信息
process name
procee status(ready/blocked/running)
pc, stack pointer, file descriptors
process对资源(CPU 时间、内存空间）的需求情况

线程模型

UT：用户线程
KT：内核线程

持久化

Fri, 07 Mar 2025 00:00:00 +0000

参考：小林 coding
参考视频

AOF

Append Ony File，是一个文本文件，因此较大。当客户端发起一个写请求时，Redis 主线程首先在内存中执行写操作，接着将这个写命令同步到磁盘中的 AOF 日志中。

Virtualization

Wed, 05 Mar 2025 00:00:00 +0000

参考的技术博客
 OSTEP slides
参考

虚拟内存

虚拟化：每个进程都认为，自己有自己的地址空间，多个进程的地址空间是分开的。

实际上，CPU 拿到这些虚拟的地址，会让它内部的 MMU 把虚拟地址翻译成物理地址，也就是内存中的地址。内存里，每个地址可以存放一个字节。

问题排查

Mon, 03 Mar 2025 00:00:00 +0000

参考视频

内存溢出的原因

一次性申请太多对象->分页查询
内存泄漏：可达但不再使用的对象仍然占用内存->找到并释放这些对象
本身资源不够->jmap -heap [process id]查看堆信息

jmap是一个JDK命令行工具，用来生成heap dump。heap dump叫做堆转储快照，是一个binary file，记录了堆里面所有对象的信息。
或者，添加JVM参数-XX:+HeapDumpOnOutOfMemoryError，当程序发生OOM时，JVM会自动生成heap dump。

Transaction

Sun, 02 Mar 2025 00:00:00 +0000

参考：小林 coding

事务的特性

atomicity: undo log

consistency: 由其他三个特性实现.事务在执行前后，数据库从一个一致性状态转变到另一个一致性状态。

isolation: MVCC/lock.一个事物的执行不影响其它事务的执行

索引

Fri, 28 Feb 2025 00:00:00 +0000

聚簇索引、二级索引

聚簇索引

InnoDB中，每个表都有一个聚簇索引，它决定着数据在磁盘上存储的物理顺序。

如果有 primary key, 即为聚簇索引
如果没有 primary key, 选择一个唯一的非空索引作为聚簇索引
如果还是没有，InnoDB隐式地创建一个自增列作为聚簇索引

B+ Tree

InnoDB在默认情况下，聚簇索引和二级索引都使用 B+ Tree存储。

ThreadLocal&线程池

Thu, 27 Feb 2025 00:00:00 +0000

参考：JavaGuide

ThreadLocal

Thread类里面有一个变量threadLocals，可以视为一个 HashMap，用来存放线程私有的内容。

1
2
3

/* ThreadLocal values pertaining to this thread. This map is maintained
    * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal类里面有一个instance 方法 set,实际上是把内容存在threadLocals里面。key是该ThreadLocal对象自己。

技巧题

Wed, 26 Feb 2025 00:00:00 +0000

31. Next Permutation

考虑最后一个permutation：5-4-3-2-1，全部降序。

从后往前，找第一组升序的nums[i]和nums[i+1], 比如12947653，找到了nums[4]=4.
从后往前，找第一个比nums[i]大的数nums[j]，也就是 5
交换nums[i]和nums[j], 得到 12957643，此时nums[i]后面的数字全都是降序排列
把nums[i]后面的数字按升序排列，得到 12953467

128. Longest Consecutive Sequence

[100,4,200,1,3,2]

Stack&Queue&Heap

Tue, 25 Feb 2025 00:00:00 +0000

灵神题单单调栈

栈

普通栈

636. 函数的独占时间

自己构造调用栈即可。不管当前的 operation 是 start还是end，栈顶都代表当前正在执行的函数

合法括号字符串

32 最长有效括号

“()(())”

用一个数组tmp记录匹配成功的index。遇到(时，把它的 index 加入栈。遇到）时，从栈里pop出一个(，它们两个匹配成功，于是把tmp中它们两个的index上都标记为1.

Array

Sat, 22 Feb 2025 00:00:00 +0000

LC 188

输入: nums = [1,2,3,4,5,6,7], k = 3 输出: [5,6,7,1,2,3,4]

方法一：切片操作；取数组里的后k个元素：nums[-k%n:]

方法二：先反转整体，再反转局部. 反转过程单独实现，不要用切片，因为可能会产生额外空间。

JMM

Fri, 21 Feb 2025 00:00:00 +0000

参考：JavaGuide

并发问题

CPU Cache

Cahce中某个变量的值可能与 Main memory中的值不一致，导致计算出错。

指令级重排

编译器优化重排

JVM, JIT做这件事。对于Java程序，在不改变它的语义的情况下，编译时进行指令重排序，类似g1, g2 optimization的重排。

Sorting

Fri, 21 Feb 2025 00:00:00 +0000

merge sort

LC 148: sort a linked list

快慢指针分成两半，断开中间，分别递归排序，最后升序合并两个链表。边界条件：head==None or head.next==None

LC 23. Merge k Sorted Lists

注意边界情况

quick sort

以数组某个元素（一般选取首元素）为基准数，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。 python模版

Java线程

Tue, 18 Feb 2025 00:00:00 +0000

参考：JavaGuide

线程

线程的实现

一个Java程序作为一个进程，运行时实际上是多线程并发的, main函数就是主线程。每个调用过start()方法，并且还未结束的java.lang.Thread类的实例就是一个线程。Java线程是Java程序的并发执行单位。

Python一些常用操作

Tue, 18 Feb 2025 00:00:00 +0000

intervals.sort(key=lambda p: p[0])

LC 189 [:]切片操作

dict

# 包含初始键值对的字典
filled_dict = {'key1': 'value1', 'key2': 'value2'}

# 使用 dict() 构造函数
constructed_dict = dict(key1='value1', key2='value2')

valueList=list(filled_dict.values())

my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
for key in my_dict.keys():
    print(f"Key: {key}")

LC 49

滑动窗口

Tue, 18 Feb 2025 00:00:00 +0000

reference：灵茶山艾府

定长滑窗

入：下标为i的元素进入窗口，更新相关统计量。如果i<k−1则重复第一步。

更新：更新答案。一般是更新最大值/最小值。

前缀和

Tue, 18 Feb 2025 00:00:00 +0000

前缀和题单

一维前缀和

LC 1749

任意子数组和的绝对值的最大值: 在前缀和数组里面找最小值和最大值，他们的差的绝对值就是答案。

1
2
3

def maxAbsoluteSum(self, nums: List[int]) -> int:
    s = list(accumulate(nums, initial=0))  # nums 的前缀和
    return max(s) - min(s)

2055. 蜡烛之间的盘子

找a或其右边第一个蜡烛
找b或其左边第一个蜡烛
用前缀和，算他们之间的盘子数量

步骤1，2可以用二分，但是会超时
最好是预处理，记录每个位置左边/右边的第一个蜡烛位置

垃圾回收

Mon, 17 Feb 2025 00:00:00 +0000

参考：深入理解Java虚拟机，极致八股文之JVM垃圾回收器G1&ZGC详解

对象已死？

引用计数算法

/**
* testGC()方法执行后，objA和objB会不会被GC呢？
* @author zzm
*/
public class ReferenceCountingGC {
    public Object instance = null;
    private static final int _1MB = 1024 * 1024;
    /**
    * 这个成员属性的唯一意义就是占点内存，以便能在GC日志中看清楚是否有回收过
    */
    private byte[] bigSize = new byte[2 * _1MB];
    public static void testGC() {
    ReferenceCountingGC objA = new ReferenceCountingGC();
    ReferenceCountingGC objB = new ReferenceCountingGC();
    objA.instance = objB;
    objB.instance = objA;
    objA = null;
    objB = null;
    // 假设在这行发生GC，objA和objB是否能被回收？
    System.gc();
    }
}

缺点：这两个对象互相引用，导致他们的 reference counting 始终不能为 0，无法被回收。

动态规划

Wed, 12 Feb 2025 00:00:00 +0000

灵神题单

线性dp

排列型

外层遍历target，内层遍历可用的数字

70. 爬楼梯

这里的1和2也可以无数次被用，并且不同顺序算为不同的答案

lc 377:

排列型：外层target，内层nums

二叉树

Wed, 12 Feb 2025 00:00:00 +0000

灵神题单

自底向上dfs: 后序遍历

对于当前节点root做什么，需要它的子树的信息。

LC 1110，删点成林

LC 1123 公共祖先

dfs函数返回：以root为根的子树的所有叶子的最近公共祖先，还有从叶子结点往上数，到root的深度

回溯

Mon, 10 Feb 2025 00:00:00 +0000

子集型回溯

在一次 dfs函数里面，如果 path 是 mutable 类型, 一定保证path进入函数和出函数时 状态一定不变。不管有多少个分支，每个分支都要考虑这个问题。

如果 path是immutable，如string，它作为参数传递给dfs，这种情况下根本没有在修改它的状态，而是每次新建一个string，传给子节点。因而不需要恢复状态。LC 257.

Linked List

Sun, 09 Feb 2025 00:00:00 +0000

灵神题单

反转链表

def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
    #因为答案的头节点可能会改，所以搞一个dummy
    dummy=ListNode(next=head)
    pre=dummy
    #移动pre, cur到1和2
    for _ in range(left-1):
        pre=pre.next
    cur=pre.next
    #记录一下此时pre
    p0=pre
    #开始反转2到4这一段, 其实就是分别把2到4的next改了
    for _ in range(right-left+1):
        nxt=cur.next
        cur.next=pre
        pre=cur
        cur=nxt
    #新的pre,cur分别是4，5
    #连接 2 和 5
    p0.next.next=cur
    #连接1和4
    p0.next=pre
    return dummy.next

反转链表关注 pre和cur在开始前和结束后的位置，在这一题中，旧pre的next为新的pre，旧cur的 next为新的cur.

Java 8的新特性

Fri, 07 Feb 2025 00:00:00 +0000

Functional Interface

函数式接口的定义是，必须只含有一个abstract method，它可以拥有许多static或default method(包含实现), 但是 abstract method必须只有一个。

达人探店

Fri, 07 Feb 2025 00:00:00 +0000

点赞设计

用Redis的 sorted set, key是当前 post的ID，set里面存点赞用户的 ID，score 为点赞的时间戳。

前端在看帖子详情的时候，后端不仅需要根据帖子id去数据库里拿内容，还要通过redis判断帖子是否被当前用户点过赞。在 Blog里面加一个liked字段，作为结果一并返回给前端。

接口和抽象类

Fri, 07 Feb 2025 00:00:00 +0000

Interface

接口是对行为的抽象。

abstract method, Java 8以前接口只能有抽象方法
default method，提供方法体，Java 8 以后有
static method, 提供方法体，Java 8 以后有，可以通过Interface.method()调用

public interface MyInterface {
    // 抽象方法
    void abstractMethod();

    // 默认方法
    default void defaultMethod() {
        System.out.println("这是接口的默认方法");
        privateHelperMethod();  // 调用私有辅助方法（注意：私有方法是Java 9的特性，这里仅为示例）
    }

    // 静态方法
    static void staticMethod() {
        System.out.println("这是接口的静态方法");
    }

    // 私有辅助方法（Java 9 特性，但为了完整性展示，包含在此）
    private void privateHelperMethod() {
        System.out.println("这是接口的私有辅助方法");
    }
}

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("实现接口的抽象方法");
    }

    // 可以选择覆盖默认方法
    @Override
    public void defaultMethod() {
        System.out.println("覆盖接口的默认方法");
        MyInterface.super.defaultMethod();  // 调用接口的默认方法
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();

        // 调用实现的抽象方法
        myClass.abstractMethod();

        // 调用默认方法
        myClass.defaultMethod();  // 注意这里调用的是覆盖后的版本

        // 调用接口的静态方法
        MyInterface.staticMethod();
    }
}

Abstract Class

抽象类通常作为基类，比如 Person，Animal。因为不同子类的某种方法的 body可能不一样，所以把这些方法作为abstract method放在抽象类中。

Concurrency

Wed, 05 Feb 2025 00:00:00 +0000

目标

Mutual exclusion (e.g., A and B don’t run at same time)，进程的互斥

solved with locks

Ordering (e.g., B runs after A does something)，进程的同步

solved with condition variables OR semaphores

CS 537 Videos 小林coding

锁

可以理解为 Mutex. 它只是一个变量，只有 available/acquired 两种状态，每个线程可以获取/释放它。 Reference: OSTEP-Locks

黑马点评商户缓存

Mon, 03 Feb 2025 00:00:00 +0000

一致性

缓存更新策略

内存淘汰：Redis 内存不足时自动淘汰部分数据，下次请求时更新缓存
超时剔除：给缓存数据添加 TTL 时间，到期后自动删除缓存。下次请求时更新缓存。
主动更新：在修改数据库的同时更新缓存。

缓存数据库一致性

有请求并发到来时，不管是先更新缓存后更新数据库，还是先更新数据库后更新缓存，都可能出现缓存不一致问题。

优惠券秒杀

Sat, 01 Feb 2025 00:00:00 +0000

全局ID生成器: Redis自增

使用数据库自增ID的缺点：

可能会暴露给用户一些信息：用户可能会根据此推断，一天之内销售出了多少张优惠券。
当优惠券太多时，会导致数据库ID过大。但如果为优惠券分表，又会出现许多优惠券共用同一个ID的情况。

//符号位0+时间戳31bit+序列号32bit
public long nextId(String keyPrefix){
    //生成时间戳
    LocalDateTime now=LocalDateTime.now();
    long nowSecond=now.toEpochSecond(ZoneOffset.UTC);
    long timestamp=nowSecond-BEGIN_TIMESTAMP;
    //生成序列号. 每一天下的单使用同一个Key
    String date=now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
    long count=  stringRedisTemplate.opsForValue().increment("icr:"+keyPrefix+":"+date);
    //拼接并返回
    return timestamp<<COUNT_BITS|count;
}

这里的 keyPrefix表示一种object,比如优惠券订单

Redis缓存

Fri, 31 Jan 2025 00:00:00 +0000

Caching Patterns

Redis Doc: How to use Redis for Query Caching

这里有图片！

Cache-Aside (Lazy Loading)

只有我们想查看数据的时候，Redis Cache才有可能被更新。当我们发出一个Query,后端先判断数据是否在Redis Cache里面。如果不在，则查数据库，并且把查到的数据放到Redis Cache里。

JVM Basic

Thu, 30 Jan 2025 00:00:00 +0000

ClassFile

Java文件经过javac编译后，得到.class字节码文件，再放在JVM上面跑。ClassFile是一种结构规范，所有.class文件都应该符合这样的格式。

Nginx

Thu, 30 Jan 2025 00:00:00 +0000

CLI

nginx -V 查看 Nginx配置文件的位置：/opt/homebrew/etc/nginx/nginx.conf

nginx命令启动master进程，nginx分为master进程和worker进程。 master进程负责读取配置文件、管理worker进程；worker进程实际处理HTTP请求。

Session登录

Thu, 30 Jan 2025 00:00:00 +0000

黑马点评登录

第一次请求：获取验证码

    @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginFormDTO, HttpSession session){
        return userService.login(loginFormDTO, session);
    }

后端为其生成随机验证码，并且存入 session

`1`	`session.setAttribute("code", code);`

后端接着把Session ID通过 set cookie返回给前端浏览器。浏览器保存这个 Session ID, 把它存在 cookie 里面。

Java IO

Tue, 28 Jan 2025 00:00:00 +0000

File

Public Static Fields

To let the code run on every system, use these variables.

// depends on the system. On Mac, it is "/"
System.out.println(File.separator);
// On Mac, it's ":", used to separate filenames in a sequence of files given as a path list
System.out.println(File.pathSeparator);

For example, if we want to get a path like “Users/ruoke”, we can create it using

Maven

Tue, 28 Jan 2025 00:00:00 +0000

Basic

Java Version

ruoke@Ruokes-MacBook-Pro ~ % mvn -v
Apache Maven 3.9.6 (bc0240f3c744dd6b6ec2920b3cd08dcc295161ae)
Maven home: /Users/ruoke/Documents/devTools/apache-maven-3.9.6
Java version: 21.0.3, vendor: Oracle Corporation, runtime: /Library/Java/JavaVirtualMachines/jdk-21.jdk/Contents/Home

这个 Java 版本是 Maven 本身运行时使用的 Java 版本

1
2
3

<properties>
    <java.version>1.8</java.version>
</properties>

我项目里的 pom指定该项目的Java编译时版本，会影响maven-compiler-plugin去找哪个版本的JDK；但这里并不指定该项目的运行时版本。可以在Project Structure里面规定哪个版本JDK用来编译文件

Mon, 01 Jan 0001 00:00:00 +0000

视觉/文本/音频，每个模态都产出semantic_emb和spatial_emb

VisualEncoder

离线特征

用 SigLIP2 自带的 preprocess 把图片 resize / crop / normalize
输入分辨率 256，patch size 16。所以一张图会被切成 16 × 16 = 256 个 patch
每个 patch 变成向量
过 Transformer trunk, 得到[B,256,1152]，也就是一张图片有256个patch，每个patch有1152维

在线部分

semantic_emb

AttentionPool

query是一个单独学出来的向量，它去看所有patch tokens, 压缩成每张图片一个1152维度的向量

Mon, 01 Jan 0001 00:00:00 +0000

failure

During a big promotion our model’s TPM (500,000 tokens/min) was exhausted and many highlight requests started failing. My goal was to stabilize the service quickly without just dropping requests. I added a worker-side token bucket (Redis) so a task only calls the model if tokens are available, otherwise it gets delayed and retried later. I also tied autoscaling to token usage and queue length so we automatically add capacity when pressure rises. Within minutes the failure rate fell below 1% and the task queue stopped growing.

Mon, 01 Jan 0001 00:00:00 +0000

Lab 0

Node

一个Node可以有parent和多个child node

field

@VizIgnore @NonNull private final Address address;

private transient Consumer<Triple<Address, Address, Message>> messageAdder;
//模拟网络通信行为
private transient Consumer<Triple<Address, Address[], Message>> batchMessageAdder;
private transient Consumer<Triple<Address, Timer, Pair<Integer, Integer>>> timerAdder;
private transient Consumer<Throwable> throwableCatcher;

public Address(String identifier) {
    this.identifier = identifier;
    this.parentAddress = null;
    this.subIdentifier = null;
    this.fullAddressString = identifier; // 完整地址就是核心标识
}

function

init():

这是节点的入口。如果你需要在节点启动时就发消息（比如 Client 一上来就要 Ping），写在这里。不要在构造函数里发消息。

Mon, 01 Jan 0001 00:00:00 +0000

Lecture

线性

二分类

Perceptron
- weighted sum+activate function: 简单线性决策，可以解决OR/AND
Logistic Regression
- 概率化的线性分类器
- p(y=1|x)=sigmoid(z), z:weighted sum
- loss function: binary cross-entropy
Linear SVM

多分类

Softmax Regression
- 输出层：softmax. 前面的输出，会给每个样本一堆logits,代表它在相应分类的得分，softmax吧这组logits转换为在每个分类的概率

非线性

Multi-layer perceptron (MLP)

multiple linear layers + non-linear activations

Non-parametric / Classical ML

kNN

Naive Bayes

Tree-based Models

Decision Tree

Random Forest

Gradient Boosted Trees (e.g., XGBoost)

Lecture 6

Word Embeddings & X2Vec

Word2Vec

Skip-Gram， semi-supervised
生成训练数据：通过移动窗口扫描句子，生成 (输入词, 目标词) 对
架构：input(one-hot), 1 hidden layer, softmax classifier

Product2Vec (X2Vec)

View Similarity：学习 Substitutability（可替代性/严格相似）
Purchase Similarity：学习 Complementarity（互补性/搭配关系）

BERT

bert base: 12 layers of encoder
[CLS]：放在句首，用于整个句子的分类表示。
[SEP]：放在句尾或两句之间，作为分隔符。

normalization： all lower case
WordPiece Tokenization
add special tokens: [CLS]/[SEP]
Token IDs(BERT vocab)
each token got 3 embeddings，sum them up
- token embedding(get from a huge matrix, size of [Vocab_Size, 768])
- position embedding(get from a matrix, size of [Max_Len, 768])
- segment embedding
got a matrix[token_size*768]
pass the matrix through a 12 Encoder Layers. After that, [CLS] would gather information from the entire sentence

usage

get tokenizer

`1`	`tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")`

get tokens and token_ids

1
2

tokens = tokenizer.tokenize(text)
input_ids = tokenizer.convert_tokens_to_ids(tokens)

get embedding

`1`	`outputs = bert_model(input_ids=input_ids, attention_mask=attention_mask)`

对应第5,6,7步

Mon, 01 Jan 0001 00:00:00 +0000

heap

1. 重构字符串(Roblox)
1. 任务调度器(Roblox, Snowflake)
1. 前K个高频单词(Adobe)
1. 前 K 个高频元素(Adobe, Bloomberg)
1. 最多可以参加的会议数目(Snowflake)
1. 查找和最小的 K 对数字(Linkedin, Google)
1. 最后一块石头的重量(Nvidia)
1. 数据流的中位数(Snowflake)
Merge k Sorted Lists(Bloomberg, Snowflake, Nvidia, Microsoft)
1. 股票价格波动(Google)
1. 会议室 III

prefix sum

1. 乘积小于 K 的子数组(Airbnb)
1. 最大连续1的个数 III(Microsoft, Expedia)
1. 和可被 K 整除的子数组(Expedia)
1. 二维区域和检索 - 矩阵不可变(Snowflake)
Subarray Sum Equals K(Bloomberg)
Product of Array Except Self(Bloomberg, Microsoft)
Meeting Rooms II(Microsoft)

trie

1. 添加与搜索单词 - 数据结构设计(Docusign, LinkedIn, Snowflake, Rubrik, Tiktok)
1. 最长公共前缀(Bloomberg)
1. 最长公共前缀的长度(Databricks)
Implement Trie (Prefix Tree)(Snowflake)
1. 设计内存文件系统(Snowflake)
1. 删除子文件夹(Snowflake, Google)
1. 搜索推荐系统(Docusign, Amazon)
1. 单词搜索 II(Microsoft, Google, Airbnb)

stack

Basic Calculator II(Tesla)
Max Stack(Linkedin)
Nested List Weight Sum II(Linkedin)
Valid Parentheses(Nvidia, Expedia)
1. 逆波兰表达式求值(Microsoft)
1. 基本计算器(Microsoft)
1. 有效的括号(Microsoft)
1. 最长有效括号(Tiktok)
1. 最大矩形(Tiktok)
1. 柱状图中最大的矩形(Microsoft)
1. 简化路径(Snowflake, Tiktok)
1. 去除重复字母(Expedia)
1. 队列中可以看到的人数(Expedia)
1. 使字符串平衡的最小交换次数(Expedia)
1. 子数组范围和(Tiktok)

queue

1. 设计循环队列(Tesla, Cloudflare)
1. 敲击计数器(Snowflake, Cloudflare, Databricks)
1. 绝对差不超过限制的最长连续子数组(Google)

错题集

1. 设计循环队列(Tesla, Cloudflare)

hash

1. 缺失的第一个正数(Tesla)
1. 丢失的数字(Meta, Microsoft, Bloomberg)

sort

1. 数组中的第K个最大元素(Microsoft)

sliding window

1. 最大连续1的个数 III(SAP, Salesforce, LinkedIn, Meta, Google)
1. 替换后的最长重复字符(Adobe, Amazon, Bytedance, Bloomberg)
1. 子串的最大出现次数(Hubspot, Salesforce)
1. 至多包含两个不同字符的最长子串(Ebay, Google, Tiktok)
1. 至多包含 K 个不同字符的最长子串(Microsoft)
1. 乘积小于 K 的子数组(Paypal, Oracle, Salesforce)
1. 最小区间(Lyft, Databricks)
1. 大小为 K 且平均值大于等于阈值的子数组数目(LinkedIn)

Mon, 01 Jan 0001 00:00:00 +0000

300. 最长递增子序列

输出子序列

nums = [10,9,2,5,3,7,101,18]
import bisect
def sol(nums):
    g=[]
    g_idx=[]
    n=len(nums)
    parent=[-1]*n #记录nums[i]在最终答案里的上一个数字的index
    for i, x in enumerate(nums):
        idx=bisect.bisect_left(g, x)
        if idx>0:
            # its has a preceding number
            parent[i]=g_idx[idx-1]
        if idx<len(g):
            g[idx]=x
            g_idx[idx]=i
        else:
            g.append(x)
            g_idx.append(i)
    cur_idx=g_idx[-1]
    res=[]
    while cur_idx!=-1:
        res.append(nums[cur_idx])
        cur_idx=parent[cur_idx]
    return res[::-1]

162. 寻找峰值

DoorDash面经

Mon, 01 Jan 0001 00:00:00 +0000

消息可靠性

生产者->MQ

生产者开启 confirm 模式

channel.confirmSelect(); // 开启Confirm模式
channel.basicPublish(exchange, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
if (!channel.waitForConfirms(5000)) {
    // 消息未确认，重试或记录日志
}

异步确认：发送消息后不阻塞等待 MQ 的 ACK，而是通过回调函数接收 ACK 通知；若回调中发现未确认（如 ACK 失败、超时），将未确认的消息存入本地缓存，定期触发重试，直到收到 ACK 或达到最大重试次数；
同步确认：发送消息后阻塞等待 ACK

MQ

持久化（必做）：设置消息和队列为「持久化模式」（RocketMQ 默认开启），MQ 会将消息和队列信息写入磁盘，即使 MQ 进程宕机、重启，也能从磁盘恢复消息，避免内存中的消息丢失；
集群多副本（进阶，提升可靠性）：搭建 RocketMQ 集群，配置多副本（类似镜像队列），将队列数据同步到集群多个节点，设置节点同步模式（如同步复制）；

MQ->消费者

手动 ACK
- 自动 ACK 的确定：会存在消费者收到，确认之后没消费，消费者挂了，数据丢失
死信队列：当消息多次重试（如3次）仍处理失败（如系统异常），将消息转入「死信队列」，由人工介入排查处理，避免消息无限重试或被丢弃

幂等性

为什么会有重复的消息

生产者没收到 MQ 的 ACK，又发了一次
MQ 没收到消费者的 ACK，又发了一次

解决

数据库唯一索引
Redis SETNX /Lua 脚本查状态改状态

对比Kafka的优势

Consumer 端自带重试机制，当消费消息失败时，RocketMQ 会自动将消息放入重试队列。
当消费消息失败时，RocketMQ 会自动将消息放入重试队列

Mon, 01 Jan 0001 00:00:00 +0000

MLE-Dojo Benchmark

这是什么

MLE-Dojo 是一个面向 LLM machine learning engineering（MLE）agent 的交互式 benchmark / Gym-style 环境。它把真实 Kaggle 竞赛整理成可执行任务，让 agent 不只是回答问题，而是要反复读数据、写代码、运行实验、根据反馈调试，并提交预测结果。