How do you say 'N-Queens problem' in different programming languages?

Can you tell me how to implement the N-Queens problem in Python?

Sure! In Python, you can use a backtracking algorithm to solve the N-Queens problem. Would you like to see a sample code?

Yes, please share the sample code.

Here's a simple implementation:

def solve_n_queens(n):
    def is_safe(board, row, col):
        for i in range(col):
            if board[row][i] == 'Q':
                return False
        for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
            if board[i][j] == 'Q':
                return False
        for i, j in zip(range(row, n), range(col, -1, -1)):
            if board[i][j] == 'Q':
                return False
        return True

    def solve(board, col):
        if col >= n:
            return True
        for i in range(n):
            if is_safe(board, i, col):
                board[i][col] = 'Q'
                if solve(board, col + 1):
                    return True
                board[i][col] = '.'
        return False

    board = [['.' for _ in range(n)] for _ in range(n)]
    if not solve(board, 0):
        return []
    return board

This code initializes a board and uses recursion to place queens.

What about in JavaScript?

In JavaScript, you can implement the N-Queens problem similarly. Here's a sample code:

function solveNQueens(n) {
    const board = Array.from({ length: n }, () => Array(n).fill('.'));
    const results = [];

    function isSafe(row, col) {
        for (let i = 0; i < col; i++) {
            if (board[row][i] === 'Q') return false;
        }
        for (let i = row, j = col; i >= 0 && j >= 0; i--, j--) {
            if (board[i][j] === 'Q') return false;
        }
        for (let i = row, j = col; i < n && j >= 0; i++, j--) {
            if (board[i][j] === 'Q') return false;
        }
        return true;
    }

    function solve(col) {
        if (col >= n) {
            results.push(board.map(row => row.join('')));
            return;
        }
        for (let i = 0; i < n; i++) {
            if (isSafe(i, col)) {
                board[i][col] = 'Q';
                solve(col + 1);
                board[i][col] = '.';
            }
        }
    }

    solve(0);
    return results;
}

This code also uses backtracking to find all solutions.