puzzle-lib 1.3.0 → 1.6.0

package/src/Semaphore/SemaphoreEncoding.ts

@@ -0,0 +1,48 @@
+import {SemaphoreDirection} from './SemaphoreDirection';
+
+export enum SemaphoreEncoding {
+  None = 0,
+
+  // Letters
+  LetterA = SemaphoreDirection.SouthWest | SemaphoreDirection.South,
+  LetterB = SemaphoreDirection.West | SemaphoreDirection.South,
+  LetterC = SemaphoreDirection.NorthWest | SemaphoreDirection.South,
+  LetterD = SemaphoreDirection.North | SemaphoreDirection.South,
+  LetterE = SemaphoreDirection.NorthEast | SemaphoreDirection.South,
+  LetterF = SemaphoreDirection.East | SemaphoreDirection.South,
+  LetterG = SemaphoreDirection.SouthEast | SemaphoreDirection.South,
+  LetterH = SemaphoreDirection.SouthWest | SemaphoreDirection.West,
+  LetterI = SemaphoreDirection.SouthWest | SemaphoreDirection.NorthWest,
+  LetterJ = SemaphoreDirection.North | SemaphoreDirection.East,
+  LetterK = SemaphoreDirection.SouthWest | SemaphoreDirection.North,
+  LetterL = SemaphoreDirection.SouthWest | SemaphoreDirection.NorthEast,
+  LetterM = SemaphoreDirection.SouthWest | SemaphoreDirection.East,
+  LetterN = SemaphoreDirection.SouthWest | SemaphoreDirection.SouthEast,
+  LetterO = SemaphoreDirection.West | SemaphoreDirection.NorthWest,
+  LetterP = SemaphoreDirection.West | SemaphoreDirection.North,
+  LetterQ = SemaphoreDirection.West | SemaphoreDirection.NorthEast,
+  LetterR = SemaphoreDirection.West | SemaphoreDirection.East,
+  LetterS = SemaphoreDirection.West | SemaphoreDirection.SouthEast,
+  LetterT = SemaphoreDirection.NorthWest | SemaphoreDirection.North,
+  LetterU = SemaphoreDirection.NorthWest | SemaphoreDirection.NorthEast,
+  LetterV = SemaphoreDirection.North | SemaphoreDirection.SouthEast,
+  LetterW = SemaphoreDirection.East | SemaphoreDirection.NorthEast,
+  LetterX = SemaphoreDirection.SouthEast | SemaphoreDirection.NorthEast,
+  LetterY = SemaphoreDirection.NorthWest | SemaphoreDirection.East,
+  LetterZ = SemaphoreDirection.SouthEast | SemaphoreDirection.East,
+
+  // Numbers
+  Number1 = SemaphoreDirection.SouthWest | SemaphoreDirection.South,
+  Number2 = SemaphoreDirection.West | SemaphoreDirection.South,
+  Number3 = SemaphoreDirection.NorthWest | SemaphoreDirection.South,
+  Number4 = SemaphoreDirection.North | SemaphoreDirection.South,
+  Number5 = SemaphoreDirection.NorthEast | SemaphoreDirection.South,
+  Number6 = SemaphoreDirection.East | SemaphoreDirection.South,
+  Number7 = SemaphoreDirection.SouthEast | SemaphoreDirection.South,
+  Number8 = SemaphoreDirection.SouthWest | SemaphoreDirection.West,
+  Number9 = SemaphoreDirection.SouthWest | SemaphoreDirection.NorthWest,
+  Number0 = SemaphoreDirection.SouthWest | SemaphoreDirection.North,
+
+  // Formatting
+  FormattingNumber = SemaphoreDirection.North | SemaphoreDirection.NorthEast,
+}

package/src/Semaphore/SemaphoreStream.ts

