trackler 2.2.1.46 → 2.2.1.47

data/tracks/ecmascript/exercises/word-search/example.js

@@ -0,0 +1,146 @@
+class WordSearch {
+  constructor(grid) {
+    this.grid = grid;
+  }
+
+  find(words) {
+    return words
+      .map(word => ({[word]: findWordInAnyDirection(word, this.grid)}))
+      .reduce((acc, oneWord) => Object.assign(acc, oneWord), {});
+  }
+}
+
+function findWordInAnyDirection(word, grid) {
+  return searchHorizontally({word, grid})
+    || flipCoordinates(searchHorizontally({word, grid: flipGrid(grid)}))
+    || searchDiagonally({word, grid})
+    || searchDiagonally({word, grid, fromTop: false});
+}
+
+function searchHorizontally({word, grid}) {
+  let rowIndex = 0;
+  let startCol;
+  let start;
+  let end;
+
+  const getCoords = () => [[rowIndex + 1, startCol], [rowIndex + 1, startCol + word.length - 1]];
+
+  const getStartCol = (word) => 1 + grid[rowIndex].indexOf(word);
+
+  while (rowIndex < grid.length) {
+    startCol = getStartCol(word);
+    if (startCol) {
+      [start, end] = getCoords();
+    } else {
+      startCol = getStartCol([...word].reverse().join(''));
+      if (startCol) {
+        [end, start] = getCoords();
+      }
+    }
+    if (start && end) {
+      return {start, end};
+    }
+    rowIndex++;
+  }
+}
+
+function flipCoordinates(coords) {
+  if (!coords) {
+    return undefined;
+  }
+  return {
+    start: coords.start.reverse(),
+    end:   coords.end.reverse()
+  };
+}
+
+function flipGrid(grid) {
+  return [...grid[0]]
+    .map((col, c) => grid.map((row, r) => grid[r][c]))
+    .map(row => row.join(''))
+}
+
+function searchDiagonally({word, grid, isReversed = false, fromTop = true}) {
+  let rIncrement = fromTop ? 1 : -1;
+  let startRow = fromTop ? 0 : grid.length - 1;
+  let endRow = fromTop ? (r) => r < grid.length : (r) => r > 0;
+  let diagonalFind = fromTop ? findAWordDiagonallyTopDown : findAWordDiagonallyBottomUp;
+
+  for (let r = startRow; (endRow)(r); r += rIncrement) {
+    for (let c = 0; c < grid[r].length; c++) {
+      const possibleCoords = diagonalFind(r, c, word, grid);
+      if (possibleCoords) {
+        return formatCoordinates(possibleCoords, isReversed);
+      }
+    }
+  }
+
+  if (!isReversed) {
+    //now find the reversed version
+    const reversedWord = [...word].reverse().join('');
+    return searchDiagonally({word: reversedWord, grid, isReversed: true, fromTop});
+  }
+}
+
+function formatCoordinates(coords, isReversed) {
+  return {
+    true:  {
+      start: coords.end,
+      end:   coords.start
+    },
+    false: coords
+  }[isReversed];
+}
+
+function findAWordDiagonallyTopDown(r, c, word, grid) {
+  function outOfRange(r, c, words, columns, letters) {
+    return r > columns - words + letters || c > columns - words + letters;
+  }
+
+  function buildCoords(startR, startC, r, c) {
+    return {
+      start: [startR, startC],
+      end:   [r + 1, c]
+    }
+  }
+
+  return diagonalFind(r, c, word, grid, 1, outOfRange, buildCoords);
+}
+
+function findAWordDiagonallyBottomUp(r, c, word, grid) {
+  function outOfRange(r, c, words, columns, letters) {
+    return r < words - letters - 1 || c > columns - words + letters;
+  }
+
+  function buildCoords(startR, startC, r, c) {
+    return {
+      start: [startR, startC],
+      end:   [r + 1, c]
+    };
+  }
+
+  return diagonalFind(r, c, word, grid, -1, outOfRange, buildCoords);
+}
+
+function diagonalFind(r, c, word, grid, rIncrement, outOfRange, buildCoords) {
+  let foundLetters = "";
+  let startR = r + 1;
+  let startC = c + 1;
+  for (let letter of word) {
+    if (outOfRange(r, c, word.length, grid[r].length, foundLetters.length)) {
+      return undefined;
+    }
+    let foundLetter = grid[r].charAt(c++);
+    if (foundLetter !== letter) {
+      return undefined;
+    }
+    foundLetters += foundLetter;
+    if (foundLetters === word) {
+      return buildCoords(startR, startC, r, c);
+    }
+    r += rIncrement;
+  }
+}
+
+
+module.exports = WordSearch;

