Code Review (Easy): The Dashboard Logic Puzzle

Story

To give the team a mental break, Lena decided to add a classic grid puzzle to the company’s internal dashboard, but she needed a way to ensure the puzzles were actually solvable. She asked Mark to review her new utility that takes a partially filled grid and automatically determines where the missing numbers go. The tool ensures that every row, column, and small square block is perfectly filled with the numbers one through nine without any repeats. For example, if she inputs a board full of empty dots and a few starting digits, the program should return the completed grid with every single empty space filled correctly.

Your Task

Read the story and code, then decide if the code is ready for production or needs improvement.

Hints

What would block an approval? Give me a hint.

Check out Next Topic: The Reviewer Shuffle

function solveSudoku(board: string[][], useMRV: boolean = true, useUnifiedBitUtil: boolean = true): void {
  const SIZE = 9;
  const FULL_MASK = 0x1FF; // 9 bits
  const rows: number[] = new Array(SIZE).fill(0);
  const cols: number[] = new Array(SIZE).fill(0);
  const boxes: number[] = new Array(SIZE).fill(0);
  const empties: { r: number; c: number }[] = [];

const boxIndex = (r: number, c: number) => Math.floor(r / 3) * 3 + Math.floor(c / 3);

for (let r = 0; r < SIZE; r++) {
    for (let c = 0; c < SIZE; c++) {
      const ch = board[r][c];
      if (ch === '.' ) {
        empties.push({ r, c });
      } else {
        const d = parseInt(ch, 10);
        const bit = 1 << (d - 1);
        rows[r] |= bit;
        cols[c] |= bit;
        boxes[boxIndex(r, c)] |= bit;
      }
    }
  }

function bitCountImpl(n: number): number {
    let cnt = 0;
    while (n) {
      n &= n - 1;
      cnt++;
    }
    return cnt;
  }

function bitToDigitImpl(bit: number): number {
    let idx = 0;
    while (bit > 1) {
      bit >>= 1;
      idx++;
    }
    return idx + 1;
  }

// Universal bit utility that can either count bits or convert a single bit to digit,
  // controlled by a boolean flag passed at each call.
  function bitUtil(n: number, countMode: boolean): number {
    if (countMode) {
      let cnt = 0;
      while (n) {
        n &= n - 1;
        cnt++;
      }
      return cnt;
    } else {
      let idx = 0;
      while (n > 1) {
        n >>= 1;
        idx++;
      }
      return idx + 1;
    }
  }

function backtrack(idx: number): boolean {
    if (idx === empties.length) return true;

let best = -1;
    let bestCount = 10;

if (useMRV) {
      // Choose the empty cell with fewest candidates (MRV)
      for (let k = idx; k < empties.length; k++) {
        const { r, c } = empties[k];
        const used = rows[r] | cols[c] | boxes[boxIndex(r, c)];
        const avail = (~used) & FULL_MASK;
        const cnt = useUnifiedBitUtil ? bitUtil(avail, true) : bitCountImpl(avail);
        if (cnt < bestCount) {
          bestCount = cnt;
          best = k;
          if (cnt === 1) break; // can't get better than 1
        }
      }

if (best === -1 || bestCount === 0) return false;

// move chosen to current idx
      const tmp = empties[idx];
      empties[idx] = empties[best];
      empties[best] = tmp;
    } else {
      // Without MRV, just take the current index
      best = idx;
    }

const { r, c } = empties[idx];
    const b = boxIndex(r, c);
    const used = rows[r] | cols[c] | boxes[b];
    let avail = (~used) & FULL_MASK;

while (avail) {
      const pick = avail & -avail;
      avail &= avail - 1;

const d = useUnifiedBitUtil ? bitUtil(pick, false) : bitToDigitImpl(pick);
      const ch = String(d);

// place
      board[r][c] = ch;
      rows[r] |= pick;
      cols[c] |= pick;
      boxes[b] |= pick;

if (backtrack(idx + 1)) return true;

// undo
      board[r][c] = '.';
      rows[r] &= ~pick;
      cols[c] &= ~pick;
      boxes[b] &= ~pick;
    }

if (useMRV) {
      // restore order before backtracking up
      const tmp = empties[idx];
      empties[idx] = empties[best];
      empties[best] = tmp;
    }

return false;
  }

backtrack(0);
}