@@ -0,0 +1,89 @@
+import {EncodingCategory} from '../Common/EncodingCategory';
+import {SemaphoreCharacter} from './SemaphoreCharacter';
+import {SemaphoreData} from './SemaphoreData';
+import {SemaphoreEncoding} from './SemaphoreEncoding';
+
+interface SemaphoreStreamState {
+  numberMode: boolean;
+}
+
+export class SemaphoreStream {
+  private readonly _chars: SemaphoreEncoding[] = [];
+  private readonly _state: SemaphoreStreamState;
+  private _currentStr = '';
+  private _processPosition = 0;
+
+  constructor(chars?: SemaphoreEncoding[]) {
+    if (chars) {
+      this._chars = Array.from(chars);
+    }
+
+    this._state = {
+      numberMode: false,
+    };
+
+    this.invalidate();
+  }
+
+  get chars() {
+    return this._chars;
+  }
+
+  set chars(value: SemaphoreEncoding[]) {
+    this.clear();
+
+    for (const ch of value) {
+      this._chars.push(ch);
+    }
+  }
+
+  append(ch: SemaphoreCharacter) {
+    this._chars.push(ch.valueOf());
+  }
+
+  clear() {
+    this._chars.length = 0;
+    this.invalidate();
+  }
+
+  space() {
+    this._chars.push(SemaphoreEncoding.None);
+  }
+
+  toString() {
+    this.update();
+    return this._currentStr;
+  }
+
+  private invalidate() {
+    this._currentStr = '';
+    this._processPosition = 0;
+  }
+
+  private update() {
+    while (this._processPosition < this._chars.length) {
+      const ch = this._chars[this._processPosition];
+
+      if (ch === SemaphoreEncoding.None) {
+        this._state.numberMode = false;
+        this._currentStr += ' ';
+      } else if (ch === SemaphoreEncoding.FormattingNumber) {
+        this._state.numberMode = true;
+        this._currentStr += '#';
+      } else {
+        const category =
+          EncodingCategory.Punctuation |
+          (this._state.numberMode
+            ? EncodingCategory.Number
+            : EncodingCategory.Letter);
+        const exact = SemaphoreData.instance.lookup(ch, category).exact;
+
+        if (exact.length > 0) {
+          this._currentStr += exact[0].toString();
+        }
+      }
+
+      this._processPosition++;
+    }
+  }
+}

package/src/WordSearch/Point.ts

@@ -0,0 +1,4 @@
+export interface Point {
+  x: number;
+  y: number;
+}

package/src/WordSearch/Result.ts

@@ -0,0 +1,10 @@
+import {Point} from './Point';
+
+export class Result {
+  word: string;
+  points: Point[];
+  constructor(word: string, wordPoints: Point[]) {
+    this.word = word;
+    this.points = Array.from(wordPoints);
+  }
+}

package/src/WordSearch/WordSearchDirection.ts

@@ -0,0 +1,6 @@
+export enum WordSearchDirection {
+  None = 0,
+  Cardinal = 1,
+  Diagonal = 2,
+  CardinalAndDiagonal = 3,
+}

package/src/WordSearch/WordSearchSolver.ts