data/tracks/ecmascript/exercises/word-search/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.3",
+    "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.4"
+  },
+  "jest": {
+    "modulePathIgnorePatterns": [
+      "package.json"
+    ]
+  },
+  "babel": {
+    "presets": [
+      "env"
+    ],
+    "plugins": [
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ],
+      ["transform-regenerator"]
+    ]
+  },
+  "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/word-search/word-search.spec.js

@@ -0,0 +1,626 @@
+import WordSearch from './word-search';
+
+
+describe('single line grids', () => {
+  test('Should accept an initial game grid', () => {
+    const grid = ["jefblpepre"];
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch instanceof WordSearch).toEqual(true);
+  });
+
+  xtest('can accept a target search word', () => {
+
+    const grid = ["jefblpepre"];
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["glasnost"])).toEqual({"glasnost": undefined});
+  });
+
+  xtest('should locate a word written left to right', () => {
+    const grid = ["clojurermt"];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [1, 1],
+        "end":   [1, 7]
+      }
+    };
+
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["clojure"])).toEqual(expectedResults);
+  });
+
+  xtest('can locate a left to right word in a different position', () => {
+
+    const grid = ["mtclojurer"];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [1, 3],
+        "end":   [1, 9]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["clojure"])).toEqual(expectedResults);
+
+  });
+
+  xtest('can locate a different left to right word', () => {
+
+    const grid = ["coffeelplx"];
+
+    const expectedResults = {
+      "coffee": {
+        "start": [1, 1],
+        "end":   [1, 6]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["coffee"])).toEqual(expectedResults);
+
+  });
+
+  xtest('can locate that different left to right word in a different position', () => {
+
+    const grid = ["xcoffeezlp"];
+
+    const expectedResults = {
+      "coffee": {
+        "start": [1, 2],
+        "end":   [1, 7]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["coffee"])).toEqual(expectedResults);
+
+  });
+
+});
+
+describe('multi line grids', () => {
+  xtest('can locate a left to right word in a two line grid', () => {
+
+    const grid = [
+      "jefblpepre",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [2, 1],
+        "end":   [2, 7]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["clojure"])).toEqual(expectedResults);
+
+  });
+
+  xtest('can locate a left to right word in a different position in a two line grid', () => {
+
+    const grid = [
+      "jefblpepre",
+      "tclojurerm"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [2, 2],
+        "end":   [2, 8]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["clojure"])).toEqual(expectedResults);
+
+  });
+
+  xtest('can locate a left to right word in a three line grid', () => {
+
+    const grid = [
+      "camdcimgtc",
+      "jefblpepre",
+      "clojurermt",
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [3, 1],
+        "end":   [3, 7]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["clojure"])).toEqual(expectedResults);
+
+  });
+
+  xtest('can locate a left to right word in a ten line grid', () => {
+
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end":   [10, 7]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["clojure"])).toEqual(expectedResults);
+
+  });
+
+  xtest('can locate a left to right word in a different position in a ten line grid', () => {
+
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "clojurermt",
+      "jalaycalmp"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [9, 1],
+        "end":   [9, 7]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["clojure"])).toEqual(expectedResults);
+
+  });
+
+  xtest('can locate a different left to right word in a ten line grid', () => {
+
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "clojurermt",
+      "jalaycalmp"
+    ];
+
+    const expectedResults = {
+      "scree": {
+        "start": [7, 1],
+        "end":   [7, 5]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["scree"])).toEqual(expectedResults);
+
+  });
+
+});
+
+
+describe('can find multiple words', () => {
+  xtest('can find two words written left to right', () => {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt",
+      "xjavamtzlp"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end":   [10, 7]
+      },
+      "java":    {
+        "start": [11, 2],
+        "end":   [11, 5]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["java", "clojure"])).toEqual(expectedResults);
+
+  });
+});
+
+describe('different directions', () => {
+
+
+
+  xtest('should locate a single word written right to left', () => {
+    const grid = ["rixilelhrs"];
+
+    const expectedResults = {
+      "elixir": {
+        "start": [1, 6],
+        "end":   [1, 1]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["elixir"])).toEqual(expectedResults);
+
+  });
+
+  xtest('should locate multiple words written in different horizontal directions', ()=> {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end":   [10, 7]
+      },
+      "elixir":    {
+        "start": [5, 6],
+        "end":   [5, 1]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["elixir", "clojure"])).toEqual(expectedResults);
+
+  });
+});
+
+describe('vertical directions', ()=> {
+  xtest('should locate words written top to bottom', ()=> {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end":   [10, 7]
+      },
+      "elixir":    {
+        "start": [5, 6],
+        "end":   [5, 1]
+      },
+      "ecmascript": {
+        "start": [1, 10],
+        "end":   [10, 10]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["elixir", "clojure", "ecmascript"])).toEqual(expectedResults);
+
+  });
+
+  xtest('should locate words written bottom to top', ()=> {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end":   [10, 7]
+      },
+      "elixir":    {
+        "start": [5, 6],
+        "end":   [5, 1]
+      },
+      "ecmascript": {
+        "start": [1, 10],
+        "end":   [10, 10]
+      },
+      "rust":{
+        "start": [5, 9],
+        "end":   [2, 9]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find(["elixir", "clojure", "ecmascript", "rust"])).toEqual(expectedResults);
+
+  });
+  xtest('should locate words written top left to bottom right', ()=> {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end": [10, 7]
+      },
+      "elixir": {
+        "start": [5, 6],
+        "end": [5, 1]
+      },
+      "ecmascript": {
+        "start": [1, 10],
+        "end": [10, 10]
+      },
+      "rust": {
+        "start": [5, 9],
+        "end": [2, 9]
+      },
+      "java": {
+        "start": [1, 1],
+        "end": [4, 4]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find([
+      "clojure",
+      "elixir",
+      "ecmascript",
+      "rust",
+      "java"
+    ])).toEqual(expectedResults);
+
+  });
+
+  xtest('should locate words written bottom right to top left', ()=> {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end": [10, 7]
+      },
+      "elixir": {
+        "start": [5, 6],
+        "end": [5, 1]
+      },
+      "ecmascript": {
+        "start": [1, 10],
+        "end": [10, 10]
+      },
+      "rust": {
+        "start": [5, 9],
+        "end": [2, 9]
+      },
+      "java": {
+        "start": [1, 1],
+        "end": [4, 4]
+      },
+      "lua": {
+        "start": [9, 8],
+        "end": [7, 6]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find([
+      "clojure",
+      "elixir",
+      "ecmascript",
+      "rust",
+      "java",
+      "lua"
+    ])).toEqual(expectedResults);
+
+  });
+
+  xtest('should locate words written bottom left to top right', ()=> {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end": [10, 7]
+      },
+      "elixir": {
+        "start": [5, 6],
+        "end": [5, 1]
+      },
+      "ecmascript": {
+        "start": [1, 10],
+        "end": [10, 10]
+      },
+      "rust": {
+        "start": [5, 9],
+        "end": [2, 9]
+      },
+      "java": {
+        "start": [1, 1],
+        "end": [4, 4]
+      },
+      "lua": {
+        "start": [9, 8],
+        "end": [7, 6]
+      },
+      "lisp": {
+        "start": [6, 3],
+        "end": [3, 6]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find([
+      "clojure",
+      "elixir",
+      "ecmascript",
+      "rust",
+      "java",
+      "lua",
+      "lisp"
+    ])).toEqual(expectedResults);
+
+  });
+
+  xtest('should locate words written top right to bottom left', ()=> {
+    const grid = [
+      "jefblpepre",
+      "camdcimgtc",
+      "oivokprjsm",
+      "pbwasqroua",
+      "rixilelhrs",
+      "wolcqlirpc",
+      "screeaumgr",
+      "alxhpburyi",
+      "jalaycalmp",
+      "clojurermt"
+    ];
+
+    const expectedResults = {
+      "clojure": {
+        "start": [10, 1],
+        "end": [10, 7]
+      },
+      "elixir": {
+        "start": [5, 6],
+        "end": [5, 1]
+      },
+      "ecmascript": {
+        "start": [1, 10],
+        "end": [10, 10]
+      },
+      "rust": {
+        "start": [5, 9],
+        "end": [2, 9]
+      },
+      "java": {
+        "start": [1, 1],
+        "end": [4, 4]
+      },
+      "lua": {
+        "start": [9, 8],
+        "end": [7, 6]
+      },
+      "lisp": {
+        "start": [6, 3],
+        "end": [3, 6]
+      },
+      "ruby": {
+        "start": [6, 8],
+        "end": [9, 5]
+      }
+    };
+
+    const wordSearch = new WordSearch(grid);
+
+    expect(wordSearch.find([
+      "clojure",
+      "elixir",
+      "ecmascript",
+      "rust",
+      "java",
+      "lua",
+      "lisp",
+      "ruby"
+    ])).toEqual(expectedResults);
+
+  });
+
+});