solve problem Walking Robot Simulation

Author: P-ppc

README.md

@@ -218,6 +218,7 @@ All solutions will be accepted!
 |427|[Construct Quad Tree](https://leetcode-cn.com/problems/construct-quad-tree/description/)|[java/py](./algorithms/ConstructQuadTree)|Easy|
 |458|[Poor Pigs](https://leetcode-cn.com/problems/poor-pigs/description/)|[java/py/js](./algorithms/PoorPigs)|Easy|
 |558|[Quad Tree Intersection](https://leetcode-cn.com/problems/quad-tree-intersection/description/)|[java/py](./algorithms/QuadTreeIntersection)|Easy|
+|874|[Walking Robot Simulation](https://leetcode-cn.com/problems/walking-robot-simulation/description/)|[java/py/js](./algorithms/WalkingRobotSimulation)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/WalkingRobotSimulation/README.md

@@ -0,0 +1,2 @@
+# Walking Robot Simulation
+This problem is easy to solve, here is the [solution](https://leetcode-cn.com/articles/walking-robot-simulation/)

algorithms/WalkingRobotSimulation/Solution.java

@@ -0,0 +1,37 @@
+class Solution {
+    public int robotSim(int[] commands, int[][] obstacles) {
+        int x = 0,
+            y = 0,
+            di = 0,
+            res = 0;
+        
+        int[] dx = {0, 1, 0, -1},
+              dy = {1, 0, -1, 0};
+        
+        Set<String> obstacleSet = new HashSet<String>();
+        
+        for (int[] obstacle: obstacles) {
+            obstacleSet.add(String.valueOf(obstacle[0]) + "X" + obstacle[1]);
+        }
+        
+        for (int cmd : commands) {
+            if (cmd == -2) {
+                di = (di - 1) % 4;
+                if (di < 0) di = di + 4;
+            } else if (cmd == -1) {
+                di = (di + 1) % 4;
+            } else {
+                for (int i = 0; i < cmd; i++) {
+                    if (!obstacleSet.contains(String.valueOf(x + dx[di]) + "X" + String.valueOf(y + dy[di]))) {
+                        x += dx[di];
+                        y += dy[di];
+                        res = Math.max(res, x * x + y * y);
+                    } else {
+                        break;
+                    }
+                } 
+            }
+        }
+        return res;
+    }
+}

algorithms/WalkingRobotSimulation/solution.js

@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} commands
+ * @param {number[][]} obstacles
+ * @return {number}
+ */
+var robotSim = function(commands, obstacles) {
+    let x = y = di = res = 0,
+        dx = [0, 1, 0, -1],
+        dy = [1, 0, -1, 0]
+        obstacleSet = new Set(obstacles.map(d => `${d[0]}X${d[1]}`))
+    
+    commands.forEach(cmd => {
+        if (cmd === -2) {
+            di = (di - 1) % 4
+            if (di < 0) di = di + 4
+        } else if (cmd === -1) {
+            di = (di + 1) % 4
+        } else {
+            for (let i = 0; i < cmd; i++) {
+                if (!obstacleSet.has(`${x + dx[di]}X${y + dy[di]}`)) {
+                    x += dx[di]
+                    y += dy[di]
+                    res = Math.max(res, x * x + y * y)
+                } else {
+                    break
+                }
+            }            
+        }
+    })
+    
+    return res
+};

algorithms/WalkingRobotSimulation/solution.py

@@ -0,0 +1,26 @@
+class Solution(object):
+    def robotSim(self, commands, obstacles):
+        """
+        :type commands: List[int]
+        :type obstacles: List[List[int]]
+        :rtype: int
+        """
+        dx = [0, 1, 0, -1]
+        dy = [1, 0, -1, 0]
+        x = y = di = 0
+        obstacleSet = set(map(tuple, obstacles))
+        ans = 0
+
+        for cmd in commands:
+            if cmd == -2:  #left
+                di = (di - 1) % 4
+            elif cmd == -1:  #right
+                di = (di + 1) % 4
+            else:
+                for k in xrange(cmd):
+                    if (x + dx[di], y + dy[di]) not in obstacleSet:
+                        x += dx[di]
+                        y += dy[di]
+                        ans = max(ans, x * x + y * y)
+
+        return ans