Mars Rover Problem in Java

The Mars Rover problem is a classic programming challenge that tests one's ability to design an algorithm to navigate a rover on a rectangular grid. The goal is to manoeuvre the rover based on a set of commands, avoiding obstacles and staying within the bounds of the grid. In this section, we will explore a Java implementation of the Mars Rover problem, discuss potential challenges, and provide solutions to overcome them.

Problem Statement:

The Mars Rover problem involves a grid, where the rover's position is represented by a pair of coordinates (x, y) and a cardinal direction (N, S, E, or W). The rover is controlled by a set of commands: 'L' and 'R' to turn left or right, respectively, and 'M' to move one step forward in the current direction. The grid may contain obstacles, and the rover must navigate around them.

Solution to the Problem

In order to implement the Mars Rover problem in Java, we can define a Rover class with attributes for the rover's current position and direction. We can use the concept of enums to represent the cardinal directions and create methods to handle the movement and rotation commands.

Here's the complete Java program for the Mars Rover problem, along with comments explaining each section of the code:

MarsRover.java

import java.util.HashSet;
import java.util.Set;
// Enum representing the cardinal directions
enum Direction {
    N, E, S, W;
    // Method to turn left
    public Direction turnLeft() {
        return values()[(ordinal() + 3) % 4];
    }
    // Method to turn right
    public Direction turnRight() {
        return values()[(ordinal() + 1) % 4];
    }
}
public class MarsRover {
    private int x;
    private int y;
    private Direction direction;
    private Set<String> obstacles; // Set to store the positions of obstacles
    // Constructor
    public MarsRover(int x, int y, Direction direction) {
        this.x = x;
        this.y = y;
        this.direction = direction;
        this.obstacles = new HashSet<>();
    }
    // Method to rotate the rover
    public void rotate(char rotation) {
        if (rotation == 'L') {
            direction = direction.turnLeft();
        } else if (rotation == 'R') {
            direction = direction.turnRight();
        }
    }
    // Method to move the rover
    public void move() {
        int nextX = x;
        int nextY = y;
        switch (direction) {
            case N:
                nextY++;
                break;
            case E:
                nextX++;
                break;
            case S:
                nextY--;
                break;
            case W:
                nextX--;
                break;
        }
        // Check for obstacles and boundary conditions
        String nextPosition = nextX + ":" + nextY;
        if (!obstacles.contains(nextPosition) && isValidPosition(nextX, nextY)) {
            x = nextX;
            y = nextY;
        }
    }
    // Method to check if a position is valid within the grid
    private boolean isValidPosition(int x, int y) {
        int maxX = 10; // Maximum X-coordinate of the grid
        int maxY = 10; // Maximum Y-coordinate of the grid
        return x >= 0 && x <= maxX && y >= 0 && y <= maxY;
    }
    // Method to add an obstacle to the grid
    public void addObstacle(int x, int y) {
        obstacles.add(x + ":" + y);
    }

    // Method to get the current position of the rover
    public String getPosition() {
        return x + ":" + y + " (" + direction + ")";
    }
    public static void main(String[] args) {
        // Create a MarsRover object
        MarsRover rover = new MarsRover(0, 0, Direction.N);
        // Add obstacles to the grid
        rover.addObstacle(2, 2);
        rover.addObstacle(4, 6);
        // Execute a series of commands
        String commands = "LMLMLMLMM";
        for (char command : commands.toCharArray()) {
            if (command == 'L' || command == 'R') {
                rover.rotate(command);
            } else if (command == 'M') {
                rover.move();
            }
        }
        // Print the final position of the rover
        System.out.println("Final position: " + rover.getPosition());
    }
}

Output:

Final position: 0:4 (N)

In this example, we create a MarsRover object starting at coordinates (0, 0) and facing north. We add obstacles at positions (2, 2) and (4, 6) on the grid.

Challenges and Solutions:

Grid Bounds: To prevent the rover from going outside the grid, we can enforce boundary checks in the move() method. When attempting to move outside the grid, we can throw an exception or ignore the command altogether.
Obstacle Detection: To handle obstacles, we can maintain a separate data structure, such as a set or a grid, to represent the obstacles on the grid. Before moving, we can check if the next position contains an obstacle and take appropriate action.
Input Validation: It's crucial to validate the input commands to ensure they are in the correct format and contain valid characters. Additionally, we should handle cases where the rover encounters an unrecognized command.
Error Handling: We can use exceptions or error codes to handle exceptional cases, such as invalid input or out-of-bounds movements. Proper error handling will make the program more robust and prevent unexpected behavior.

Next TopicModel Class in Java

← prev next →