← Back to blog WeRide SDE OA Interview Recap on 1point3acres — Autonomous Driving VO Coaching Guide
OA WeRide

WeRide SDE OA Interview Recap on 1point3acres — Autonomous Driving VO Coaching Guide

2026-05-20

WeRide (文远知行) is one of the first Chinese robotaxi operators with a commercial license, and over the last two years its Bay Area office has expanded its SDE / MLE hiring significantly. Recent WeRide threads on 1point3acres show an unmistakable autonomous-driving flavor: sensor fusion, point-cloud clustering, shortest-path planning. This article ranks the question types by frequency and adds a realistic VO coaching / mock-interview plan.

WeRide OA at a Glance

Dimension Detail
Platform CodeSignal / HackerRank (varies by role)
Duration 70-90 minutes
Count 3 problems (1 easy + 2 medium/hard)
Difficulty Mostly LC Medium, occasional Hard
Focus Graphs, simulation, geometry, strings

Question Type 1: Sliding-Window Trimmed Mean (Sensor Denoising)

Problem

LiDAR / IMU streams contain bursty noise. Given a data stream data[] and window size k, output the trimmed mean (drop max and min, then average) for each length-k window.

Idea

Python

from sortedcontainers import SortedList

def trimmed_mean_window(data, k):
    if len(data) < k:
        return []
    sl = SortedList(data[:k])
    window_sum = sum(data[:k])
    res = [(window_sum - sl[0] - sl[-1]) / (k - 2)]

    for i in range(k, len(data)):
        sl.remove(data[i - k])
        window_sum -= data[i - k]
        sl.add(data[i])
        window_sum += data[i]
        res.append((window_sum - sl[0] - sl[-1]) / (k - 2))
    return res

Time O(n log k)　Space O(k)

Question Type 2: HD Map Shortest Path with Battery Constraints

Problem

A robotaxi runs trips on a city graph. Nodes = intersections; edges = roads with cost cost and energy drop. Battery capacity B. Some nodes are chargers (instantly refill). Find the min-cost path from src to dst keeping energy ≥ 0 throughout.

Idea

Python

import heapq

def min_cost_with_battery(graph, n, src, dst, B, chargers):
    # graph[u] = [(v, cost, energy_drop)]
    pq = [(0, src, B)]
    visited = {}
    while pq:
        cost, u, e = heapq.heappop(pq)
        if (u, e) in visited and visited[(u, e)] <= cost:
            continue
        visited[(u, e)] = cost
        if u == dst:
            return cost
        for v, w, drop in graph[u]:
            ne = e - drop
            if ne < 0:
                continue
            if v in chargers:
                ne = B
            heapq.heappush(pq, (cost + w, v, ne))
    return -1

Time O(B · E log(B · V))

Question Type 3: Point-Cloud Connected Components

Problem

A 2D grid with 0/1 occupancy. Return the number of connected components (4-neighborhood). This is LeetCode 200's cousin, except WeRide often asks you to support dynamic add/remove.

Idea

Python (static)

def count_clusters(grid):
    if not grid:
        return 0
    R, C = len(grid), len(grid[0])
    seen = [[False] * C for _ in range(R)]
    cnt = 0
    for i in range(R):
        for j in range(C):
            if grid[i][j] == 1 and not seen[i][j]:
                cnt += 1
                stack = [(i, j)]
                while stack:
                    x, y = stack.pop()
                    if 0 <= x < R and 0 <= y < C and grid[x][y] == 1 and not seen[x][y]:
                        seen[x][y] = True
                        stack.extend([(x+1,y),(x-1,y),(x,y+1),(x,y-1)])
    return cnt

Frequency Table from 1point3acres

Topic Frequency Key technique
Sensor denoising / sliding window ★★★★ SortedList
Shortest path with constraints ★★★★★ Dijkstra + state expansion
Point-cloud / connected components ★★★★ BFS / DSU
Log parsing ★★★ Regex / state machine
Geometry (hull, closest pair) ★★ Divide & conquer

VO Loop and VO Coaching Boundaries

WeRide's North America VO loop typically has 4-5 rounds:

  1. Algorithms: LC Medium-Hard
  2. System design: a subsystem of perception / planning / control
  3. C++ / Python depth: memory model, move semantics, ROS experience
  4. Behavioral: cross-team collaboration, high-pressure debug
  5. Hiring manager / team fit

oavoservice's combined VO Proxy + VO Coaching package

For WeRide's 4-5 round multi-domain VO (algorithms + system design + C++/ROS + behavioral), oavoservice provides a full bundle:

Reach out on WeChat Coding0201 for the full plan and pricing.

6-Day Sprint

Day Task
D1 Bucket WeRide threads by topic (graph, sliding window, geometry)
D2 Dijkstra / Bellman-Ford / SPFA — 1 each, with state expansion
D3 LeetCode 200 / 695 / 547 + dynamic variants
D4 System design: perception → planning → control pipeline
D5 C++ / ROS refresher; pull out an old project if needed
D6 Behavioral STAR: outage and cross-team stories, 2 each

FAQ

Can I memorize WeRide 1point3acres OA posts directly?

No. About 30% of WeRide problems rotate each batch, but themes (graphs + sliding window + simulation) are stable. Memorize patterns, not statements.

What's the difference between WeRide SDE and MLE OA?

SDE leans toward classic data structures (graphs, strings, stacks/heaps). MLE leans toward ML pipelines, point-cloud processing and light probability. Both usually include one scenario problem with autonomous-driving flavor.

Can I apply to WeRide without autonomous-driving experience?

Yes. WeRide's North America roles mostly evaluate general SDE ability. Domain knowledge can be picked up through KITTI / Apollo / Autoware open-source projects; interviewers care more about whether you can solve novel problems with familiar tools.

Failed the OA — what's the cooldown?

Usually 6 months. Switching tracks (e.g., Infra → Perception) typically resets the cooldown.

Preparing for WeRide SDE OA / VO?

oavoservice tracks WeRide / Cruise / Waymo / Pony.ai OA and VO updates over time. Our mentors come from frontline AV teams and offer question bucketing, timed mocks, system-design debriefs, behavioral recordings as part of VO coaching.

👉 Add WeChat: Coding0201 — get WeRide high-frequency questions + VO coaching.

Contact

Email: [email protected]
Telegram: @OAVOProxy