Código para Resolver el Rompecabezas de las N Reinas

function solveNQueens(n = 8) {
    const solutions = [];
    const board = Array(n).fill(-1);

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

    function backtrack(row) {
        if (row === n) {
            solutions.push([...board]);
            return;
        }

        for (let col = 0; col < n; col++) {
            if (isSafe(row, col)) {
                board[row] = col;
                backtrack(row + 1);
                board[row] = -1;
            }
        }
    }

    backtrack(0);
    return solutions;
}

const solutions = solveNQueens(8);
console.log(`Found ${solutions.length} solutions`);

def solve_n_queens(n=8):
    solutions = []
    board = [-1] * n

    def is_safe(row, col):
        for i in range(row):
            queen_col = board[i]
            if (queen_col == col or 
                abs(queen_col - col) == abs(i - row)):
                return False
        return True

    def backtrack(row):
        if row == n:
            solutions.append(board[:])
            return
        
        for col in range(n):
            if is_safe(row, col):
                board[row] = col
                backtrack(row + 1)
                board[row] = -1

    backtrack(0)
    return solutions

solutions = solve_n_queens(8)
print(f"Found {len(solutions)} solutions")

import java.util.*;

public class NQueens {
    public static List> solveNQueens(int n) {
        List> solutions = new ArrayList<>();
        int[] board = new int[n];
        Arrays.fill(board, -1);
        
        solveNQueensHelper(board, 0, solutions);
        return solutions;
    }
    
    private static boolean isSafe(int[] board, int row, int col) {
        for (int i = 0; i < row; i++) {
            int queenCol = board[i];
            if (queenCol == col || 
                Math.abs(queenCol - col) == Math.abs(i - row)) {
                return false;
            }
        }
        return true;
    }
    
    private static void solveNQueensHelper(int[] board, int row, 
                                          List> solutions) {
        if (row == board.length) {
            List solution = new ArrayList<>();
            for (int col : board) solution.add(col);
            solutions.add(solution);
            return;
        }
        
        for (int col = 0; col < board.length; col++) {
            if (isSafe(board, row, col)) {
                board[row] = col;
                solveNQueensHelper(board, row + 1, solutions);
                board[row] = -1;
            }
        }
    }
}

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

bool isSafe(const vector<int>& board, int row, int col) {
    for (int i = 0; i < row; i++) {
        int queenCol = board[i];
        if (queenCol == col || 
            abs(queenCol - col) == abs(i - row)) {
            return false;
        }
    }
    return true;
}

void solveNQueens(vector<int>& board, int row, 
                 vector<vector<int>>& solutions) {
    if (row == board.size()) {
        solutions.push_back(board);
        return;
    }
    
    for (int col = 0; col < board.size(); col++) {
        if (isSafe(board, row, col)) {
            board[row] = col;
            solveNQueens(board, row + 1, solutions);
            board[row] = -1;
        }
    }
}

vector<vector<int>> solveNQueens(int n) {
    vector<int> board(n, -1);
    vector<vector<int>> solutions;
    solveNQueens(board, 0, solutions);
    return solutions;
}

using System;
using System.Collections.Generic;

public class NQueens {
    public static List<List<int>> SolveNQueens(int n) {
        var solutions = new List<List<int>>();
        var board = new int[n];
        Array.Fill(board, -1);
        
        SolveNQueensHelper(board, 0, solutions);
        return solutions;
    }
    
    private static bool IsSafe(int[] board, int row, int col) {
        for (int i = 0; i < row; i++) {
            int queenCol = board[i];
            if (queenCol == col || 
                Math.Abs(queenCol - col) == Math.Abs(i - row)) {
                return false;
            }
        }
        return true;
    }
    
    private static void SolveNQueensHelper(int[] board, int row, 
                                         List<List<int>> solutions) {
        if (row == board.Length) {
            var solution = new List<int>(board);
            solutions.Add(solution);
            return;
        }
        
        for (int col = 0; col < board.Length; col++) {
            if (IsSafe(board, row, col)) {
                board[row] = col;
                SolveNQueensHelper(board, row + 1, solutions);
                board[row] = -1;
            }
        }
    }
}

<?php
function solveNQueens($n = 8) {
    $solutions = [];
    $board = array_fill(0, $n, -1);
    
    function isSafe($board, $row, $col) {
        for ($i = 0; $i < $row; $i++) {
            $queenCol = $board[$i];
            if ($queenCol == $col || 
                abs($queenCol - $col) == abs($i - $row)) {
                return false;
            }
        }
        return true;
    }
    
    function backtrack($board, $row, &$solutions) {
        global $n;
        if ($row == $n) {
            $solutions[] = $board;
            return;
        }
        
        for ($col = 0; $col < $n; $col++) {
            if (isSafe($board, $row, $col)) {
                $board[$row] = $col;
                backtrack($board, $row + 1, $solutions);
                $board[$row] = -1;
            }
        }
    }
    
    backtrack($board, 0, $solutions);
    return $solutions;
}

$solutions = solveNQueens(8);
echo "Found " . count($solutions) . " solutions";
?>