trackler 2.2.1.130 → 2.2.1.131

data/tracks/typescript/exercises/minesweeper/README.md

@@ -0,0 +1,55 @@
+# Minesweeper
+
+Add the numbers to a minesweeper board.
+
+Minesweeper is a popular game where the user has to find the mines using
+numeric hints that indicate how many mines are directly adjacent
+(horizontally, vertically, diagonally) to a square.
+
+In this exercise you have to create some code that counts the number of
+mines adjacent to a square and transforms boards like this (where `*`
+indicates a mine):
+
+    +-----+
+    | * * |
+    |  *  |
+    |  *  |
+    |     |
+    +-----+
+
+into this:
+
+    +-----+
+    |1*3*1|
+    |13*31|
+    | 2*2 |
+    | 111 |
+    +-----+
+
+## 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
+```
+
+
+
+## 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/minesweeper/minesweeper.example.ts

@@ -0,0 +1,58 @@
+const MINE = '*'
+
+const DELTAS = [
+    [-1, -1],
+    [-1, 0],
+    [-1, 1],
+    [1, 1],
+    [1, 0],
+    [1, -1],
+    [0, 1],
+    [0, -1],
+]
+
+class Minesweeper {
+    annotate(rows: string[]) {
+        if (noDataPresent(rows)) {
+            return rows
+        }
+
+        const inputBoard = rows.map((row) => [...row])
+
+        const result = inputBoard.map((row, x) => [...row].map((cell, y) => cellToMineOrCount(cell, inputBoard, x, y)))
+
+        return stringify(result as string[][])
+    }
+}
+
+function cellToMineOrCount(cell: string, inputBoard: string[][], x: number, y: number) {
+    if (cell === MINE) {
+        return MINE
+    }
+    return countAdjacentMines(inputBoard, x, y) || " "
+}
+
+function countAdjacentMines(board: string[][], x: number, y: number) {
+    return DELTAS
+        .filter((d) => adjacentSquareIsOnBoard(board, x, d))
+        .filter((d) => adjacentSquareHasMine(board, x, y, d))
+        .length
+}
+
+function stringify(board: string[][]) {
+    return board.map((row) => row.join(''))
+}
+
+function noDataPresent(rows: string[]) {
+    return rows.length === 0 || rows[0].length === 0
+}
+
+function adjacentSquareIsOnBoard(board: string[][], x: number, d: number[]) {
+    return board[x + d[0]]
+}
+
+function adjacentSquareHasMine(board: string[][], x: number, y: number, d: number[]) {
+    return board[x + d[0]][y + d[1]] === MINE
+}
+
+export default Minesweeper

data/tracks/typescript/exercises/minesweeper/minesweeper.test.ts

@@ -0,0 +1,173 @@
+import Minesweeper from './minesweeper'
+
+describe('Minesweeper()', () => {
+    let minesweeper: Minesweeper
+
+    beforeEach(() => {
+        minesweeper = new Minesweeper()
+    })
+
+    it('handles no rows', () => {
+        expect(minesweeper.annotate([])).toEqual([])
+    })
+
+    xit('handles no columns', () => {
+        expect(minesweeper.annotate([''])).toEqual([''])
+    })
+
+    xit('handles no mines', () => {
+        const input = [
+            '   ',
+            '   ',
+            '   ',
+        ]
+        const expected = [
+            '   ',
+            '   ',
+            '   ',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles board with only mines', () => {
+        const input = [
+            '***',
+            '***',
+            '***',
+        ]
+        const expected = [
+            '***',
+            '***',
+            '***',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles mine surrounded by spaces', () => {
+        const input = [
+            '   ',
+            ' * ',
+            '   ',
+        ]
+        const expected = [
+            '111',
+            '1*1',
+            '111',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles space surrounded by mines', () => {
+        const input = [
+            '***',
+            '* *',
+            '***',
+        ]
+        const expected = [
+            '***',
+            '*8*',
+            '***',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles space surrounded by mines', () => {
+        const input = [
+            '***',
+            '* *',
+            '***',
+        ]
+        const expected = [
+            '***',
+            '*8*',
+            '***',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles horizontal line', () => {
+        const input = [' * * ']
+        const expected = ['1*2*1']
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles horizontal line, mines at edges', () => {
+        const input = ['*   *']
+        const expected = ['*1 1*']
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles vertical line', () => {
+        const input = [
+            ' ',
+            '*',
+            ' ',
+            '*',
+            ' ',
+        ]
+        const expected = [
+            '1',
+            '*',
+            '2',
+            '*',
+            '1',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles vertical line, mines at edges', () => {
+        const input = [
+            '*',
+            ' ',
+            ' ',
+            ' ',
+            '*',
+        ]
+        const expected = [
+            '*',
+            '1',
+            ' ',
+            '1',
+            '*',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles cross', () => {
+        const input = [
+            '  *  ',
+            '  *  ',
+            '*****',
+            '  *  ',
+            '  *  ',
+        ]
+        const expected = [
+            ' 2*2 ',
+            '25*52',
+            '*****',
+            '25*52',
+            ' 2*2 ',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+
+    xit('handles large board', () => {
+        const input = [
+            ' *  * ',
+            '  *   ',
+            '    * ',
+            '   * *',
+            ' *  * ',
+            '      ',
+        ]
+        const expected = [
+            '1*22*1',
+            '12*322',
+            ' 123*2',
+            '112*4*',
+            '1*22*2',
+            '111111',
+        ]
+        expect(minesweeper.annotate(input)).toEqual(expected)
+    })
+})

data/tracks/typescript/exercises/minesweeper/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": "^21.1.5",
+    "@types/node": "^8.0.47",
+    "jest": "^21.2.1",
+    "ts-jest": "^21.1.3",
+    "tslint": "^5.8.0",
+    "typescript": "^2.5.3"
+  },
+  "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/minesweeper/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/minesweeper/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"]
+    }
+}