Tag: code

I know this code worked as I tested it with the case reviews discussed below in the code, and I even added some of mine, but the developers who tested me came back with the following reviews:

1. Everything in one file, no attempt to modularize or separate concerns
2. No tests at all. You could possibly forgive an entry level
   0% test submission, but seniors should demonstrate their
   value
3. Everything is declared as a let variable which suggests
   can be canceled. I guess most of them should be consts.
   Again, the senior should demonstrate this
4. The submission can be difficult to read with the excessive comments and all that together

I have included their original tests, as well as three of mine, commented in the code below … I don't know if they were ignored or rejected … Someone could- enlighten us on how this code could have been improved? If I receive another coding test, I would like to have an overview of what is expected in terms of code formatting compared to this kind of comments …

The description

• The application is a simulation of a toy robot moving on a square table, dimensions 5 units x 5 units.
• There are no other obstacles on the table surface.
• The robot is free to move around the table surface, but must be prevented from falling to destruction. Any movement that
  prevent the robot from falling off the table,
  however, other valid motion commands must still be authorized.

Create an application that can read commands like this:

PLACE X,Y,F
MOVE
LEFT
RIGHT
REPORT

• PLACE will place the toy robot on the table in position X, Y and oriented NORTH, SOUTH, EAST or WEST.
• Origin (0,0) can be considered as the most SOUTHWEST corner.
• The first valid command for the robot is a PLACE command, after which any sequence of commands can be issued, in any order, including
  another PLACE command. The app should delete all orders
  in order until a valid PLACE command has been executed.
• MOVE moves the toy robot one unit forward in the direction it is currently facing.
• LEFT and RIGHT will rotate the robot 90 degrees in the specified direction without changing the robot's position.

• REPORT will announce the X, Y and F of the robot. It can be in any form, but standard output is sufficient.

• A robot that is not on the table can choose to ignore the MOVE, LEFT, RIGHT and REPORT commands.

• The input can come from a file or from standard input, depending on the choice of the developer.
• Provide test data to exercise the application.

constraints

• The toy robot must not fall off the table during movement. This also includes the initial placement of the toy robot.
• Any movement that would cause the robot to fall should be ignored.

Example of entry and exit

Example a

PLACE 0,0,NORTH
MOVE
REPORT

Expected production:

0,1,NORTH

Example b

PLACE 0,0,NORTH
LEFT
REPORT

Expected production:

0,0,WEST

Example c

PLACE 1,2,EAST
MOVE
MOVE
LEFT
MOVE
REPORT

Expected production

3,3,NORTH

deliverables

Ruby source files, test data, and any test code.

There is no need to provide graphical output showing the
toy robot movement.

// Toy Robot!

/* A few caveats for this solution
    1) Input is said to be of a text format, we will make this an array with each element containing a command
        e.g. ("PLACE 1,2,NORTH", "MOVE", "LEFT", "MOVE", "REPORT")
    2) I'm doing this in NodeJS (JavaScript)
    3) To run this one could run this directly in the Node terminal, or copy and paste it into JSBin.com and execute it there; 
        or reference it in an HTML file; so in saying that, the executed input will be located at the bottom of the functional definition.

*/

/* CODE STARTS */

