Xiaohongshu Autumn 2024 Tech Interview Guide: Salary, Questions & Tips

Xiaohongshu Autumn 2024 Recruitment Overview

The official autumn recruitment batch has opened, independent from the early batch, allowing each candidate two application slots; additional opportunities exist via third‑party recruiting platforms. The program targets graduates from September 2023 to August 2026, meaning the 23rd to 26th cohorts can apply, including those who missed the previous campus hiring.

Technical positions this year have increased to 2.5 times the previous year's volume, adding AI innovation and large‑model roles alongside frontend, backend, client, and infrastructure development.

Company poster claims “top‑level compensation, Xiaohongshu is your first choice this year”.

Salary packages: ordinary offer ~400k CNY total, SP offer ~500k CNY total, SSP offer ~700k CNY total (including overtime pay).

The company previously used a “big‑week/small‑week” schedule; after May 1st it switched to a regular double‑week, removing overtime pay and reducing monthly income by roughly 15%.

When choosing between a Xiaohongshu offer and an Alibaba offer, consider the higher salary and equity potential at Xiaohongshu versus Alibaba's brand stability.

Advice 1: Xiaohongshu’s growth is strong, the role is core, overall compensation and equity are attractive; joining can maximize short‑term gains.

Advice 2: Alibaba offers a mature, stable platform with well‑defined processes; both are large‑scale tech firms with comparable advantages.

Technical Interview Questions and Answers

1. How does Redis achieve high performance?

Redis combines in‑memory storage, a single‑threaded event loop, compact data structures, and I/O multiplexing to deliver extreme speed.

Pure memory operations: data resides entirely in RAM, giving read/write speeds orders of magnitude faster than disk.

Single‑threaded model: one main thread handles all requests, avoiding context‑switch overhead; heavy tasks like persistence run in background threads.

Rich, hand‑crafted data structures (e.g., SDS strings, hash tables) are minimal and highly efficient.

I/O multiplexing (epoll) lets the single thread monitor many connections simultaneously.

2. What are the differences between HTTP and RPC?

HTTP is a general‑purpose data‑transfer protocol with a fixed format, while RPC is a specialized remote‑function‑call mechanism offering simpler invocation and better performance for tightly coupled services.

Purpose : HTTP transports any kind of data (web pages, JSON, images); RPC is designed solely for invoking remote functions.

Invocation style : HTTP requires manual construction of URLs, headers, and bodies (e.g., http://xxx/login with {"user":"xxx"}); RPC lets you call a function directly in code (e.g., remoteServer.add(1,2)).

Data format & performance : HTTP carries verbose headers and status codes; RPC can use compact binary protocols, reducing payload size and parsing time.

Underlying technology : HTTP always runs over TCP; RPC can use TCP, HTTP, or other transports, focusing on the remote‑call abstraction.

3. How is user‑mode virtual address space divided?

A process’s virtual address space is a contiguous range split into several segments, each serving a specific purpose.

Code segment: executable binary code.

Data segment: initialized static constants and global variables.

BSS segment: uninitialized static/global variables.

Heap segment: dynamically allocated memory, grows upward.

File‑mapping segment: shared libraries, memory‑mapped files.

Stack segment: local variables and call frames (e.g., int x = 5).

4. What is Go’s GMP model?

Go’s concurrency runtime consists of three components: G (goroutine), M (machine/OS thread), and P (processor). Gs are lightweight tasks, Ms are actual OS threads bound to CPUs, and Ps schedule Gs onto Ms.

G (Goroutine) : lightweight execution unit, few KB of stack, created and destroyed cheaply.

M (Machine) : OS thread that actually runs code; each M is bound to a CPU core.

P (Processor) : scheduler context holding a local run queue of Gs; the number of Ps defaults to the number of CPU cores (adjustable via GOMAXPROCS).

When you call go func(), a new G is placed into a P’s queue; the associated M pulls Gs from the queue, steals from other Ps when idle, and detaches during blocking I/O, enabling efficient user‑level scheduling.

5. Why are coroutines faster than threads?

Coroutines (goroutines, fibers, etc.) have much lower context‑switch and management overhead because they operate entirely in user space.

No kernel involvement : switching only saves a few registers and stack pointers, avoiding costly kernel mode transitions.

Low resource consumption : each coroutine uses a tiny stack (KB) versus megabytes for a thread, allowing many more concurrent units.

Efficient scheduling : the runtime schedules coroutines directly, eliminating complex OS scheduler decisions.

6. What is the size of an empty C++ class?

An empty class occupies 1 byte so that each object has a unique address.

class Empty {};
Empty e1, e2; // addresses differ because each occupies 1 byte

If the class is inherited or contains members/virtual functions, its size grows accordingly.

7. What problems does C++ diamond inheritance cause?

Diamond inheritance leads to data redundancy (the base subobject appears twice) and ambiguity when accessing members, which can be resolved with virtual inheritance.

class A { int x; };
class B : public A {};
class C : public A {};
class D : public B, public C {}; // D has two copies of x

Solution: declare the base class as virtual during inheritance so only one shared subobject exists.

8. What are typical use cases for static variables in C++?

Static variables have program‑lifetime storage but limited visibility.

File‑scope static (global) : limits visibility to the current translation unit, preventing name clashes.

Function‑scope static : initialized once on first call, retains value across calls; useful for call counters, singletons, or reusable buffers.

Class static members : shared by all instances; used for instance counters, constant configuration, or shared resources.

Uninitialized global static variables are placed in the BSS segment and are zero‑initialized by the runtime.

// file1.cpp
static int uninit; // zero‑initialized, visible only in file1

// file2.cpp
static int uninit; // separate zero‑initialized variable, independent of file1

9. What information does a core‑dump stack contain?

A core‑dump stack records the program state at the moment of a crash, helping locate the fault.

Function call chain (e.g., C → B → A).

Memory addresses of each function (e.g., 0x400520).

Parameters and local variables of each frame.

Stack pointer position, indicating stack usage and possible overflow.

10. Algorithm practice

Find the median of two sorted arrays in O(log(m + n)) time.