Added task 2069.

Author: javadev

src/main/java/g2001_2100/s2069_walking_robot_simulation_ii/Robot.java

@@ -0,0 +1,57 @@
+package g2001_2100.s2069_walking_robot_simulation_ii;
+
+// #Medium #Design #Simulation #2022_05_30_Time_110_ms_(56.14%)_Space_95.2_MB_(53.51%)
+
+public class Robot {
+    private int p;
+    private int w;
+    private int h;
+
+    public Robot(int width, int height) {
+        w = width - 1;
+        h = height - 1;
+        p = 0;
+    }
+
+    public void step(int num) {
+        p += num;
+    }
+
+    public int[] getPos() {
+        int remain = p % (2 * (w + h));
+        if (remain <= w) {
+            return new int[] {remain, 0};
+        }
+        remain -= w;
+        if (remain <= h) {
+            return new int[] {w, remain};
+        }
+        remain -= h;
+        if (remain <= w) {
+            return new int[] {w - remain, h};
+        }
+        remain -= w;
+        return new int[] {0, h - remain};
+    }
+
+    public String getDir() {
+        int[] pos = getPos();
+        if (p == 0 || pos[1] == 0 && pos[0] > 0) {
+            return "East";
+        } else if (pos[0] == w && pos[1] > 0) {
+            return "North";
+        } else if (pos[1] == h && pos[0] < w) {
+            return "West";
+        } else {
+            return "South";
+        }
+    }
+}
+
+/*
+ * Your Robot object will be instantiated and called as such:
+ * Robot obj = new Robot(width, height);
+ * obj.step(num);
+ * int[] param_2 = obj.getPos();
+ * String param_3 = obj.getDir();
+ */

src/main/java/g2001_2100/s2069_walking_robot_simulation_ii/readme.md

@@ -0,0 +1,55 @@
+2069\. Walking Robot Simulation II
+
+Medium
+
+A `width x height` grid is on an XY-plane with the **bottom-left** cell at `(0, 0)` and the **top-right** cell at `(width - 1, height - 1)`. The grid is aligned with the four cardinal directions (`"North"`, `"East"`, `"South"`, and `"West"`). A robot is **initially** at cell `(0, 0)` facing direction `"East"`.
+
+The robot can be instructed to move for a specific number of **steps**. For each step, it does the following.
+
+1.  Attempts to move **forward one** cell in the direction it is facing.
+2.  If the cell the robot is **moving to** is **out of bounds**, the robot instead **turns** 90 degrees **counterclockwise** and retries the step.
+
+After the robot finishes moving the number of steps required, it stops and awaits the next instruction.
+
+Implement the `Robot` class:
+
+*   `Robot(int width, int height)` Initializes the `width x height` grid with the robot at `(0, 0)` facing `"East"`.
+*   `void step(int num)` Instructs the robot to move forward `num` steps.
+*   `int[] getPos()` Returns the current cell the robot is at, as an array of length 2, `[x, y]`.
+*   `String getDir()` Returns the current direction of the robot, `"North"`, `"East"`, `"South"`, or `"West"`.
+
+**Example 1:**
+
+![example-1](https://assets.leetcode.com/uploads/2021/10/09/example-1.png)
+
+**Input**
+
+["Robot", "step", "step", "getPos", "getDir", "step", "step", "step", "getPos", "getDir"]
+
+[[6, 3], [2], [2], [], [], [2], [1], [4], [], []]
+
+**Output:**
+
+[null, null, null, [4, 0], "East", null, null, null, [1, 2], "West"]
+
+**Explanation:**
+
+    Robot robot = new Robot(6, 3); // Initialize the grid and the robot at (0, 0) facing East.
+    robot.step(2);  // It moves two steps East to (2, 0), and faces East.
+    robot.step(2);  // It moves two steps East to (4, 0), and faces East.
+    robot.getPos(); // return [4, 0]
+    robot.getDir(); // return "East"
+    robot.step(2);  // It moves one step East to (5, 0), and faces East.
+                    // Moving the next step East would be out of bounds, so it turns and faces North.
+                    // Then, it moves one step North to (5, 1), and faces North.
+    robot.step(1);  // It moves one step North to (5, 2), and faces North (not West).
+    robot.step(4);  // Moving the next step North would be out of bounds, so it turns and faces West.
+                    // Then, it moves four steps West to (1, 2), and faces West.
+    robot.getPos(); // return [1, 2]
+    robot.getDir(); // return "West" 
+
+**Constraints:**
+
+*   `2 <= width, height <= 100`
+*   <code>1 <= num <= 10<sup>5</sup></code>
+*   At most <code>10<sup>4</sup></code> calls **in total** will be made to `step`, `getPos`, and `getDir`.

src/test/java/g2001_2100/s2069_walking_robot_simulation_ii/RobotTest.java

@@ -0,0 +1,61 @@
+package g2001_2100.s2069_walking_robot_simulation_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class RobotTest {
+    @Test
+    void robot() {
+        // Initialize the grid and the robot at (0, 0) facing East.
+        Robot robot = new Robot(6, 3);
+        // It moves two steps East to (2, 0), and faces East.
+        robot.step(2);
+        // It moves two steps East to (4, 0), and faces East.
+        robot.step(2);
+        // return [4, 0]
+        assertThat(robot.getPos(), equalTo(new int[] {4, 0}));
+        // return "East"
+        robot.getDir();
+        // It moves one step East to (5, 0), and faces East.
+        // Moving the next step East would be out of bounds, so it turns and faces North.
+        // Then, it moves one step North to (5, 1), and faces North.
+        robot.step(2);
+        // It moves one step North to (5, 2), and faces North (not West).
+        robot.step(1);
+        // Moving the next step North would be out of bounds, so it turns and faces West.
+        // Then, it moves four steps West to (1, 2), and faces West.
+        robot.step(4);
+        // return [1, 2]
+        assertThat(robot.getPos(), equalTo(new int[] {1, 2}));
+        // return "West"
+        assertThat(robot.getDir(), equalTo("West"));
+    }
+
+    @Test
+    void robot2() {
+        // Initialize the grid and the robot at (0, 0) facing East.
+        Robot robot = new Robot(0, 0);
+        // It moves two steps East to (0, -2), and faces East.
+        robot.step(2);
+        // It moves two steps East to (0, -4), and faces East.
+        robot.step(2);
+        // return [0, -4]
+        assertThat(robot.getPos(), equalTo(new int[] {0, -4}));
+    }
+
+    @Test
+    void robot3() {
+        // Initialize the grid and the robot at (0, 0) facing East.
+        Robot robot = new Robot(2, 2);
+        // It moves two steps East to (2, 0), and faces East.
+        robot.step(2);
+        // It moves two steps East to (4, 0), and faces East.
+        robot.step(2);
+        // It moves two steps East to (6, 0), and faces East.
+        robot.step(2);
+        // return [1, 1]
+        assertThat(robot.getPos(), equalTo(new int[] {1, 1}));
+    }
+}