Race Car - Practice Coding Problems

Race Car - Problem

Dynamic Programming Hard

Race Car Control Challenge

You have an autonomous race car positioned at the starting line (position 0) on an infinite racing track. The car begins with an initial speed of +1 and can move in either direction along the track.

Your car responds to two types of commands:

'A' (Accelerate): The car moves forward by its current speed, then doubles its speed
• position += speed
• speed *= 2
'R' (Reverse): The car changes direction without moving
• If speed > 0, then speed = -1
• If speed < 0, then speed = 1
• Position remains unchanged

Example: Commands "AAR" produce:
• Start: position=0, speed=1
• After 'A': position=1, speed=2
• After 'A': position=3, speed=4
• After 'R': position=3, speed=-1

Your goal: Find the minimum number of commands needed to reach the target position exactly.

Input & Output

example_1.py — Basic Target

$ Input: target = 3

› Output: 2

💡 Note: The shortest sequence is "AA": Start (0,1) → A (1,2) → A (3,4). We reach position 3 in 2 steps.

example_2.py — Requires Reverse

$ Input: target = 6

› Output: 5

💡 Note: The optimal sequence is "AAARA": (0,1) → A (1,2) → A (3,4) → A (7,8) → R (7,-1) → A (6,2). Total: 5 steps.

example_3.py — Single Step

$ Input: target = 1

› Output: 1

💡 Note: Simply accelerate once: "A" takes us from (0,1) to (1,2). We reach target 1 in just 1 step.

Constraints

1 ≤ target ≤ 10⁴
The target position is always reachable
Speed doubles with each acceleration
Position can be negative during the process

Visualization

Tap to expand

Understanding the Visualization

Initial State

Car starts at position 0 with speed +1

Decision Point

At each state, choose between Accelerate or Reverse

Accelerate Effect

Move forward by current speed, then double the speed

Reverse Effect

Change direction (speed becomes ±1), position unchanged

BFS Exploration

Explore all states level by level until target is reached

Key Takeaway

🎯 Key Insight: BFS guarantees finding the minimum steps because it explores states level by level. The first time we reach the target position is guaranteed to be via the shortest path!

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22

The optimal solution uses BFS (Breadth-First Search) to explore states level by level, guaranteeing the shortest path. Each state contains (position, speed, steps), and we try both accelerate and reverse commands from each state. Key optimizations include state pruning when |position - target| > target and using a visited set to avoid cycles. Time complexity is O(T log T) where T is the target.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Exploration (DFS)	O(2^n)	O(2^n)	Recursively try all possible command sequences until reaching target
BFS with State Tracking (Optimal)	O(T log T)	O(T log T)	Use BFS to find shortest path while tracking visited states to avoid cycles

Recursive Exploration (DFS) — Algorithm Steps

Start from position 0 with speed 1
For each state, try both 'A' and 'R' commands
Recursively explore each possibility
Track the minimum steps to reach target
Use memoization to avoid recalculating same states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start at position 0 with speed 1

Branch on Commands

Try both 'A' and 'R' from current state

Recursive Exploration

Recursively explore each branch until target is reached

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define HASH_SIZE 100003

typedef struct Node {
    int pos, speed, steps;
    struct Node* next;
} Node;

Node* hash_table[HASH_SIZE];

int hash_func(int pos, int speed) {
    return (pos * 31 + speed) % HASH_SIZE;
}

int get_memo(int pos, int speed) {
    int hash = hash_func(pos, speed);
    Node* node = hash_table[hash];
    while (node) {
        if (node->pos == pos && node->speed == speed) {
            return node->steps;
        }
        node = node->next;
    }
    return -1;
}

void set_memo(int pos, int speed, int steps) {
    int hash = hash_func(pos, speed);
    Node* node = (Node*)malloc(sizeof(Node));
    node->pos = pos;
    node->speed = speed;
    node->steps = steps;
    node->next = hash_table[hash];
    hash_table[hash] = node;
}

int dfs(int pos, int speed, int target) {
    int memo_val = get_memo(pos, speed);
    if (memo_val != -1) return memo_val;
    
    if (pos == target) return 0;
    
    if (abs(pos - target) > target) {
        return INT_MAX;
    }
    
    int res1 = 1 + dfs(pos + speed, speed * 2, target);
    int res2 = 1 + dfs(pos, speed > 0 ? -1 : 1, target);
    
    int result = (res1 < res2) ? res1 : res2;
    set_memo(pos, speed, result);
    return result;
}

int racecar(int target) {
    memset(hash_table, 0, sizeof(hash_table));
    return dfs(0, 1, target);
}

int main() {
    int target;
    scanf("%d", &target);
    printf("%d\n", racecar(target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Without pruning, we explore 2^n possible command sequences where n is the answer length

⚠ Quadratic Growth

Space Complexity

O(2^n)

Recursion stack and memoization table can grow exponentially

⚠ Quadratic Space

23.4K Views

Medium-High Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Exploration (DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler