Description
A robot on an infinite XY-plane starts at point (0, 0) facing north. The robot receives an array of integers commands, which represents a sequence of moves that it needs to execute. There are only three possible types of instructions the robot can receive:
-2: Turn left90degrees.-1: Turn right90degrees.1 <= k <= 9: Move forwardkunits, one unit at a time.
Some of the grid squares are obstacles. The ith obstacle is at grid point obstacles[i] = (xi, yi). If the robot runs into an obstacle, it will stay in its current location (on the block adjacent to the obstacle) and move onto the next command.
Return the maximum squared Euclidean distance that the robot reaches at any point in its path (i.e. if the distance is 5, return 25).
Note:
- There can be an obstacle at
(0, 0). If this happens, the robot will ignore the obstacle until it has moved off the origin. However, it will be unable to return to(0, 0)due to the obstacle. - North means +Y direction.
- East means +X direction.
- South means -Y direction.
- West means -X direction.
Example 1:
Input: commands = [4,-1,3], obstacles = []
Output: 25
Explanation:
The robot starts at (0, 0):
- Move north 4 units to
(0, 4). - Turn right.
- Move east 3 units to
(3, 4).
The furthest point the robot ever gets from the origin is (3, 4), which squared is 32 + 42 = 25 units away.
Example 2:
Input: commands = [4,-1,4,-2,4], obstacles = [[2,4]]
Output: 65
Explanation:
The robot starts at (0, 0):
- Move north 4 units to
(0, 4). - Turn right.
- Move east 1 unit and get blocked by the obstacle at
(2, 4), robot is at(1, 4). - Turn left.
- Move north 4 units to
(1, 8).
The furthest point the robot ever gets from the origin is (1, 8), which squared is 12 + 82 = 65 units away.
Example 3:
Input: commands = [6,-1,-1,6], obstacles = [[0,0]]
Output: 36
Explanation:
The robot starts at (0, 0):
- Move north 6 units to
(0, 6). - Turn right.
- Turn right.
- Move south 5 units and get blocked by the obstacle at
(0,0), robot is at(0, 1).
The furthest point the robot ever gets from the origin is (0, 6), which squared is 62 = 36 units away.
Constraints:
1 <= commands.length <= 104commands[i]is either-2,-1, or an integer in the range[1, 9].0 <= obstacles.length <= 104-3 * 104 <= xi, yi <= 3 * 104- The answer is guaranteed to be less than
231.
Solutions
This code simulates a robot moving on a 2D grid that starts at the origin (0, 0) and executes a series of movement and rotation commands while navigating around obstacles. The robot maintains its current direction (north, east, south, or west) stored in an array of direction vectors, and processes each command by either turning (if the command is -1 for right or -2 for left) or moving forward one step at a time (for positive numbers), checking against a pre-computed Set of obstacles to prevent collisions. As the robot moves, it tracks the maximum squared Euclidean distance from the origin by calculating x² + y² after each command, and finally returns this maximum distance value, which represents how far the robot ever got from its starting position during the entire simulation.
/**
* @param {number[]} commands
* @param {number[][]} obstacles
* @return {number}
*/
var robotSim = function(commands, obstacles) {
const moves = [[0, 1], [1, 0], [0, -1], [-1, 0]];
const obs = new Set(obstacles.map(coord => coord[0] + ',' + coord[1]));
let dir = 0;
let x = 0;
let y = 0;
let maxDist = 0;
for (const cmd of commands) {
if (cmd < 0) {
const shift = cmd === -1 ? 1 : -1;
dir = (dir + shift + 4) % 4;
continue;
}
for (let i = 1; i <= cmd; i++) {
const nx = x + moves[dir][0];
const ny = y + moves[dir][1];
if (obs.has(nx + ',' + ny)) {
break;
}
x = nx;
y = ny;
}
maxDist = Math.max(maxDist, x * x + y * y);
}
return maxDist;
};