Class Solver

Constructed using 2d board array Returns: Strategy used to solve each step or null if solved or unsolvable error Solution 2d board array

Hierarchy

  • Solver

Constructors

constructor

Properties

algorithm allHints board cellBoard emptyCells hint placedCount solution solved

Methods

addEveryEmptyCell applyHint getAllHints getBoard getNotes getNotesString getPlacedCount getSolution isFinished nextStep placeValues removeNotes setAllHints setEmptyCells setHint setNotes

Constructors

constructor

  • Creates solver object

    Parameters

    • board: string[][]

      2d board array

    • algorithm: StrategyEnum[] = ...

      optional parameter specifying order to apply strategies

    • Optional notes: string[][]

      optional parameter specifying initial state of the notes (one array with an array for each cell in order)

    • Optional solution: string[][]

    Returns Solver

Properties

Private algorithm

algorithm: StrategyEnum[]

Private allHints

allHints: Hint[]

Private board

board: Cell[][]

Private cellBoard

cellBoard: CellBoard

Private emptyCells

emptyCells: Cell[][]

Private hint

hint: Hint

Private placedCount

placedCount: number

Private solution

solution: string[][]

Private solved

solved: boolean

Methods

Private addEveryEmptyCell

  • Adds every empty cell in board to cells

    Parameters

    • cells: Cell[][]

      cell array

    Returns void

Private applyHint

  • Applies hint (places values according to hint)

    Returns void

getAllHints

  • Gets an array containing Hint objects for each strategy that can be used at this step

    Returns

    array of Hints for all applicable strategies at this step

    Returns Hint[]

getBoard

  • Returns current state of the board being solved

    Returns

    current board array

    Returns string[][]

getNotes

  • Returns current notes stored by the Solver

    Returns

    array of notes arrays in order (one array with an array for each cell)

    Returns string[][]

getNotesString

  • Returns current notes stored by the Solver

    Returns

    string of notes for each cell going left to right and top to bottom, "0"=note not in cell, "1"=note in cell

    Returns string

getPlacedCount

  • Returns current number of placed values (including givens)

    Returns

    number of placed values

    Returns number

getSolution

  • Gets solution array if solved, otherwise throws error

    Returns

    solution array

    Throws

    CustomError Thrown if puzzle isn't solved

    Returns string[][]

Private isFinished

  • Checks if puzzle is finished

    Returns

    true if puzzle is finished

    Parameters

    • cells: Cell[][]

      empty cells

    Returns boolean

nextStep

  • Takes the next step in solving puzzle

    Returns

    hint used or null if finished

    Throws

    CustomError Thrown if board is unsolvable

    Returns Hint

Private placeValues

  • Places values from given cells into board

    Parameters

    • cells: Cell[]

      cells array

    Returns void

Private removeNotes

  • Removes given notes from board

    Parameters

    • notes: Group[]

      Groups containing notes to remove

    • amend: boolean

      If true than cell notes are amended by adding all possible notes to cell before removing any

    Returns void

Private setAllHints

  • Creates a Hint object for each strategy that can be used at this step and adds it to allHints

    Returns void

Private setEmptyCells

  • Sets emptyCells to be all of the empty cells in the board

    Returns void

Private setHint

  • Gets and sets the next hint if a strategy can be applied, otherwise sets to null

    Parameters

    • cells: Cell[][]

      empty cells

    Returns void

setNotes

  • Sets boards notes to given notes

    Parameters

    • notes: string[][]

      array of notes arrays in order (one array with an array for each cell)

    Returns void

Settings

Member Visibility

Theme

Generated using TypeDoc