# artemkorsakov's solution

## to Robot Simulator in the Java Track

Published at Apr 13 2019 · 0 comments
Instructions
Test suite
Solution

#### Note:

This exercise has changed since this solution was written.

Write a robot simulator.

A robot factory's test facility needs a program to verify robot movements.

The robots have three possible movements:

• turn right
• turn left

Robots are placed on a hypothetical infinite grid, facing a particular direction (north, east, south, or west) at a set of {x,y} coordinates, e.g., {3,8}, with coordinates increasing to the north and east.

The robot then receives a number of instructions, at which point the testing facility verifies the robot's new position, and in which direction it is pointing.

• The letter-string "RAALAL" means:
• Turn right
• Turn left
• Turn left yet again
• Say a robot starts at {7, 3} facing north. Then running this stream of instructions should leave it at {9, 4} facing west.

# Running the tests

You can run all the tests for an exercise by entering

``````\$ gradle test
``````

## Source

Inspired by an interview question at a famous company.

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

### RobotTest.java

``````import org.junit.Ignore;
import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class RobotTest {

@Test
public void robotsAreCreatedWithAPositionAndOrientation() {
Orientation initialOrientation = Orientation.NORTH;
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, initialOrientation);

assertEquals(initialOrientation, robot.getOrientation());
assertEquals(initialGridPosition, robot.getGridPosition());
}

@Ignore("Remove to run test")
@Test
public void negativePositionsAreAllowed() {
GridPosition initialGridPosition = new GridPosition(-1, -1);
Orientation initialOrientation = Orientation.SOUTH;
Robot robot = new Robot(initialGridPosition, initialOrientation);

assertEquals(initialOrientation, robot.getOrientation());
assertEquals(initialGridPosition, robot.getGridPosition());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromNorthToEast() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.NORTH);

robot.turnRight();

Orientation expectedOrientation = Orientation.EAST;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromEastToSouth() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.EAST);

robot.turnRight();

Orientation expectedOrientation = Orientation.SOUTH;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromSouthToWest() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.SOUTH);

robot.turnRight();

Orientation expectedOrientation = Orientation.WEST;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromWestToNorth() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.WEST);

robot.turnRight();

Orientation expectedOrientation = Orientation.NORTH;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromNorthToWest() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.NORTH);

robot.turnLeft();

Orientation expectedOrientation = Orientation.WEST;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromWestToSouth() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.WEST);

robot.turnLeft();

Orientation expectedOrientation = Orientation.SOUTH;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromSouthToEast() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.SOUTH);

robot.turnLeft();

Orientation expectedOrientation = Orientation.EAST;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void changesTheDirectionFromEastToNorth() {
GridPosition initialGridPosition = new GridPosition(0, 0);
Robot robot = new Robot(initialGridPosition, Orientation.EAST);

robot.turnLeft();

Orientation expectedOrientation = Orientation.NORTH;
assertEquals(initialGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void increasesTheYCoordinateOneWhenFacingNorth() {
Orientation initialOrientation = Orientation.NORTH;
Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);

GridPosition expectedGridPosition = new GridPosition(0, 1);
assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(initialOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void decreasesTheYCoordinateByOneWhenFacingSouth() {
Orientation initialOrientation = Orientation.SOUTH;
Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);

GridPosition expectedGridPosition = new GridPosition(0, -1);
assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(initialOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void increasesTheXCoordinateByOneWhenFacingEast() {
Orientation initialOrientation = Orientation.EAST;
Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);

GridPosition expectedGridPosition = new GridPosition(1, 0);
assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(initialOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void decreasesTheXCoordinateByOneWhenFacingWest() {
Orientation initialOrientation = Orientation.WEST;
Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);

GridPosition expectedGridPosition = new GridPosition(-1, 0);
assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(initialOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void instructionsStartingNorthAndMoveEastAndNorth() {
Robot robot = new Robot(new GridPosition(7, 3), Orientation.NORTH);

robot.simulate("RAALAL");

GridPosition expectedGridPosition = new GridPosition(9, 4);
Orientation expectedOrientation = Orientation.WEST;

assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void instructionsToMoveWestAndNorth() {
Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);

robot.simulate("LAAARALA");

GridPosition expectedGridPosition = new GridPosition(-4, 1);
Orientation expectedOrientation = Orientation.WEST;

assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void instructionsToMoveWestAndSouth() {
Robot robot = new Robot(new GridPosition(2, -7), Orientation.EAST);

robot.simulate("RRAAAAALA");

GridPosition expectedGridPosition = new GridPosition(-3, -8);
Orientation expectedOrientation = Orientation.SOUTH;

assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

@Ignore("Remove to run test")
@Test
public void instructionsStartingSouthAndMoveEastAndNorth() {
Robot robot = new Robot(new GridPosition(8, 4), Orientation.SOUTH);

robot.simulate("LAAARRRALLLL");

GridPosition expectedGridPosition = new GridPosition(11, 5);
Orientation expectedOrientation = Orientation.NORTH;

assertEquals(expectedGridPosition, robot.getGridPosition());
assertEquals(expectedOrientation, robot.getOrientation());
}

}``````
``````public class Robot {
private GridPosition gridPosition;
private Orientation orientation;

Robot(GridPosition initialGridPosition, Orientation initialOrientation) {
this.gridPosition = initialGridPosition;
this.orientation = initialOrientation;
}

Orientation getOrientation() {
return orientation;
}

GridPosition getGridPosition() {
return gridPosition;
}

void turnRight() {
int ord = (orientation.ordinal() + 1) % Orientation.values().length;
orientation = Orientation.values()[ord];
}

void turnLeft() {
int ord = (orientation.ordinal() + Orientation.values().length - 1) % Orientation.values().length;
orientation = Orientation.values()[ord];
}

if (orientation.equals(Orientation.NORTH)) {
gridPosition = new GridPosition(gridPosition.x, gridPosition.y + 1);
} else if (orientation.equals(Orientation.EAST)) {
gridPosition = new GridPosition(gridPosition.x + 1, gridPosition.y);
} else if (orientation.equals(Orientation.SOUTH)) {
gridPosition = new GridPosition(gridPosition.x, gridPosition.y - 1);
} else {
gridPosition = new GridPosition(gridPosition.x - 1, gridPosition.y);
}
}

void simulate(String keys) {
for (char key : keys.toCharArray()) {
if (key == 'R') {
turnRight();
} else if (key == 'L') {
turnLeft();
} else if (key == 'A') {
}
}
}
}``````