N Queens Problem in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the chessboard as a 2D array filled with dots '.' representing empty cells.

DSA Javascript

const board = Array(n).fill().map(() => Array(n).fill([1]));

Drag options to blanks, or click blank then click option'

A'Q'

B'.'

C0

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Q' instead of '.' for empty cells.

Using 0 or null which are not characters.

The board should be initialized with '.' to represent empty cells where queens can be placed later.

2fill in blank

medium

Complete the code to place a queen 'Q' on the board at row i and column j.

DSA Javascript

board[[1]][j] = 'Q';

Drag options to blanks, or click blank then click option'

Ai

B0

Cj

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping row and column indices.

Using a fixed number instead of variable i.

To place a queen at row i and column j, use board[i][j] = 'Q'.

3fill in blank

hard

Fix the error in the function that checks if placing a queen at (row, col) is safe by completing the diagonal check.

DSA Javascript

for (let i = row, j = col; i >= 0 && j >= 0; i--, j--) {
  if (board[i][j] === [1]) return false;
}

Drag options to blanks, or click blank then click option'

Anull

B'.'

C0

D'Q'

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for '.' instead of 'Q'.

Using 0 or null which are not valid board values.

We check if there is a queen 'Q' on the diagonal; if yes, it's not safe.

4fill in blank

hard

Fill both blanks to complete the recursive function call and backtracking step in the N Queens solver.

DSA Javascript

if (solveNQueens([1] + 1)) return true;
board[row][[2]] = '.'; // backtrack

Drag options to blanks, or click blank then click option'

Arow

Bcol

Crow + 1

Dcol + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Incrementing column instead of row in recursion.

Removing queen from wrong position during backtracking.

We move to the next row by calling solveNQueens(row + 1) and remove the queen from the current column during backtracking.

5fill in blank

hard

Fill all three blanks to complete the code that collects the current board configuration as a list of strings.

DSA Javascript

const result = [];
for (let i = 0; i < n; i++) {
  result.push(board[i].[1](''));
}
solutions.push(result.map(row => row.[2]()));

// Clear the board for next solution
for (let i = 0; i < n; i++) {
  board[i] = Array(n).fill([3]);
}

Drag options to blanks, or click blank then click option'

Ajoin

Bslice

C'.'

Dsplit

Attempts:

3 left

💡 Hint

Common Mistakes

Using split instead of join.

Not copying the string before pushing.

Resetting board cells to 'Q' instead of '.'

We join each row array into a string, copy it with slice(), and reset the board cells to '.' for the next solution.

Practice

1. What is the main goal of the N Queens Problem in chess?

easy

A. Place N queens on an NxN board so no two queens attack each other

B. Place N queens on an NxN board so all queens attack each other

C. Place N queens on an NxN board in the same row

D. Place N queens on an NxN board in the same column

Solution

1. Step 1: Understand the problem objective

   The N Queens Problem requires placing queens so that none can attack another. Queens attack horizontally, vertically, and diagonally.

2. Step 2: Analyze the options

   Only Place N queens on an NxN board so no two queens attack each other correctly states the goal: no two queens attack each other on an NxN board.

3. Final Answer:

   Place N queens on an NxN board so no two queens attack each other -> Option A

4. Quick Check:

   Goal = safe queen placement [OK]

Hint: Remember: queens must not threaten each other [OK]

Common Mistakes:

• Thinking queens can share rows or columns
• Ignoring diagonal attacks
• Confusing attack with placement

2. Which of the following JavaScript function signatures is correct for solving the N Queens Problem recursively?

easy

A. function solveNQueens(board, row) {}

B. function solveNQueens(board, col) {}

C. function solveNQueens(row, col) {}

D. function solveNQueens(board) {}

Solution

1. Step 1: Understand recursive approach parameters

   Typically, the recursive function takes the board state and the current row to place a queen.

2. Step 2: Check options for correct parameters

   function solveNQueens(board, row) {} uses board and row, which fits the common recursive pattern.

3. Final Answer:

   function solveNQueens(board, row) {} -> Option A

4. Quick Check:

   Recursive function = board + current row [OK]

Hint: Pass board and current row for recursion [OK]

Common Mistakes:

• Using column instead of row for recursion
• Missing board parameter
• Using only one parameter

3. What will be the output of the following code snippet for n = 4?

function isSafe(board, row, col) {
  for (let i = 0; i < row; i++) {
    if (board[i] === col || Math.abs(board[i] - col) === row - i) return false;
  }
  return true;
}

function solveNQueens(n) {
  const board = Array(n).fill(-1);
  const results = [];
  function backtrack(row) {
    if (row === n) {
      results.push(board.slice());
      return;
    }
    for (let col = 0; col < n; col++) {
      if (isSafe(board, row, col)) {
        board[row] = col;
        backtrack(row + 1);
        board[row] = -1;
      }
    }
  }
  backtrack(0);
  return results.length;
}

console.log(solveNQueens(4));

medium

A. 1

B. 4

C. 0

D. 2

Solution

1. Step 1: Understand the code logic

   The code uses backtracking to find all valid placements of 4 queens on a 4x4 board. It counts solutions by pushing valid boards to results.

2. Step 2: Recall known N Queens results

   For n=4, the number of valid solutions is 2, which matches the returned results length.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   4 Queens solutions = 2 [OK]

Hint: Remember 4 queens have exactly 2 solutions [OK]

Common Mistakes:

• Assuming 4 queens have more than 2 solutions
• Confusing board representation with count
• Misreading the backtracking logic

4. Identify the bug in this code snippet for checking if a queen placement is safe:

function isSafe(board, row, col) {
  for (let i = 0; i < row; i++) {
    if (board[i] === col || Math.abs(board[i] - col) === row + i) return false;
  }
  return true;
}

medium

A. The function should return true inside the loop

B. The loop should run until 'i <= row' instead of 'i < row'

C. The diagonal check uses 'row + i' instead of 'row - i'

D. The equality check for columns is incorrect

Solution

1. Step 1: Analyze the diagonal attack condition

   The diagonal attack is checked by comparing absolute difference of columns to difference of rows. It should be row - i, not row + i.

2. Step 2: Identify the incorrect expression

   The code uses row + i, which is wrong and causes incorrect safety checks.

3. Final Answer:

   The diagonal check uses 'row + i' instead of 'row - i' -> Option C

4. Quick Check:

   Diagonal check = row - i [OK]

Hint: Diagonal difference = current row minus previous row [OK]

Common Mistakes:

• Using addition instead of subtraction for diagonal check
• Looping one extra iteration
• Returning true too early

5. Given a 5x5 board, how many distinct solutions does the N Queens Problem have, and what is the main reason for this number compared to smaller boards?

hard

A. 5 solutions because each queen must be in a unique row and column

B. 10 solutions because more rows allow more queen placements without conflict

C. 0 solutions because 5x5 boards cannot place 5 queens safely

D. 1 solution because only one arrangement avoids attacks on 5x5

Solution

1. Step 1: Recall known solution counts for N Queens

   For n=5, the known number of distinct solutions is 10.

2. Step 2: Understand why solution count increases

   With larger boards, more safe placements exist because queens can be spread out more easily without attacking each other.

3. Final Answer:

   10 solutions because more rows allow more queen placements without conflict -> Option B

4. Quick Check:

   5 Queens solutions = 10 [OK]

Hint: More board size means more safe queen arrangements [OK]

Common Mistakes:

• Assuming no solutions for 5x5
• Confusing unique rows with total solutions
• Underestimating solution count