Home » JavaScript » JavaScript Tutorial Through Katas: Mars Rover

About Viktor Farcic

Viktor Farcic
Viktor Farcic is a Software Developer currently focused on transitions from Waterfall to Agile processes with special focus on Behavior-Driven Development (BDD), Test-Driven Development (TDD) and Continuous Integration (CI).

JavaScript Tutorial Through Katas: Mars Rover

A programming kata is an exercise which helps a programmer hone his skills through practice and repetition.

The article assumes that the reader is familiar with the basic usage of JavaScript and Jasmine asserts and knows how to run them from his favorite IDE (ours is WebStorm or IntelliJ IDEA.

Tests that prove that the solution is correct are displayed below. Recommended way to solve this kata is to write the implementation for the first test, confirm that it passes and move to the next. Once all of the tests pass, the kata can be considered solved.

One possible solution is provided below the tests. Try to solve the kata by yourself first.

Mars Rover

Develop an api that moves a rover around on a grid.

  • You are given the initial starting point (x,y) of a rover and the direction (N,S,E,W) it is facing.
  • The rover receives a character array of commands.
  • Implement commands that move the rover forward/backward (f,b).
  • Implement commands that turn the rover left/right (l,r).
  • Implement wrapping from one edge of the grid to another. (planets are spheres after all)
  • Implement obstacle detection before each move to a new square. If a given sequence of commands encounters an obstacle, the rover moves up to the last possible point and reports the obstacle.

Following is a set of unit tests that can be used to solve this kata in the TDD fashion.

describe('Mars Rover', function() {

    describe('You are given the initial starting point (x,y) of a rover and the direction (N,S,E,W) it is facing', function() {
        it('should set starting location', function() {
            var mr = new MarsRover([12, 21]);
            expect(mr.location).toEqual([12, 21]);
        });
        it('should use default starting location value 0x0 when not assigned', function() {
            var mr = new MarsRover();
            expect(mr.location).toEqual([0, 0]);
        });
        it('should set direction as numeric value', function() {
            var mr = new MarsRover([12, 21], 'N');
            expect(mr.direction).toEqual('N');
        });
        it('should use default starting direction value N when not assigned', function() {
            var mr = new MarsRover([12, 21]);
            expect(mr.direction).toEqual('N');
        });
    });

    describe('The rover receives a character array of commands', function() {
        it('should set commands array', function() {
            var mr = new MarsRover([12, 21], 'N');
            mr.commands(['do', 'this', 'and', 'then', 'do', 'that']);
            expect(mr.commands()).toEqual(['do', 'this', 'and', 'then', 'do', 'that']);
        });
    });

    describe('Implement commands that move the rover forward/backward (f,b)', function() {
        it('should reduce Y when moving north', function() {
            var mr = new MarsRover([12, 21], 'N');
            mr.commands(['f', 'f']);
            expect(mr.location).toEqual([12, 19]);
        });
        it('should increase Y when moving south', function() {
            var mr = new MarsRover([12, 21], 'S');
            mr.commands(['f']);
            expect(mr.location).toEqual([12, 22]);
        });
        it('should reduce X when moving west', function() {
            var mr = new MarsRover([12, 21], 'W');
            mr.commands(['f']);
            expect(mr.location).toEqual([11, 21]);
        });
        it('should increase X when moving east', function() {
            var mr = new MarsRover([12, 21], 'E');
            mr.commands(['f']);
            expect(mr.location).toEqual([13, 21]);
        });
        it('should increase Y when moving backwards facing north', function() {
            var mr = new MarsRover([12, 21], 'N');
            mr.commands(['b']);
            expect(mr.location).toEqual([12, 22]);
        });
        it('should reduce Y when moving backwards facing south', function() {
            var mr = new MarsRover([12, 21], 'S');
            mr.commands(['b']);
            expect(mr.location).toEqual([12, 20]);
        });
        it('should increase X when moving backwards facing west', function() {
            var mr = new MarsRover([12, 21], 'W');
            mr.commands(['b']);
            expect(mr.location).toEqual([13, 21]);
        });
        it('should reduce X when moving backwards facing east', function() {
            var mr = new MarsRover([12, 21], 'E');
            mr.commands(['b']);
            expect(mr.location).toEqual([11, 21]);
        });
    });

    describe('Implement commands that turn the rover left/right (l,r)', function() {
        it('should change direction from E to N when command is to turn left', function() {
            var mr = new MarsRover([12, 21], 'E');
            mr.commands(['l']);
            expect(mr.direction).toEqual('N');
        });
        it('should change direction from N to W when command is to turn left', function() {
            var mr = new MarsRover([12, 21], 'N');
            mr.commands(['l']);
            expect(mr.direction).toEqual('W');
        });
        it('should change direction from E to S when command is to turn right', function() {
            var mr = new MarsRover([12, 21], 'E');
            mr.commands(['r']);
            expect(mr.direction).toEqual('S');
        });
    });

    describe('Implement wrapping from one edge of the grid to another (planets are spheres after all)', function() {
        it('should assign grid size', function() {
            var mr = new MarsRover([12, 21], 'N', [12, 33]);
            expect(mr.grid).toEqual([12, 33]);
        });
        it('should use default value 100x100 when grid is not assigned', function() {
            var mr = new MarsRover([12, 21], 'N');
            expect(mr.grid).toEqual([100, 100]);
        });
        it('should return X to 0 when grid is passed', function() {
            var mr = new MarsRover([9, 9], 'E', [10, 10]);
            mr.commands(['f']);
            expect(mr.location).toEqual([0, 9]);
        });
        it('should return Y to 0 when grid is passed', function() {
            var mr = new MarsRover([9, 9], 'S', [10, 10]);
            mr.commands(['f']);
            expect(mr.location).toEqual([9, 0]);
        });
        it('should return X to grid end when grid is passed from west', function() {
            var mr = new MarsRover([0, 9], 'E', [10, 10]);
            mr.commands(['b']);
            expect(mr.location).toEqual([9, 9]);
        });
        it('should return Y to grid end when grid is passed from north', function() {
            var mr = new MarsRover([9, 0], 'N', [10, 10]);
            mr.commands(['f']);
            expect(mr.location).toEqual([9, 9]);
        });
    });

    describe('Implement obstacle detection before each move to a new square.'
        + ' If a given sequence of commands encounters an obstacle,'
        + ' the rover moves up to the last possible point and reports the obstacle', function() {
        it('should assign obstacles', function() {
            var mr = new MarsRover([12, 21], 'N', [12, 33], [[5, 5], [3, 7]]);
            expect(mr.obstacles).toEqual([[5, 5], [3, 7]]);
        });
        it('should use empty array when obstacles are not assigned', function() {
            var mr = new MarsRover([12, 21], 'N');
            expect(mr.obstacles.length).toEqual(0);
        });
        it('should not move to the obstacle', function() {
            var mr = new MarsRover([0, 0], 'E');
            mr.obstacles = [[5, 1], [3, 0]];
            mr.commands(['f', 'f', 'f']);
            expect(mr.location).toEqual([2, 0]);
        });
        it('should stop when obstacle is detected', function() {
            var mr = new MarsRover([0, 0], 'E');
            mr.obstacles = [[3, 0]];
            mr.commands(['f', 'f', 'f', 'l', 'f']);
            expect(mr.location).toEqual([2, 0]);
        });
        it('should set status to obstacle when one is detected', function() {
            var mr = new MarsRover([0, 0], 'E');
            mr.obstacles = [[1, 0]];
            mr.commands(['f']);
            expect(mr.status).toEqual('obstacle');
        });
        it('should leave status to OK when obstacle is NOT detected', function() {
             var mr = new MarsRover([0, 0], 'E');
             mr.commands(['f']);
             expect(mr.status).toEqual('OK');
        });
    });

}); 

One possible solution is following.

function MarsRover(location, direction, grid, obstacles) {

    self = this;
    this.location = (location === undefined) ? [0, 0] : location;
    this.direction = (direction === undefined) ? 'N' : direction;
    this.grid = (grid === undefined) ? [100, 100] : grid;
    this.obstacles = (obstacles === undefined) ? [] : obstacles;
    this.status = 'OK';

    this.commands = function(commands) {
        if (commands === undefined) { // Getter
            return this.commandsArray;
        } else { // Setter
            for(var index = 0; index < commands.length; index++) {
                var command = commands[index];
                if (command === 'f' || command === 'b') {
                    if (!move(command)) break;
                } else if (command === 'l' || command === 'r') {
                    turn(command);
                }
            }
            resetLocation();
            this.commandsArray = commands;
        }
    };

    function resetLocation() {
        self.location = [
            (self.location[0] + self.grid[0]) % self.grid[0],
            (self.location[1] + self.grid[1]) % self.grid[1]
        ]
    }

    function move(command) {
        var xIncrease = 0, yIncrease = 0;
        if (self.direction === 'N') {
            yIncrease = -1;
        } else if (self.direction === 'E') { // East
            xIncrease = 1;
        } else if (self.direction === 'S') { // South
            yIncrease = 1;
        } else if (self.direction === 'W') { // West
            xIncrease = -1;
        }
        if (command === 'b') { // Backward
            xIncrease *= -1;
            yIncrease *= -1;
        }
        var newLocation = [self.location[0] + xIncrease, self.location[1] + yIncrease];
        if (isObstacle(newLocation)) {
            return false;
        }
        self.location = newLocation;
        return true;
    }

    function isObstacle(newLocation) {
        for(var index = 0; index < self.obstacles.length; index++) {
            if (newLocation.toString() == self.obstacles[index].toString()) {
                self.status = 'obstacle';
                return true;
            }
        }
        return false;
    }

    function turn(command) {
        var directionNumber = directionAsNumber(self.direction);
        if (command === 'l') { // Left
            directionNumber = (directionNumber + 4 - 1) % 4;
        } else { // Right
            directionNumber = (directionNumber + 1) % 4;
        }
        self.direction = self.directions[directionNumber];
    }

    this.directions = ['N', 'E', 'S', 'W'];

    function directionAsNumber(direction) {
        for(var index = 0; index < 4; index++) {
            if (self.directions[index] === direction) return index;
        }
    }

} 

Full source is located in the GitHub repo https://github.com/vfarcic/mars-rover-kata-java-script. Besides tests and implementation, it includes package.json with NodeJS dependencies, Bower configuration with JS libraries and Grunt configuration that can be used run tests. README.md contains short instructions how to setup the project.

There are many ways to improve both tests and implementation of the provided solution. We could, for example:

  • Check whether object values are correct. Location and grid must be number arrays consisting of two numbers.
  • Check whether object values are correct. Direction must be one of following values: ‘N’, ‘S’, ‘E’, ‘W’
  • Check whether command values are correct Commands must be an arrays consisting of one of following values: ‘f’, ‘b’, ‘l’, ‘r’.
  • Change the code so that it works with both lower and upper cases (i.e ‘N’ or ‘n’ to specify north).

What was your solution? Post it as a comment so that we can compare different ways to solve this kata.

(0 rating, 0 votes)
You need to be a registered member to rate this.
Start the discussion Views Tweet it!
Do you want to know how to develop your skillset to become a Web Rockstar?
Subscribe to our newsletter to start Rocking right now!
To get you started we give you our best selling eBooks for FREE!
1. Building web apps with Node.js
2. HTML5 Programming Cookbook
3. CSS Programming Cookbook
4. AngularJS Programming Cookbook
5. jQuery Programming Cookbook
6. Bootstrap Programming Cookbook
and many more ....
I agree to the Terms and Privacy Policy
Subscribe
Notify of
guest

This site uses Akismet to reduce spam. Learn how your comment data is processed.

0 Comments
Inline Feedbacks
View all comments