trackler 2.2.0.0 → 2.2.0.1

data/tracks/ecmascript/exercises/minesweeper/example.js

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

data/tracks/ecmascript/exercises/minesweeper/minesweeper.spec.js

@@ -0,0 +1,174 @@
+import Minesweeper from './minesweeper';
+
+
+describe('Minesweeper()', () => {
+  let minesweeper;
+
+  beforeEach(() => {
+    minesweeper = new Minesweeper();
+  });
+
+  test('handles no rows', () => {
+    expect(minesweeper.annotate([])).toEqual([]);
+  });
+
+  xtest('handles no columns', () => {
+    expect(minesweeper.annotate([''])).toEqual(['']);
+  });
+
+  xtest('handles no mines', () => {
+    const input = [
+      '   ',
+      '   ',
+      '   ',
+    ];
+    const expected = [
+      '   ',
+      '   ',
+      '   ',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles board with only mines', () => {
+    const input = [
+      '***',
+      '***',
+      '***',
+    ];
+    const expected = [
+      '***',
+      '***',
+      '***',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles mine surrounded by spaces', () => {
+    const input = [
+      '   ',
+      ' * ',
+      '   ',
+    ];
+    const expected = [
+      '111',
+      '1*1',
+      '111',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles space surrounded by mines', () => {
+    const input = [
+      '***',
+      '* *',
+      '***',
+    ];
+    const expected = [
+      '***',
+      '*8*',
+      '***',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles space surrounded by mines', () => {
+    const input = [
+      '***',
+      '* *',
+      '***',
+    ];
+    const expected = [
+      '***',
+      '*8*',
+      '***',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles horizontal line', () => {
+    const input = [' * * '];
+    const expected = ['1*2*1'];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles horizontal line, mines at edges', () => {
+    const input = ['*   *'];
+    const expected = ['*1 1*'];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles vertical line', () => {
+    const input = [
+      ' ',
+      '*',
+      ' ',
+      '*',
+      ' ',
+    ];
+    const expected = [
+      '1',
+      '*',
+      '2',
+      '*',
+      '1',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles vertical line, mines at edges', () => {
+    const input = [
+      '*',
+      ' ',
+      ' ',
+      ' ',
+      '*',
+    ];
+    const expected = [
+      '*',
+      '1',
+      ' ',
+      '1',
+      '*',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('handles cross', () => {
+    const input = [
+      '  *  ',
+      '  *  ',
+      '*****',
+      '  *  ',
+      '  *  ',
+    ];
+    const expected = [
+      ' 2*2 ',
+      '25*52',
+      '*****',
+      '25*52',
+      ' 2*2 ',
+    ];
+    expect(minesweeper.annotate(input)).toEqual(expected);
+  });
+
+  xtest('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/ecmascript/exercises/minesweeper/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "xecmascript",
+  "version": "0.0.0",
+  "description": "Exercism exercises in ECMAScript 6.",
+  "author": "Katrina Owen",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xecmascript"
+  },
+  "devDependencies": {
+    "babel-jest": "^20.0.1",
+    "babel-plugin-transform-builtin-extend": "^1.1.2",
+    "babel-preset-env": "^1.4.0",
+    "eslint": "^3.19.0",
+    "eslint-config-airbnb": "^15.0.1",
+    "eslint-plugin-import": "^2.2.0",
+    "eslint-plugin-jsx-a11y": "^5.0.1",
+    "eslint-plugin-react": "^7.0.1",
+    "jest": "^20.0.1"
+  },
+  "jest": {
+    "modulePathIgnorePatterns": [
+      "package.json"
+    ]
+  },
+  "babel": {
+    "presets": [
+      "env"
+    ],
+    "plugins": [
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
+    ]
+  },
+  "scripts": {
+    "test": "jest --no-cache ./*",
+    "watch": "jest --no-cache --watch ./*",
+    "lint": "eslint .",
+    "lint-test": "eslint . && jest --no-cache ./* "
+  },
+  "eslintConfig": {
+    "parserOptions": {
+      "ecmaVersion": 6,
+      "sourceType": "module"
+    },
+    "env": {
+      "es6": true,
+      "node": true,
+      "jest": true
+    },
+    "extends": "airbnb",
+    "rules": {
+      "import/no-unresolved": "off",
+      "import/extensions": "off"
+    }
+  },
+  "licenses": [
+    "MIT"
+  ],
+  "dependencies": {}
+}
+

data/tracks/ecmascript/exercises/nth-prime/example.js

@@ -5,9 +5,10 @@ function generatePrimes(uptoNumber) {
     return realPrimes;
   }
 
-  let currentPrime, possiblePrimes = [];
+  let currentPrime,
+    possiblePrimes = [];
   for (let i = 2; i <= uptoNumber; i++) {
-    possiblePrimes.push({ number: i, prime: true});
+    possiblePrimes.push({ number: i, prime: true });
   }
 
   for (let i = 2; i < Math.sqrt(possiblePrimes.length); i++) {

data/tracks/ecmascript/exercises/nth-prime/nth-prime.spec.js

@@ -23,5 +23,4 @@ describe('Prime', () => {
     expect(() => prime.nth(0))
       .toThrow(new Error('Prime is not possible'));
   });
-
 });

data/tracks/ecmascript/exercises/ocr-numbers/example.js

@@ -38,7 +38,7 @@ const PATTERNS = {
   9: [' _ ',
     '|_|',
     ' _|',
-    '   ']
+    '   '],
 };
 export default class Parser {
   convert(text) {
@@ -55,7 +55,7 @@ export default class Parser {
     for (let rowNumber = 0; rowNumber < lines.length; rowNumber += 4) {
       let row = '';
       for (let rowLine = 0; rowLine < 4; rowLine++) {
-        row += lines[rowNumber + rowLine] + '\n';
+        row += `${lines[rowNumber + rowLine]}\n`;
       }
       rows.push(row.slice(0, -1));
     }
@@ -76,7 +76,7 @@ export default class Parser {
   }
 
   static getDigit(text) {
-    for (let digit in PATTERNS) {
+    for (const digit in PATTERNS) {
       if (PATTERNS.hasOwnProperty(digit)) {
         if (PATTERNS[digit].join('') === text) {
           return digit;

data/tracks/ecmascript/exercises/ocr-numbers/ocr-numbers.spec.js

@@ -2,13 +2,12 @@ import Ocr from './ocr-numbers';
 const ocr = new Ocr();
 
 describe('ocr', () => {
-
   test('recognizes zero', () => {
     expect(ocr.convert(
       ' _ \n' +
       '| |\n' +
       '|_|\n' +
-      '   '
+      '   ',
     )).toBe('0');
   });
 
@@ -17,7 +16,7 @@ describe('ocr', () => {
       '   \n' +
       '  |\n' +
       '  |\n' +
-      '   '
+      '   ',
     )).toBe('1');
   });
 
@@ -26,7 +25,7 @@ describe('ocr', () => {
       ' _ \n' +
       ' _|\n' +
       '|_ \n' +
-      '   '
+      '   ',
     )).toBe('2');
   });
 
@@ -35,7 +34,7 @@ describe('ocr', () => {
       ' _ \n' +
       ' _|\n' +
       ' _|\n' +
-      '   '
+      '   ',
     )).toBe('3');
   });
 
@@ -44,7 +43,7 @@ describe('ocr', () => {
       '   \n' +
       '|_|\n' +
       '  |\n' +
-      '   '
+      '   ',
     )).toBe('4');
   });
 
@@ -53,7 +52,7 @@ describe('ocr', () => {
       ' _ \n' +
       '|_ \n' +
       ' _|\n' +
-      '   '
+      '   ',
     )).toBe('5');
   });
 
@@ -62,7 +61,7 @@ describe('ocr', () => {
       ' _ \n' +
       '|_ \n' +
       '|_|\n' +
-      '   '
+      '   ',
     )).toBe('6');
   });
 
@@ -71,7 +70,7 @@ describe('ocr', () => {
       ' _ \n' +
       '  |\n' +
       '  |\n' +
-      '   '
+      '   ',
     )).toBe('7');
   });
 
@@ -80,7 +79,7 @@ describe('ocr', () => {
       ' _ \n' +
       '|_|\n' +
       '|_|\n' +
-      '   '
+      '   ',
     )).toBe('8');
   });
 
@@ -89,7 +88,7 @@ describe('ocr', () => {
       ' _ \n' +
       '|_|\n' +
       ' _|\n' +
-      '   '
+      '   ',
     )).toBe('9');
   });
 
