trackler 2.2.1.47 → 2.2.1.48

data/tracks/typescript/exercises/robot-simulator/README.md

@@ -0,0 +1,58 @@
+# Robot Simulator
+
+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
+- advance
+
+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
+  - Advance twice
+  - Turn left
+  - Advance once
+  - 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.
+
+## Setup
+
+Go through the setup instructions for TypeScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/typescript
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ yarn install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ yarn test
+```
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Caesar_cipher](https://en.wikipedia.org/wiki/Caesar_cipher)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/typescript/exercises/robot-simulator/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "xtypescript",
+  "version": "1.0.0",
+  "description": "Exercism exercises in Typescript.",
+  "author": "",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xtypescript"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "tsc --noEmit -p . && jest --no-cache",
+    "lint": "tsc --noEmit -p . && tslint \"*.ts?(x)\"",
+    "lintci": "tslint \"*.ts?(x)\" --force"
+  },
+  "dependencies": {
+    "@types/jest": "^20.0.0",
+    "@types/node": "^7.0.5",
+    "jest": "^20.0.4",
+    "ts-jest": "^20.0.6",
+    "tslint": "^5.4.3",
+    "typescript": "^2.2.1"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
+    },
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  }
+}

data/tracks/typescript/exercises/robot-simulator/robot-simulator.example.ts

@@ -0,0 +1,74 @@
+export default class Robot {
+  public coordinates: number[]
+  public bearing: string
+
+  constructor(xcoord: number = 0, ycoord: number = 0, direction: string = 'north') {
+    this.coordinates = [xcoord, ycoord]
+    this.bearing = direction
+  }
+
+  at(xcoord: number, ycoord: number) {
+    this.coordinates = [xcoord, ycoord]
+  }
+
+  orient(direction: string) {
+    this.bearing = direction
+    return `The robot is pointed ${direction}`
+  }
+
+  advance() {
+    if (this.bearing === 'north') {
+      this.coordinates[1] += 1
+    } else if (this.bearing === 'south') {
+      this.coordinates[1] -= 1
+    } else if (this.bearing === 'east') {
+      this.coordinates[0] += 1
+    } else if (this.bearing === 'west') {
+      this.coordinates[0] -= 1
+    }
+  }
+
+  turnLeft() {
+    if (this.bearing === 'north') {
+      this.orient('west')
+    } else if (this.bearing === 'south') {
+      this.orient('east')
+    } else if (this.bearing === 'east') {
+      this.orient('north')
+    } else if (this.bearing === 'west') {
+      this.orient('south')
+    }
+  }
+
+  turnRight() {
+    if (this.bearing === 'north') {
+      this.orient('east')
+    } else if (this.bearing === 'south') {
+      this.orient('west')
+    } else if (this.bearing === 'east') {
+      this.orient('south')
+    } else if (this.bearing === 'west') {
+      this.orient('north')
+    }
+  }
+
+  instructions(s: string) {
+    return [...s].map((character) => {
+      if (character === 'L') {
+        return 'turnLeft'
+      } else if (character === 'R') {
+        return 'turnRight'
+      } else if (character === 'A') {
+        return 'advance'
+      } else {
+        throw 'Invalid Instruction'
+      }
+    })
+  }
+
+  evaluate(s: string) {
+    this.instructions(s).forEach((instruction) => {
+      this[instruction]()
+    })
+  }
+}

data/tracks/typescript/exercises/robot-simulator/robot-simulator.test.ts

@@ -0,0 +1,150 @@
+import Robot from './robot-simulator'
+
+describe('Robot', () => {
+  const robot = new Robot()
+
+  it('robot bearing', () => {
+    const directions = ['east', 'west', 'north', 'south']
+
+    directions.forEach((currentDirection) => {
+      robot.orient(currentDirection)
+      expect(robot.bearing).toEqual(currentDirection)
+    })
+  })
+
+  xit('invalid robot bearing', () => {
+    try {
+      robot.orient('crood')
+    } catch (exception) {
+      expect(exception).toEqual('Invalid Robot Bearing')
+    }
+  })
+
+  xit('turn right from north', () => {
+    robot.orient('north')
+    robot.turnRight()
+    expect(robot.bearing).toEqual('east')
+  })
+
+  xit('turn right from east', () => {
+    robot.orient('east')
+    robot.turnRight()
+    expect(robot.bearing).toEqual('south')
+  })
+
+  xit('turn right from south', () => {
+    robot.orient('south')
+    robot.turnRight()
+    expect(robot.bearing).toEqual('west')
+  })
+
+  xit('turn right from west', () => {
+    robot.orient('west')
+    robot.turnRight()
+    expect(robot.bearing).toEqual('north')
+  })
+
+  xit('turn left from north', () => {
+    robot.orient('north')
+    robot.turnLeft()
+    expect(robot.bearing).toEqual('west')
+  })
+
+  xit('turn left from east', () => {
+    robot.orient('east')
+    robot.turnLeft()
+    expect(robot.bearing).toEqual('north')
+  })
+
+  xit('turn left from south', () => {
+    robot.orient('south')
+    robot.turnLeft()
+    expect(robot.bearing).toEqual('east')
+  })
+
+  xit('turn left from west', () => {
+    robot.orient('west')
+    robot.turnLeft()
+    expect(robot.bearing).toEqual('south')
+  })
+
+  xit('robot coordinates', () => {
+    robot.at(3, 0)
+    expect(robot.coordinates).toEqual([3, 0])
+  })
+
+  xit('other robot coordinates', () => {
+    robot.at(-2, 5)
+    expect(robot.coordinates).toEqual([-2, 5])
+  })
+
+  xit('advance when facing north', () => {
+    robot.at(0, 0)
+    robot.orient('north')
+    robot.advance()
+    expect(robot.coordinates).toEqual([0, 1])
+  })
+
+  xit('advance when facing east', () => {
+    robot.at(0, 0)
+    robot.orient('east')
+    robot.advance()
+    expect(robot.coordinates).toEqual([1, 0])
+  })
+
+  xit('advance when facing south', () => {
+    robot.at(0, 0)
+    robot.orient('south')
+    robot.advance()
+    expect(robot.coordinates).toEqual([0, -1])
+  })
+
+  xit('advance when facing west', () => {
+    robot.at(0, 0)
+    robot.orient('west')
+    robot.advance()
+    expect(robot.coordinates).toEqual([-1, 0])
+  })
+
+  xit('instructions for turning left', () => {
+    expect(robot.instructions('L')).toEqual(['turnLeft'])
+  })
+
+  xit('instructions for turning right', () => {
+    expect(robot.instructions('R')).toEqual(['turnRight'])
+  })
+
+  xit('instructions for advancing', () => {
+    expect(robot.instructions('A')).toEqual(['advance'])
+  })
+
+  xit('series of instructions', () => {
+    expect(robot.instructions('RAAL'))
+      .toEqual(['turnRight', 'advance', 'advance', 'turnLeft'])
+  })
+
+  xit('instruct robot', () => {
+    const robotI = new Robot(-2, 1, 'east')
+    robotI.evaluate('RLAALAL')
+    expect(robotI.coordinates).toEqual([0, 2])
+    expect(robotI.bearing).toEqual('west')
+  })
+
+  xit('instruct many robots', () => {
+    const robot1 = new Robot(0, 0, 'north')
+    const robot2 = new Robot(2, -7, 'east')
+    const robot3 = new Robot(8, 4, 'south')
+    robot1.evaluate('LAAARALA')
+    robot2.evaluate('RRAAAAALA')
+    robot3.evaluate('LAAARRRALLLL')
+
+    expect(robot1.coordinates).toEqual([-4, 1])
+    expect(robot1.bearing).toEqual('west')
+
+    expect(robot2.coordinates).toEqual([-3, -8])
+    expect(robot2.bearing).toEqual('south')
+
+    expect(robot3.coordinates).toEqual([11, 5])
+    expect(robot3.bearing).toEqual('north')
+  })
+})

data/tracks/typescript/exercises/robot-simulator/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": { 
+        "target": "es2017",
+        "module": "commonjs",
+        "alwaysStrict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "preserveConstEnums": true,
+        "noFallthroughCasesInSwitch":true,
+        "noImplicitThis":true,
+        "noImplicitReturns":true,
+        "sourceMap": true,
+        "noEmitOnError": true,
+        "outDir": "./build"
+    },
+    "compileOnSave": true, 
+    "exclude": [
+        "node_modules"
+    ]
+}

data/tracks/typescript/exercises/robot-simulator/tslint.json

@@ -0,0 +1,127 @@
+{
+    "jsRules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-duplicate-variable": true,
+        "no-eval": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "quotemark": [
+            false,
+            "double"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ]
+    },
+    "rules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-eval": true,
+        "no-internal-module": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "no-var-keyword": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "semicolon": [
+            true,
+            "never"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ],
+        "no-namespace": true, 
+        "prefer-for-of": true,
+        "only-arrow-functions": [true, "allow-declarations"],
+        "no-var-requires": true,
+        "no-any": true,
+        "curly": true,
+        "forin": true,
+        "no-arg": true,
+        "label-position": true,
+        "no-conditional-assignment": true,
+        "no-console": [true, "log", "error"],
+        "no-construct": true,
+        "no-duplicate-variable": true,
+        "no-empty": true,
+        "no-invalid-this": [true, "check-function-in-method"],
+        "no-misused-new": true,
+        "no-null-keyword": true,
+        "no-string-literal": true,
+        "radix": true,
+        "typeof-compare": true,
+        "use-isnan": true,
+        "prefer-const": true,
+        "array-type": [true, "array-simple"],
+        "arrow-parens": true,
+        "new-parens": true,
+        "no-consecutive-blank-lines": [true,1],
+        "no-parameter-properties": true,
+        "no-unnecessary-initializer": true,
+        "object-literal-shorthand": true,
+        "object-literal-key-quotes": [true, "as-needed"]
+    }
+}