## Algorithm

Problem Name: 874. Walking Robot Simulation

A robot on an infinite XY-plane starts at point `(0, 0)` facing north. The robot can receive a sequence of these three possible types of `commands`:

• `-2`: Turn left `90` degrees.
• `-1`: Turn right `90` degrees.
• `1 <= k <= 9`: Move forward `k` units, 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, then it will instead stay in its current location and move on to the next command.

Return the maximum Euclidean distance that the robot ever gets from the origin squared (i.e. if the distance is `5`, return `25`).

Note:

• 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):
1. Move north 4 units to (0, 4).
2. Turn right.
3. 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):
1. Move north 4 units to (0, 4).
2. Turn right.
3. Move east 1 unit and get blocked by the obstacle at (2, 4), robot is at (1, 4).
4. Turn left.
5. 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 = []
Output: 36
Explanation: The robot starts at (0, 0):
1. Move north 6 units to (0, 6).
2. Turn right.
3. Turn right.
4. Move south 6 units to (0, 0).
The furthest point the robot ever gets from the origin is (0, 6), which squared is 62 = 36 units away.
```

Constraints:

• `1 <= commands.length <= 104`
• `commands[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`.

## Code Examples

### #1 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
const robotSim = function(commands, obstacles) {
const dirs = [[1, 0], [0, -1], [-1, 0], [0, 1]] // east, south, west, north
const set = new Set()
let idx = 3, x = 0, y = 0, res = 0
for(let e of commands) {
if(e === -2) idx = (3 + idx) % 4
else if(e === -1) idx = (1 + idx) % 4
else {
const [dx, dy] = dirs[idx]
let dis = 0
while(dis < e) {
const nx = x + dx, ny = y + dy
const k = `\${nx},\${ny}`
if(set.has(k)) break
x = nx
y = ny
dis++
res = Math.max(res, x * x + y * y)
}
}
}

return res
};
``````
Copy The Code &

Input

cmd
commands = [4,-1,4,-2,4], obstacles = [[2,4]]

Output

cmd
65

### #2 Code Example with Python Programming

```Code - Python Programming```

``````
class Solution:
def robotSim(self, commands, obstacles):
i = j = mx = 0
d, move, obstacles = 3, [(-1, 0), (0, -1), (1, 0), (0, 1)], set(map(tuple, obstacles))
for command in commands:
if command == -2: d = (d + 1) % 4
elif command == -1: d = (d - 1) % 4
else:
x, y = move[d]
while command and (i + x, j + y) not in obstacles:
i += x
j += y
command -= 1
mx = max(mx, i ** 2 + j ** 2)
return mx
``````
Copy The Code &

Input

cmd
commands = [4,-1,4,-2,4], obstacles = [[2,4]]

Output

cmd
65

### #3 Code Example with C# Programming

```Code - C# Programming```

``````
using System;
using System.Collections.Generic;

namespace LeetCode
{
public class _0874_WalkingRobotSimulation
{
public int RobotSim(int[] commands, int[][] obstacles)
{
int[] dx = new int[] { 0, 1, 0, -1 }, dy = new int[] { 1, 0, -1, 0 };
int x = 0, y = 0, dir = 0;

var obstacleSet = new HashSet();
foreach (var obstacle in obstacles)

var result = 0;
foreach (var cmd in commands)
{
if (cmd == -2) dir = (dir + 3) % 4;
else if (cmd == -1) dir = (dir + 1) % 4;
else
{
for (int i = 0; i < cmd; i++)
{
var nx = x + dx[dir];
var ny = y + dy[dir];

if (obstacleSet.Contains((nx << 16) + ny))
break;

x = nx;
y = ny;
}
}

result = Math.Max(result, x * x + y * y);
}

return result;
}
}
}
``````
Copy The Code &

Input

cmd
commands = [4,-1,4,-2,4], obstacles = [[2,4]]

Output

cmd
65