[Algorithm Design and Techniques]

Author: loiane

src/ts/algorithms/backtracking/rat-in-maze.ts

@@ -0,0 +1,65 @@
+export function ratInAMaze(maze: Array<Array<number>>) {
+  const solution: Array<Array<number>> = [];
+
+  for (let i = 0; i < maze.length; i++) {
+    solution[i] = [];
+    for (let j = 0; j < maze[i].length; j++) {
+      solution[i][j] = 0;
+    }
+  }
+
+  if (findPath(maze, 0, 0, solution) === false) {
+    return solution;
+  } else {
+    return 'NO PATH FOUND';
+  }
+}
+
+function findPath(
+  maze: Array<Array<number>>,
+  x: number,
+  y: number,
+  solution: Array<Array<number>>
+) {
+  const n = maze.length;
+  // check if maze[x][y] is feasible to move
+  if (x === n - 1 && y === n - 1) {
+    // we have reached
+    solution[x][y] = 1;
+    return true;
+  }
+
+  // Check if maze[x][y] is valid
+  if (isSafe(maze, x, y) === true) {
+    // mark x,y as part of solution path
+    solution[x][y] = 1;
+
+    /* Move forward in x direction */
+    if (findPath(maze, x + 1, y, solution)) {
+      return true;
+    }
+
+    /* If moving in x direction doesn't give
+       solution then  Move down in y direction */
+    if (findPath(maze, x, y + 1, solution)) {
+      return true;
+    }
+
+    /* If none of the above movements work then
+       BACKTRACK: unmark x,y as part of solution
+       path */
+    solution[x][y] = 0;
+    return false;
+  }
+
+  return false;
+}
+
+function isSafe(maze: Array<Array<number>>, x: number, y: number) {
+  const n = maze.length;
+  // check if x and y are in limits and cell is not blocked
+  if (x >= 0 && y >= 0 && x < n && y < n && maze[x][y] !== 0) {
+    return true;
+  }
+  return false;
+}

src/ts/algorithms/backtracking/sudoku-solver.ts

@@ -0,0 +1,103 @@
+const UNASSIGNED = 0;
+
+export function sudokuSolver(grid: Array<Array<number>>) {
+  if (solveSudoku(grid) === true) {
+    return grid;
+  } else {
+    return 'NO SOLUTION EXISTS!';
+  }
+}
+
+function solveSudoku(grid: Array<Array<number>>) {
+  let row = 0;
+  let col = 0;
+  let checkBlankSpaces = false;
+
+  // If there is no unassigned location, we are done
+  for (row = 0; row < grid.length; row++) {
+    for (col = 0; col < grid[row].length; col++) {
+      if (grid[row][col] === UNASSIGNED) {
+        checkBlankSpaces = true;
+        break;
+      }
+    }
+    if (checkBlankSpaces === true) {
+      break;
+    }
+  }
+
+  if (checkBlankSpaces === false) {
+    return true;
+  } // success!
+
+  // consider digits 1 to 9
+  for (let num = 1; num <= 9; num++) {
+    // if looks promising
+    if (isSafe(grid, row, col, num)) {
+      // make tentative assignment
+      grid[row][col] = num;
+
+      // return, if success, yay!
+      if (solveSudoku(grid)) {
+        return true;
+      }
+
+      // failure, unmake & try again
+      grid[row][col] = UNASSIGNED;
+    }
+  }
+
+  return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+   in the specified row matches the given number. */
+function usedInRow(grid: Array<Array<number>>, row: number, num: number) {
+  for (let col = 0; col < grid.length; col++) {
+    if (grid[row][col] === num) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+   in the specified column matches the given number. */
+function usedInCol(grid: Array<Array<number>>, col: number, num: number) {
+  for (let row = 0; row < grid.length; row++) {
+    if (grid[row][col] === num) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+      within the specified 3x3 box matches the given number. */
+function usedInBox(
+  grid: Array<Array<number>>,
+  boxStartRow: number,
+  boxStartCol: number,
+  num: number
+) {
+  for (let row = 0; row < 3; row++) {
+    for (let col = 0; col < 3; col++) {
+      if (grid[row + boxStartRow][col + boxStartCol] === num) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/* Returns a boolean which indicates whether it will be legal to assign
+   num to the given row,col location. */
+function isSafe(grid: Array<Array<number>>, row: number, col: number, num: number) {
+  /* Check if 'num' is not already placed in current row,
+          current column and current 3x3 box */
+  return (
+    !usedInRow(grid, row, num) &&
+    !usedInCol(grid, col, num) &&
+    !usedInBox(grid, row - row % 3, col - col % 3, num)
+  );
+}

src/ts/index.ts

@@ -63,6 +63,8 @@ export { findMinValue as findMinValue } from './algorithms/search/min-max-search
 // chapter 14
 export { binarySearch as binarySearchRecursive } from './algorithms/search/binary-search-recursive';
 export { minCoinChange as minCoinChange } from './algorithms/dynamic-programing/min-coin-change';
+export { ratInAMaze as ratInAMaze } from './algorithms/backtracking/rat-in-maze';
+export { sudokuSolver as sudokuSolver } from './algorithms/backtracking/sudoku-solver';
 
 
 /* import { hotPotato } from './others/hot-potato';

test/ts/algorithms/backtracking/sudoku-solver.spec.ts

@@ -0,0 +1,31 @@
+import 'mocha';
+import { expect } from 'chai';
+import { sudokuSolver } from '../../../../src/ts/index';
+
+describe('Sudoku Solver', () => {
+  it('sudoku solver', () => {
+    const grid = [
+      [3, 0, 6, 5, 0, 8, 4, 0, 0],
+      [5, 2, 0, 0, 0, 0, 0, 0, 0],
+      [0, 8, 7, 0, 0, 0, 0, 3, 1],
+      [0, 0, 3, 0, 1, 0, 0, 8, 0],
+      [9, 0, 0, 8, 6, 3, 0, 0, 5],
+      [0, 5, 0, 0, 9, 0, 6, 0, 0],
+      [1, 3, 0, 0, 0, 0, 2, 5, 0],
+      [0, 0, 0, 0, 0, 0, 0, 7, 4],
+      [0, 0, 5, 2, 0, 6, 3, 0, 0]
+    ];
+    const solution = [
+      [3, 1, 6, 5, 7, 8, 4, 9, 2],
+      [5, 2, 9, 1, 3, 4, 7, 6, 8],
+      [4, 8, 7, 6, 2, 9, 5, 3, 1],
+      [2, 6, 3, 4, 1, 5, 9, 8, 7],
+      [9, 7, 4, 8, 6, 3, 1, 2, 5],
+      [8, 5, 1, 7, 9, 2, 6, 4, 3],
+      [1, 3, 8, 9, 4, 7, 2, 5, 6],
+      [6, 9, 2, 3, 5, 1, 8, 7, 4],
+      [7, 4, 5, 2, 8, 6, 3, 1, 9]
+    ];
+    expect(sudokuSolver(grid)).to.deep.equal(solution);
+  });
+});