@@ -0,0 +1,271 @@
+import trie = require('trie-prefix-tree');
+
+import {Point} from './Point';
+import {Result} from './Result';
+import {WordSearchDirection} from './WordSearchDirection';
+
+export enum WordSearchSpaceTreatment {
+  None = 0,
+  RemoveWithinPuzzle = 1,
+  RemoveAll = 2,
+}
+
+export class WordSearchSolver {
+  // The grid of letters which makes up the wordsearch puzzle
+  private _matrix: string[][];
+  // Transpositions to apply when finding words
+  private _directions: number[][];
+  // Potential words to find in the letter grid
+  private _targets: ReturnType<typeof trie>;
+  // Should we search for words not following a line
+  private _canBend: boolean;
+  // What should we do with spaces
+  private _spaceTreatment: WordSearchSpaceTreatment;
+
+  constructor() {
+    // Use empty grid and list by default
+    this._matrix = [[]];
+    this._targets = trie([]);
+    // Use both sets of directions by default
+    this._directions = [
+      // Cardinal directions
+      [0, 1],
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      // Diagonal
+      [1, 1],
+      [-1, -1],
+      [1, -1],
+      [-1, 1],
+    ];
+    this._canBend = false;
+    this._spaceTreatment = WordSearchSpaceTreatment.None;
+  }
+
+  setWords(words: string[]) {
+    this._targets = trie([]);
+    for (const full of words) {
+      if (full === null || typeof full === 'undefined') {
+        throw new Error('Invalid input in WordSearchSolver.findWords()');
+      }
+      const word = full.trim();
+      if (word !== '') {
+        this._targets.addWord(word);
+      } else {
+        throw new Error('Cannot find an empty string in the wordsearch');
+      }
+    }
+  }
+
+  parseGrid(gridInputText: string) {
+    const lines = gridInputText.split(/\r?\n/);
+    const grid: string[][] = [];
+    for (const line of lines) {
+      grid.push(line.split(''));
+    }
+    this.setGrid(grid);
+  }
+
+  setGrid(matrix: string[][]) {
+    this._matrix = matrix;
+    this.checkSpaces();
+  }
+
+  setDirections(direction: WordSearchDirection) {
+    this._directions = [];
+    if (
+      direction === WordSearchDirection.Cardinal ||
+      direction === WordSearchDirection.CardinalAndDiagonal
+    ) {
+      this._directions = this._directions.concat([
+        [0, 1],
+        [-1, 0],
+        [1, 0],
+        [0, -1],
+      ]);
+    }
+    if (
+      direction === WordSearchDirection.Diagonal ||
+      direction === WordSearchDirection.CardinalAndDiagonal
+    ) {
+      this._directions = this._directions.concat([
+        [1, 1],
+        [-1, -1],
+        [1, -1],
+        [-1, 1],
+      ]);
+    }
+  }
+
+  setSpaceTreatment(treatment: WordSearchSpaceTreatment) {
+    this._spaceTreatment = treatment;
+
+    if (this._matrix.length > 0) {
+      this.checkSpaces();
+    }
+  }
+
+  setCanBend(canBend: boolean) {
+    this._canBend = canBend;
+  }
+
+  findWords(): Result[] {
+    const results: Result[] = [];
+    const numRows = this._matrix.length;
+    for (let yIdx = 0; yIdx < numRows; yIdx++) {
+      const lineLength = this._matrix[yIdx].length;
+      for (let xIdx = 0; xIdx < lineLength; xIdx++) {
+        const p: Point = {x: xIdx, y: yIdx};
+        const pointResults = this.search(p);
+        results.push(...pointResults);
+      }
+    }
+    return results;
+  }
+
+  private search(start: Point): Result[] {
+    const results: Result[] = [];
+    if (this._canBend) {
+      const history: Point[] = [];
+      const dfsResults = this.dfsCheck(start, new Set(), history);
+      results.push(...dfsResults);
+    } else {
+      for (const translation of this._directions) {
+        const directionalResults = this.lineCheck(start, translation);
+        results.push(...directionalResults);
+      }
+    }
+    return results;
+  }
+
+  private dfsCheck(
+    start: Point,
+    visited: Set<Point>,
+    history: Point[]
+  ): Result[] {
+    const results: Result[] = [];
+
+    if (visited.has(start)) {
+      return results;
+    }
+
+    visited.add(start);
+    history.push(start);
+
+    let currentString = '';
+
+    for (let i = 0; i < history.length; i++) {
+      const pt = history[i];
+      currentString = currentString + this._matrix[pt.y][pt.x];
+    }
+
+    const wordsWithPrefix = this._targets.getPrefix(currentString);
+    if (wordsWithPrefix.length === 0) {
+      visited.delete(start);
+      history.pop();
+      return results;
+    }
+
+    if (wordsWithPrefix.indexOf(currentString) !== -1) {
+      const foundWord = new Result(currentString, history);
+      results.push(foundWord);
+    }
+
+    for (const translation of this._directions) {
+      const next: Point = {
+        x: start.x + translation[0],
+        y: start.y + translation[1],
+      };
+
+      if (this.isInBounds(next)) {
+        results.push(...this.dfsCheck(next, visited, history));
+      }
+    }
+
+    visited.delete(start);
+    history.pop();
+
+    return results;
+  }
+
+  private lineCheck(start: Point, direction: number[]): Result[] {
+    const results: Result[] = [];
+
+    // Working set
+    let currentPoint = start;
+    let currentString = '';
+    const pointHistory = [];
+    while (this.isInBounds(currentPoint)) {
+      currentString =
+        currentString + this._matrix[currentPoint.y][currentPoint.x];
+
+      // Get the candidates with the current prefix string
+      const wordsWithPrefix = this._targets.getPrefix(currentString);
+
+      // No point in going on, we've run out of possibilities
+      if (wordsWithPrefix.length === 0) {
+        break;
+      }
+
+      const p: Point = {x: currentPoint.x, y: currentPoint.y};
+      pointHistory.push(p);
+
+      // Is a candidate an exact match for the current search string? Save it.
+      if (wordsWithPrefix.indexOf(currentString) !== -1) {
+        const foundWord = new Result(currentString, pointHistory);
+        results.push(foundWord);
+      }
+      const next: Point = {
+        x: currentPoint.x + direction[0],
+        y: currentPoint.y + direction[1],
+      };
+      currentPoint = next;
+    }
+
+    return results;
+  }
+
+  private isInBounds(point: Point): boolean {
+    if (point.y < 0 || point.y >= this._matrix.length) {
+      return false;
+    }
+    if (point.x < 0 || point.x >= this._matrix[point.y].length) {
+      return false;
+    }
+    return true;
+  }
+
+  private checkSpaces(): void {
+    if (
+      this._matrix.length === 0 ||
+      this._spaceTreatment === WordSearchSpaceTreatment.None
+    ) {
+      return;
+    }
+
+    const nextMatrix = [];
+    for (let yIdx = 0; yIdx < this._matrix.length; yIdx++) {
+      const line = [];
+      let inPuzzle = false;
+      for (let xIdx = 0; xIdx < this._matrix[yIdx].length; xIdx++) {
+        const letter = this._matrix[yIdx][xIdx];
+        if (letter !== ' ') {
+          inPuzzle = true;
+        }
+        if (
+          this._spaceTreatment === WordSearchSpaceTreatment.RemoveAll &&
+          letter !== ' '
+        ) {
+          line.push(this._matrix[yIdx][xIdx]);
+        } else if (letter !== ' ' && inPuzzle) {
+          line.push(this._matrix[yIdx][xIdx]);
+        }
+      }
+      if (line.length > 0) {
+        nextMatrix.push(line);
+      }
+    }
+    this._matrix = nextMatrix;
+  }
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+export {BrailleCharacter} from './Braille/BrailleCharacter';
+export {BrailleDot} from './Braille/BrailleDot';
+export {BrailleEncoding} from './Braille/BrailleEncoding';
+export {BrailleStream} from './Braille/BrailleStream';
+export {AutoKeyString} from './Cipher/AutoKeyString';
+export {CaesarString} from './Cipher/CaesarString';
+export {KeyedCipherStringBase} from './Cipher/KeyedCipherStringBase';
+export {VigenereString} from './Cipher/VigenereString';
+export {CharacterImage} from './Common/CharacterImage';
+export {EncodingCategory} from './Common/EncodingCategory';
+export {EncodingEntry} from './Common/EncodingEntry';
+export {InlineSvg} from './Common/InlineSvg';
+export {CharacterAutoConvert} from './Conversion/CharacterAutoConvert';
+export {CharacterConversion} from './Conversion/CharacterConversion';
+export {CharacterEncoding} from './Conversion/CharacterEncoding';
+export {CharacterTableEntry} from './Conversion/CharacterTableEntry';
+export {SignificantFigures} from './Conversion/SignificantFigures';
+export {StringAutoConvert} from './Conversion/StringAutoConvert';
+export {MorseCharacter} from './Morse/MorseCharacter';
+export {MorseEncoding} from './Morse/MorseEncoding';
+export {MorseString} from './Morse/MorseString';
+export {NatoCharacter} from './Nato/NatoCharacter';
+export {NatoData} from './Nato/NatoData';
+export {NavalFlags} from './NavalFlags/NavalFlags';
+export {Resistor} from './Resistor/Resistor';
+export {ResistorColorEntry} from './Resistor/ResistorColorEntry';
+export {SemaphoreCharacter} from './Semaphore/SemaphoreCharacter';
+export {SemaphoreDegrees} from './Semaphore/SemaphoreDegrees';
+export {SemaphoreDirection} from './Semaphore/SemaphoreDirection';
+export {SemaphoreEncoding} from './Semaphore/SemaphoreEncoding';
+export {SemaphoreStream} from './Semaphore/SemaphoreStream';
+export {Point as WordSearchPoint} from './WordSearch/Point';
+export {Result as WordSearchResult} from './WordSearch/Result';
+export {WordSearchDirection} from './WordSearch/WordSearchDirection';
+export {
+  WordSearchSolver,
+  WordSearchSpaceTreatment,
+} from './WordSearch/WordSearchSolver';

package/src/trie-prefix-tree.d.ts

@@ -0,0 +1,70 @@
+// Type definitions for trie-prefix-tree 1.5
+// Project: https://github.com/lyndseybrowning/trie-prefix#readme
+// Definitions by: James Lismore <https://github.com/jlismore>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+// The published typings don't seem to work correctly with ES6 module syntax,
+// switch to CommonJS module syntax instead.
+declare module 'trie-prefix-tree' {
+  function Trie(strings: string[]): {
+    /**
+     * Get a string representation of the trie
+     */
+    dump(spacer?: number): string;
+    /**
+     * Get the generated raw trie object
+     */
+    tree(): {};
+    /**
+     * Add a new word to the trie
+     */
+    addWord(word: string): ReturnType<typeof Trie>;
+    /**
+     * Remove an existing word from the trie
+     */
+    removeWord(word: string): ReturnType<typeof Trie>;
+    /**
+     * Check a prefix is valid
+     * @returns Boolean
+     */
+    isPrefix(word: string): boolean;
+    /**
+     * Count the number of words with the given prefixSearch
+     * @returns Number
+     */
+    countPrefix(word: string): number;
+    /**
+     * Get a list of all words in the trie with the given prefix
+     * @returns Array
+     */
+    getPrefix(word: string, sort?: boolean): string[];
+    /**
+     * Get a random word in the trie with the given prefix
+     * @returns Array
+     */
+    getRandomWordWithPrefix(prefix: string): string;
+    /**
+     * Get all words in the trie
+     * @returns Array
+     */
+    getWords(sorted?: boolean): string[];
+    /**
+     * Check the existence of a word in the trie
+     * @returns Boolean
+     */
+    hasWord(word: string): boolean;
+    /**
+     * Get a list of valid anagrams that can be made from the given letters
+     * @returns Array
+     */
+    getAnagrams(word: string): string[];
+    /**
+     * Get a list of all sub-anagrams that can be made from the given letters
+     * @returns Array
+     */
+    getSubAnagrams(word: string): string[];
+  };
+
+  export = Trie;
+}