@@ -98,7 +97,7 @@ describe('ocr', () => {
       '    _ \n' +
       '  || |\n' +
       '  ||_|\n' +
-      '      '
+      '      ',
     )).toBe('10');
   });
 
@@ -107,7 +106,7 @@ describe('ocr', () => {
       '   \n' +
       '| |\n' +
       '| |\n' +
-      '   '
+      '   ',
     )).toBe('?');
   });
 
@@ -116,7 +115,7 @@ describe('ocr', () => {
       '       _     _        _  _ \n' +
       '  |  || |  || |  |  || || |\n' +
       '  |  ||_|  ||_|  |  ||_||_|\n' +
-      '                           '
+      '                           ',
     )).toBe('110101100');
   });
 
@@ -125,7 +124,7 @@ describe('ocr', () => {
       '       _     _           _ \n' +
       '  |  || |  || |     || || |\n' +
       '  |  | _|  ||_|  |  ||_||_|\n' +
-      '                           '
+      '                           ',
     )).toBe('11?10?1?0');
   });
 
@@ -134,7 +133,7 @@ describe('ocr', () => {
       '    _  _     _  _  _  _  _  _ \n' +
       '  | _| _||_||_ |_   ||_||_|| |\n' +
       '  ||_  _|  | _||_|  ||_| _||_|\n' +
-      '                              '
+      '                              ',
     )).toBe('1234567890');
   });
 
