WeRide is a global leader in L4 autonomous driving, headquartered in Guangzhou with R&D centers in Silicon Valley and Beijing. Their SDE OA combines autonomous driving scenarios with classic algorithms, testing candidates' ability to model and code real engineering problems. This guide covers the core question types based on the latest interview experiences.
WeRide OA Overview
| Aspect | Details |
|---|---|
| Platform | HackerRank / Internal Platform |
| Duration | 60-90 minutes |
| Questions | 2-3 coding problems |
| Difficulty | Medium |
| Focus Areas | Graph Algorithms, Greedy, Simulation, DP |
Question Type 1: Image Processing Scheduling
Problem Description
An autonomous driving system needs to apply various filters to camera-captured images. Each image has a designated processing window [start, end], and each filter has a different processing cost. Design a scheduling strategy to minimize total processing cost while satisfying time constraints.
Return the minimum cost modulo (10^9 + 7).
Solution Approach
This is an interval scheduling + greedy/DP problem:
- Sort images by deadline
- For each image, select the lowest-cost available filter
- Use a priority queue to maintain available processing resources
Python Solution
import heapq
MOD = 10**9 + 7
def min_processing_cost(images, filters):
"""
images: [(start, end, filter_requirements)]
filters: [(cost, processing_time)]
"""
images.sort(key=lambda x: x[1])
total_cost = 0
for start, end, req in images:
valid_filters = []
for cost, proc_time in filters:
if proc_time <= end - start:
valid_filters.append(cost)
if valid_filters:
total_cost = (total_cost + min(valid_filters)) % MOD
else:
return -1
return total_cost
Question Type 2: Shortest Route Planning
Problem Description
Given a city road network graph where nodes represent intersections and weighted edges represent roads (weight = travel time). An autonomous vehicle needs to travel from start to destination, but some roads change dynamically (e.g., traffic control). Find the shortest path considering dynamic changes.
Solution Approach
This is a Dijkstra + dynamic edge weight variant:
- Use modified Dijkstra's algorithm
- Consider time-dependent edge weight changes during relaxation
- Optimize with priority queue
Python Solution
import heapq
from collections import defaultdict
def shortest_path_dynamic(n, edges, changes, start, end):
graph = defaultdict(list)
for u, v, w in edges:
graph[u].append((v, w))
graph[v].append((u, w))
change_map = {}
for time, u, v, new_w in changes:
change_map[(min(u,v), max(u,v), time)] = new_w
dist = [float('inf')] * n
dist[start] = 0
pq = [(0, start)]
while pq:
d, u = heapq.heappop(pq)
if d > dist[u]:
continue
if u == end:
return d
for v, w in graph[u]:
edge_key = (min(u,v), max(u,v))
effective_w = w
for (eu, ev, t), nw in change_map.items():
if (eu, ev) == edge_key and t <= d:
effective_w = nw
new_dist = d + effective_w
if new_dist < dist[v]:
dist[v] = new_dist
heapq.heappush(pq, (new_dist, v))
return dist[end] if dist[end] != float('inf') else -1
Time Complexity: O((V + E) log V)
Space Complexity: O(V + E)
Question Type 3: Sensor Data Fusion
Problem Description
An autonomous vehicle is equipped with multiple sensors (LiDAR, Camera, Radar), each producing data frames at different frequencies. Design a data fusion algorithm to pair multi-sensor data frames with the closest timestamps, minimizing total time deviation.
Solution Approach
This is a two-pointer / sort + greedy problem:
def sensor_fusion(lidar_ts, camera_ts, radar_ts):
lidar_ts.sort()
camera_ts.sort()
radar_ts.sort()
total_diff = 0
i, j, k = 0, 0, 0
while i < len(lidar_ts) and j < len(camera_ts) and k < len(radar_ts):
max_diff = max(lidar_ts[i], camera_ts[j], radar_ts[k]) - \
min(lidar_ts[i], camera_ts[j], radar_ts[k])
total_diff += max_diff
min_val = min(lidar_ts[i], camera_ts[j], radar_ts[k])
if lidar_ts[i] == min_val:
i += 1
elif camera_ts[j] == min_val:
j += 1
else:
k += 1
return total_diff
Interview Preparation Tips
Technical Stack
- Languages: C++ primary (performance-critical), Python for OA
- Core Domains: Computer Vision, SLAM, Path Planning, Sensor Fusion
- System Skills: Real-time systems, Multi-threading, ROS
Interview Process
- OA (complete within 1-2 weeks)
- Technical Phone Screen (1 round, 45 minutes)
- Onsite Interview (3-4 rounds, including system design)
- Team Matching
FAQ
What types of questions does WeRide OA cover?
WeRide OA primarily tests graph algorithms (shortest path, BFS/DFS), greedy scheduling, and dynamic programming. Questions are typically framed as autonomous driving scenarios such as path planning, sensor data processing, and image processing scheduling.
What programming language should I use for WeRide interviews?
The OA stage supports multiple languages (Python, C++, Java), but subsequent technical interviews lean toward C++ due to the extreme performance requirements of autonomous driving systems. Python is perfectly fine for the OA stage.
How does WeRide's interview compare to other AV companies (Waymo, Cruise)?
WeRide's interview emphasizes engineering implementation and full-stack autonomous driving understanding. Difficulty is slightly lower than Waymo, but system design and real-time performance are examined more deeply. Chinese language interviews are available.
What is the pass rate for WeRide OA?
Based on community feedback, WeRide OA pass rate is approximately 40-50%. The key is writing correct and efficient code within the time limit.
Preparing for WeRide interviews?
oavoservice provides professional OA/VO assistance for autonomous driving companies including WeRide, Waymo, Cruise, and Pony.ai. Our team is familiar with the algorithm interview patterns in the autonomous driving domain.
👉 Contact WeChat: Coding0201 | Get real questions and assistance
Contact
Email: [email protected]
Telegram: @OAVOProxy