"use strict"
let Robot = function(aCommands) {

    let iTableX = 5; // Width of Table
    let iTableY = 5; // Height of Table
    let aDir = ("NORTH","EAST","SOUTH","WEST"); // Directions
    let sRobotDir = 0; // Sets the default based off the above array
    let aCommandSplit = ();

    // Sets default setting for robot's coordinates X, Y
    let iRobotX = 0;
    let iRobotY = 0;
    let bRobotPlaced = false; // Determines if the robot has been placed on the board...
    let aTokens = (); // Sets up a basic array to hold our tokens

    // Can I tell you I'm already enjoying programming this? :D

    /* Let's set up some basic rules here
    1) We split each element into a command and optional options (options only available with PLACE command)
    2) We iterate through each array element, anything but a starting PLACE command is ignored.
    3) As we proceed through each element, a switch command will assess the value of the command, and then takes an appropriate action.
    */

    // Tokenizing engine
    for(let iLoop = 0, iLen = aCommands.length; iLoop < iLen; iLoop++) {
        aCommandSplit = aCommands(iLoop).toUpperCase().split(" "); // Initiates primary split, ensuring all commands are upper case
        if(aCommandSplit.length == 2) {
            aCommandSplit(1) = aCommandSplit(1).split(","); // split parameters
        } else {
            aCommandSplit(1) = (); // defafult
        }
        aTokens.push(aCommandSplit);            
    }

    // Invalid Command
    let invalidCommand = function(item) {
        console.log(">> INVALID COMMAND: '"+item.join(" ")+"' IGNORED");
    };

    // Checks if value is below zero
    let isBelowZero = (val) => (val < 0);

    // Checks if value is equal to or above a certain limit
    let isBeyondTableLimit = (val,limit) => (val >= limit);

    // Checks if string represents a positive value
    let isPosInteger = function (str) {
        var n = Math.floor(Number(str));
        return n !== Infinity && String(n) === str && n >= 0;
    };

    // Checks to see if the string is a direction in the direction array
    let isDirection = (str) => !!~aDir.indexOf(str);

    // Returns the index of the direction string
    let whichDirection = (str) => aDir.indexOf(str);

    // Validates the parameters for placement
    let checkPlaceParams = (arr) => (
            (arr != ()) &&                              // array isn't empty
            (arr.length == 3) &&                        // array contains three elements
            isPosInteger(arr(0)) &&                     // element 0 is a positive integer or zero
            isPosInteger(arr(1)) &&                     // element 1 is a positive integer or zero
            (typeof(arr(2)) == "string") &&             // element 2 is a string
            isDirection(arr(2)) &&                      // element 2 is a direction
            !isBelowZero(+arr(0)) &&                    // element 0 is equal to zero or above
            !isBelowZero(+arr(1)) &&                    // element 1 is equal to zero or above
            !isBeyondTableLimit(+arr(0), iTableX) &&    // element 0 is not bigger than the table size
            !isBeyondTableLimit(+arr(1), iTableY)       // element 1 is not bigger than the table size
        );

    // Sets the placement
    let place = function(item) {
        if(checkPlaceParams(item(1))) {
            iRobotX = +item(1)(0);
            iRobotY = +item(1)(1);
            sRobotDir = whichDirection(item(1)(2));
            bRobotPlaced = true;
        }
    };

    // Rotates the robot left or right.
    let rotate = function(turn) {
        let newDir = (sRobotDir + ((turn=="LEFT")?3:1))%4;
        sRobotDir = newDir;
    };
    // Checks to see if the robot can move in a certain direction
    let canMove = function() {
        switch(sRobotDir) {
            case 0: // North
                return (!isBeyondTableLimit(iRobotY+1, iTableY));
                break;
            case 1: // East
                return (!isBeyondTableLimit(iRobotX+1, iTableX));
                break;
            case 2: // South
                return (!isBelowZero(iRobotY-1));
                break;
            case 3: // West
                return (!isBelowZero(iRobotX-1));
                break;
        }
    }
    // Moves the robot
    let move = function() {
        if(sRobotDir % 2 == 1) { // If east or west
            if(sRobotDir == 1) { // if east
                iRobotX++;
            } else {
                iRobotX--;
            }
        } else {
            if(sRobotDir == 0) { // if north
                iRobotY++;
            } else {
                iRobotY--;
            }
        }
    };

    // Reports position and direction facing
    let report = function() {
        console.log((iRobotX,iRobotY,aDir(sRobotDir)).join(","));
    };

    // Step through the tokens
    aTokens.forEach(function(item, index) {
        switch (item(0)) {
            case "PLACE":
                place(item);
                break;
            case "LEFT":
            case "RIGHT":
                bRobotPlaced ? rotate(item(0)) : invalidCommand(item);
                break;
            case "MOVE":
                (bRobotPlaced && canMove()) ? move() : invalidCommand(item);
                break;
            case "REPORT":
                bRobotPlaced ? report() : invalidCommand(item);
                break;
            default:
                invalidCommand(item);
                break;
        }
    });
};  

/* CODE ENDS */

/* EXECUTE BLOCK STARTS */

    // Original Test Cases
    // Robot(("PLACE 0,0,NORTH","MOVE","REPORT"));  // 0,1,NORTH
    // Robot(("PLACE 0,0,NORTH","LEFT","REPORT")); // 0,0,WEST
    // Robot(("PLACE 1,2,EAST","MOVE","MOVE","LEFT","MOVE","REPORT"));  // 3,3,NORTH

    // My Test Cases
    // Robot(("PLACE 1,2,NORTH", "MOVE", "LEFT", "MOVE", "REPORT"));      // Expected result: 0,3,WEST
    // Robot(("MOVE","PLACE 0,3,WEST","MOVE","RIGHT","MOVE","MOVE","REPORT")); // Expected result: 0,4,NORTH
    /* NOTE: Robot should ignore first MOVE command because it hasn't been PLACE-d yet, and then ignore the second MOVE command because it can't go any further west, be able to move on the third MOVE command, but then ignore the last MOVE command because it can't go any further north. */
    //Robot(("PLACE 2,2,NORTH","KEFT","NOVE","MOVE","REPORT"));
    /* Should ignore the "KEFT" command as it can't rotate "KEFT", then ignore the "NOVE" command, but obey the "MOVE" command. 
        Final result: 2,3,NORTH */

/* EXECUTE BLOCK ENDS */