@@ -151,8 +150,7 @@ describe('ocr', () => {
       ' _  _  _ \n' +
       '  ||_||_|\n' +
       '  ||_| _|\n' +
-      '         '
+      '         ',
     )).toBe('123,456,789');
   });
-
 });

data/tracks/ecmascript/exercises/octal/example.js

@@ -1,6 +1,6 @@
 export default function (octal) {
   octal = octal.match(/[^0-7]/) ? octal = '0' : octal;
   return {
-    toDecimal: () => octal.split('').reduce((prev, curr) => prev * 8 + parseInt(curr), 0)
+    toDecimal: () => octal.split('').reduce((prev, curr) => prev * 8 + parseInt(curr), 0),
   };
 }

data/tracks/ecmascript/exercises/octal/octal.spec.js

@@ -1,7 +1,6 @@
 import Octal from './octal';
 
 describe('octal', () => {
-
   test('1 is decimal 1', () => {
     expect(new Octal('1').toDecimal()).toEqual(1);
   });
@@ -41,5 +40,4 @@ describe('octal', () => {
   xtest('considers the digit 8 as invalid', () => {
     expect(new Octal('12345678').toDecimal()).toEqual(0);
   });
-
 });

data/tracks/ecmascript/exercises/palindrome-products/example.js

@@ -1,7 +1,11 @@
-let isPalindrome = (num) => num.toString().split('').reverse().join('') === num.toString();
+const isPalindrome = num => num.toString().split('').reverse().join('') === num.toString();
 
-let Palindromes = (params) => {
-  let maxFactor, minFactor, maxProduct, minProduct, data;
+const Palindromes = (params) => {
+  let maxFactor,
+    minFactor,
+    maxProduct,
+    minProduct,
+    data;
   maxFactor = params.maxFactor;
   minFactor = params.minFactor || 1;
   maxProduct = 1;
@@ -10,7 +14,7 @@ let Palindromes = (params) => {
 
   for (let ii = minFactor; ii < maxFactor; ii++) {
     for (let jj = ii; jj <= maxFactor; jj++) {
-      let product = ii * jj;
+      const product = ii * jj;
       if (isPalindrome(product)) {
         data[product] = [ii, jj];
         maxProduct = Math.max(maxProduct, product);
@@ -20,17 +24,16 @@ let Palindromes = (params) => {
   }
 
   return {
-    largest:  {
-      value:   maxProduct,
-      factors: data[maxProduct]
+    largest: {
+      value: maxProduct,
+      factors: data[maxProduct],
     },
     smallest: {
-      value:   minProduct,
-      factors: data[minProduct]
-    }
+      value: minProduct,
+      factors: data[minProduct],
+    },
   };
 };
 
 export default Palindromes;
 
-

data/tracks/ecmascript/exercises/palindrome-products/palindrome-products.spec.js

@@ -1,17 +1,16 @@
 import generate from './palindrome-products';
 
-describe("Palindrome", function() {
-
-  test("largest palindrome from single digit factors", function() {
-    const palindromes = generate({maxFactor: 9});
+describe('Palindrome', () => {
+  test('largest palindrome from single digit factors', () => {
+    const palindromes = generate({ maxFactor: 9 });
     const largest = palindromes.largest;
 
     expect(largest.value).toEqual(9);
-    const containsMatch = [[3,3], [1,9]].filter(el => numericalArraysMatch(el, [3,3])).length > 0;
+    const containsMatch = [[3, 3], [1, 9]].filter(el => numericalArraysMatch(el, [3, 3])).length > 0;
     expect(containsMatch).toBe(true);
   });
 
-  xtest("largest palindrome from double digit factors", function() {
+  xtest('largest palindrome from double digit factors', () => {
     const palindromes = generate({ maxFactor: 99, minFactor: 10 });
     const largest = palindromes.largest;
 
@@ -19,7 +18,7 @@ describe("Palindrome", function() {
     expect(largest.factors).toEqual([91, 99]);
   });
 
-  xtest("smallest palindrome from double digit factors", function() {
+  xtest('smallest palindrome from double digit factors', () => {
     const palindromes = generate({ maxFactor: 99, minFactor: 10 });
     const smallest = palindromes.smallest;
 
@@ -27,7 +26,7 @@ describe("Palindrome", function() {
     expect(smallest.factors).toEqual([11, 11]);
   });
 
-  xtest("largest palindrome from triple digit factors", function() {
+  xtest('largest palindrome from triple digit factors', () => {
     const palindromes = generate({ maxFactor: 999, minFactor: 100 });
     const largest = palindromes.largest;
 
@@ -35,37 +34,35 @@ describe("Palindrome", function() {
     expect(largest.factors).toEqual([913, 993]);
   });
 
-  xtest("smallest palindrome from triple digit factors", function() {
+  xtest('smallest palindrome from triple digit factors', () => {
     const palindromes = generate({ maxFactor: 999, minFactor: 100 });
     const smallest = palindromes.smallest;
 
     expect(smallest.value).toEqual(10201);
     expect(smallest.factors).toEqual([101, 101]);
   });
-
 });
 
-function numericalArraysMatch(a, b){
+function numericalArraysMatch(a, b) {
   if (a.length !== b.length) {
     return false;
   }
-  let one = [...a].sort(numericalSort);
-  let two = [...b].sort(numericalSort);
+  const one = [...a].sort(numericalSort);
+  const two = [...b].sort(numericalSort);
   let result = true;
   let index = 0;
-  while (index < one.length){
+  while (index < one.length) {
     result = result && one[index] === two[index];
     index++;
   }
   return result;
-
 }
 
-function numericalSort(x, y){
-  if (x < y){
+function numericalSort(x, y) {
+  if (x < y) {
     return -1;
   }
-  if (x > y){
+  if (x > y) {
     return 1;
   }
   return 0;

data/tracks/ecmascript/exercises/pangram/example.js

@@ -1,15 +1,16 @@
 const notAlpha = /[^a-z]+/gi,
-      alphaLength = 26;
-let cleaned, sortedSet;
+  alphaLength = 26;
+let cleaned,
+  sortedSet;
 
 class Pangram {
 
-  constructor (candidate){
-    cleaned = (candidate.replace(notAlpha,'')).toLowerCase();
+  constructor(candidate) {
+    cleaned = (candidate.replace(notAlpha, '')).toLowerCase();
     sortedSet = new Set([...cleaned].sort());
   }
 
-  isPangram (){
+  isPangram() {
     return sortedSet.size === alphaLength;
   }
 }