[Algorithm Design and Techniques]

Author: loiane

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

@@ -1,6 +1,5 @@
 function isSafe(maze, x, y) {
   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;
   }
@@ -9,28 +8,18 @@ function isSafe(maze, x, y) {
 
 function findPath(maze, x, y, solution) {
   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;
   }

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

@@ -1,55 +1,49 @@
 const UNASSIGNED = 0;
 
-/* Returns a boolean which indicates whether any assigned entry
-   in the specified row matches the given number. */
-function usedInRow(grid, row, num) {
-  for (let col = 0; col < grid.length; col++) {
-    if (grid[row][col] === num) {
+function usedInRow(matrix, row, num) {
+  for (let col = 0; col < matrix.length; col++) {
+    if (matrix[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, col, num) {
-  for (let row = 0; row < grid.length; row++) {
-    if (grid[row][col] === num) {
+
+function usedInCol(matrix, col, num) {
+  for (let row = 0; row < matrix.length; row++) {
+    if (matrix[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, boxStartRow, boxStartCol, num) {
+
+function usedInBox(matrix, boxStartRow, boxStartCol, num) {
   for (let row = 0; row < 3; row++) {
     for (let col = 0; col < 3; col++) {
-      if (grid[row + boxStartRow][col + boxStartCol] === num) {
+      if (matrix[row + boxStartRow][col + boxStartCol] === num) {
         return true;
       }
     }
   }
   return false;
 }
 
-function isSafe(grid, row, col, num) {
-  /* Check if 'num' is not already placed in current row,
-            current column and current 3x3 box */
+function isSafe(matrix, row, col, num) {
   return (
-    !usedInRow(grid, row, num) &&
-    !usedInCol(grid, col, num) &&
-    !usedInBox(grid, row - (row % 3), col - (col % 3), num)
+    !usedInRow(matrix, row, num) &&
+    !usedInCol(matrix, col, num) &&
+    !usedInBox(matrix, row - (row % 3), col - (col % 3), num)
   );
 }
-function solveSudoku(grid) {
+function solveSudoku(matrix) {
   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) {
+
+  for (row = 0; row < matrix.length; row++) {
+    for (col = 0; col < matrix[row].length; col++) {
+      if (matrix[row][col] === UNASSIGNED) {
         checkBlankSpaces = true;
         break;
       }
@@ -60,27 +54,23 @@ function solveSudoku(grid) {
   }
   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)) {
+    if (isSafe(matrix, row, col, num)) {
+      matrix[row][col] = num;
+      if (solveSudoku(matrix)) {
         return true;
       }
-      // failure, unmake & try again
-      grid[row][col] = UNASSIGNED;
+      matrix[row][col] = UNASSIGNED;
     }
   }
   return false;
 }
 
-export function sudokuSolver(grid) {
-  if (solveSudoku(grid) === true) {
-    return grid;
+export function sudokuSolver(matrix) {
+  if (solveSudoku(matrix) === true) {
+    return matrix;
   }
   return 'NO SOLUTION EXISTS!';
 }

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

@@ -22,32 +22,22 @@ function findPath(
   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;
   }
@@ -57,7 +47,6 @@ function findPath(
 
 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;
   }

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

@@ -13,7 +13,6 @@ function solveSudoku(grid: Array<Array<number>>) {
   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) {
@@ -28,30 +27,23 @@ function solveSudoku(grid: Array<Array<number>>) {
 
   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) {
@@ -61,8 +53,6 @@ function usedInRow(grid: Array<Array<number>>, row: number, num: number) {
   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) {
@@ -72,8 +62,6 @@ function usedInCol(grid: Array<Array<number>>, col: number, num: number) {
   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,
@@ -90,11 +78,7 @@ function usedInBox(
   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) &&