AWK

#!/usr/bin/awk -f

BEGIN {
    if (ARGC < 2) {
        print "Usage: ./nqueens.awk <board size>"
        exit 1
    }
    n = ARGV[1]
    delete ARGV[1]
    count = 0

    for (i = 0; i < n; i++) lock_col[i] = 0
    for (i = 0; i < 2 * n - 1; i++) {
        lock_ltrb[i] = 0
        lock_rtlb[i] = 0
    }

    print "Solving: n=" n
    solve(0)
    print "Result:  " count
}

function solve(row, local_count, dx, ltrb_index, rtlb_index) {
    if (row == n) {
        count++
        return
    }

    for (dx = 0; dx < n; dx++) {
        ltrb_index = dx - row + n - 1
        rtlb_index = dx + row

        if (lock_col[dx] || lock_ltrb[ltrb_index] || lock_rtlb[rtlb_index])
            continue

        lock_col[dx] = 1
        lock_ltrb[ltrb_index] = 1
        lock_rtlb[rtlb_index] = 1

        solve(row + 1)

        lock_col[dx] = 0
        lock_ltrb[ltrb_index] = 0
        lock_rtlb[rtlb_index] = 0
    }
}

Bash

#!/bin/bash

solve() {
  local row=$1
  local count=0

  if (( row == n )); then
    echo 1
    return
  fi

  for (( dx=0; dx<n; dx++ )); do
    local ltrb_index=$((dx-row+n-1))
    local rtlb_index=$((dx+row))

    if (( lock_col[dx] == 1 || ltrb_index < 0 || ltrb_index >= 2*n-1 || rtlb_index < 0 || rtlb_index >= 2*n-1 || lock_ltrb[ltrb_index] == 1 || lock_rtlb[rtlb_index] == 1 )); then
      continue
    fi

    lock_col[dx]=1
    lock_ltrb[ltrb_index]=1
    lock_rtlb[rtlb_index]=1

    count=$((count + $(solve $((row + 1)))))

    lock_col[dx]=0
    lock_ltrb[ltrb_index]=0
    lock_rtlb[rtlb_index]=0
  done

  echo $count
}

if (( $# < 1 )); then
  echo "Usage: $0 <board size>"
  exit 1
fi

n=$1

lock_col=($(for ((i=0; i<n; i++)); do echo 0; done))
lock_ltrb=($(for ((i=0; i<2*n-1; i++)); do echo 0; done))
lock_rtlb=($(for ((i=0; i<2*n-1; i++)); do echo 0; done))

echo "Solving: n=$n"
result=$(solve 0)
echo "Result:  $result"

C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int n = 10;
int count = 0;

void solve(int row, bool* lockCol, bool* lockLtrb, bool* lockRtlb) {
    if (row < n) {
        for (int dx = 0; dx < n; dx++) {
            if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row]) {
                continue;
            }
            lockCol[dx] = true;
            lockLtrb[dx - row + n - 1] = true;
            lockRtlb[dx + row] = true;
            solve(row + 1, lockCol, lockLtrb, lockRtlb);
            lockCol[dx] = false;
            lockLtrb[dx - row + n - 1] = false;
            lockRtlb[dx + row] = false;
        }
    } else {
        count++;
    }
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        printf("Usage: NQueens <board_size>\n");
        return 1;
    }

    // Convert input to integer and validate
    char* end;
    n = strtol(argv[1], &end, 10);
    if (*end != '\0' || n <= 0) {
        printf("Invalid input! Board size must be a positive integer!\n");
        return 1;
    }

    printf("Solving: n=%d\n", n);

    // Dynamically allocate arrays
    bool* lockCol = calloc(n, sizeof(bool));
    bool* lockLtrb = calloc(2 * n - 1, sizeof(bool));
    bool* lockRtlb = calloc(2 * n - 1, sizeof(bool));

    if (!lockCol || !lockLtrb || !lockRtlb) {
        printf("Memory allocation failed!\n");
        free(lockCol);
        free(lockLtrb);
        free(lockRtlb);
        return 1;
    }

    solve(0, lockCol, lockLtrb, lockRtlb);

    printf("Result:  %d\n", count);

    // Free allocated memory
    free(lockCol);
    free(lockLtrb);
    free(lockRtlb);

    return 0;
}

C++

#include <iostream>
#include <vector>
#include <stdexcept>
#include <string>

using namespace std;

int n = 10;
int count = 0;

void solve(int row, vector<bool>& lockCol, vector<bool>& lockLtrb, vector<bool>& lockRtlb) {
    if (row < n) {
        for (int dx = 0; dx < n; dx++) {
            if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row]) {
                continue;
            }
            lockCol[dx] = true;
            lockLtrb[dx - row + n - 1] = true;
            lockRtlb[dx + row] = true;
            solve(row + 1, lockCol, lockLtrb, lockRtlb);
            lockCol[dx] = false;
            lockLtrb[dx - row + n - 1] = false;
            lockRtlb[dx + row] = false;
        }
    } else {
        count++;
    }
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        cout << "Usage: NQueens <board_size>" << endl;
        return 1;
    }

    try {
        n = stoi(argv[1]);
    } catch (invalid_argument&) {
        cout << "Invalid input! Board size must be a positive integer!" << endl;
        return 1;
    } catch (out_of_range&) {
        cout << "Invalid input! Board size is out of range!" << endl;
        return 1;
    }

    if (n <= 0) {
        cout << "Invalid input! Board size must be a positive integer!" << endl;
        return 1;
    }

    cout << "Solving: n=" << n << endl;

    vector<bool> lockCol(n, false);
    vector<bool> lockLtrb(2 * n - 1, false);
    vector<bool> lockRtlb(2 * n - 1, false);

    solve(0, lockCol, lockLtrb, lockRtlb);

    cout << "Result:  " << count << endl;
    return 0;
}

C#

using System;

public class NQueens
{
    private static int n = 10;
    private static int count = 0;

    public static void Main(string[] args)
    {
        if (args.Length != 1)
        {
            Console.WriteLine("Usage: NQueens <board_size>");
            return;
        }

        try
        {
            n = int.Parse(args[0]);
        }
        catch (FormatException)
        {
            Console.WriteLine("Invalid input! Board size must be a positive integer!");
            return;
        }

        if (n <= 0)
        {
            Console.WriteLine("Invalid input! Board size must be a positive integer!");
            return;
        }

        Console.WriteLine($"Solving: n={n}");
        Solve(0, new bool[n], new bool[2 * n - 1], new bool[2 * n - 1]);
        Console.WriteLine($"Result:  {count}");
    }

    private static void Solve(int row, bool[] lockCol, bool[] lockLtrb, bool[] lockRtlb)
    {
        if (row < n)
        {
            for (int dx = 0; dx < n; dx++)
            {
                if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row])
                {
                    continue;
                }
                lockCol[dx] = true;
                lockLtrb[dx - row + n - 1] = true;
                lockRtlb[dx + row] = true;

                Solve(row + 1, lockCol, lockLtrb, lockRtlb);
                
                lockCol[dx] = false;
                lockLtrb[dx - row + n - 1] = false;
                lockRtlb[dx + row] = false;
            }
        }
        else
        {
            count++;
        }
    }
}

CoffeeScript

n = 8
count = 0

solve = (row, lock_col, lock_ltrb, lock_rtlb) ->
  if row >= n
    count++
    return
  
  for dx in [0..n-1]
    if lock_col[dx] or lock_ltrb[dx - row + n - 1] or lock_rtlb[dx + row]
      continue
    
    lock_col[dx] = true
    lock_ltrb[dx - row + n - 1] = true
    lock_rtlb[dx + row] = true
    
    solve(row + 1, lock_col, lock_ltrb, lock_rtlb)
    
    lock_col[dx] = false
    lock_ltrb[dx - row + n - 1] = false
    lock_rtlb[dx + row] = false

main = ->
  args = process.argv[2..]

  if args.length != 1
    console.log "Usage: coffee nqueens <board_size>"
    process.exit 1

  try
    n = parseInt(args[0], 10)
  catch error
    console.log "Invalid input! Board size must be a positive integer!"
    process.exit 1

  if isNaN(n) or n <= 0
    throw new Error("Invalid input! Board size must be a positive integer!")

  lock_col = Array(n).fill(false)
  lock_ltrb = Array(n * 2 - 1).fill(false)
  lock_rtlb = Array(n * 2 - 1).fill(false)
  
  console.log "Solving: n=#{n}"
  solve(0, lock_col, lock_ltrb, lock_rtlb)
  console.log "Result:  #{count}"

main()

D

import std.stdio;
import std.conv;
import std.exception;

int n;
int count;

void solve( int row, bool[] lockCol, bool[] lockTlbr, bool[] lockTrbl ) {
    if ( row < n ) {
        for ( int dx = 0; dx < n; dx++ ) {
            if ( lockCol[dx] || lockTlbr[dx - row + n - 1] || lockTrbl[dx + row] ) {
                continue;
            }
            lockCol[dx] = true;
            lockTlbr[dx - row + n - 1] = true;
            lockTrbl[dx + row] = true;
            solve( row + 1, lockCol, lockTlbr, lockTrbl );
            lockCol[dx] = false;
            lockTlbr[dx - row + n - 1] = false;
            lockTrbl[dx + row] = false;
        }
    } else {
        count++;
    }
}

void main( string[] args ) {
    if ( args.length != 2 ) {
        writeln( "Usage: nqueens <board_size>" );
        return;
    }

    try {
        n = to!int( args[1] );
        enforce( n > 0, "Invalid input! Board size must be a positive integer!" );
    } catch ( Exception e ) {
        writeln( e.msg );
        return;
    }

    bool[] lockCol = new bool[n];
    bool[] lockTlbr = new bool[2 * n - 1];
    bool[] lockTrbl = new bool[2 * n - 1];

    writeln( "Solving: n=", n );
    solve( 0, lockCol, lockTlbr, lockTrbl );
    writeln( "Result:  ", count );
}

Dart

import 'dart:io';

int n = 0;
int count = 0;

void solve(
    int row, List<bool> lockCol, List<bool> lockLtrb, List<bool> lockRtlb) {
  if (row < n) {
    for (int dx = 0; dx < n; dx++) {
      if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row]) {
        continue;
      }

      lockCol[dx] = true;
      lockLtrb[dx - row + n - 1] = true;
      lockRtlb[dx + row] = true;

      solve(row + 1, lockCol, lockLtrb, lockRtlb);

      lockCol[dx] = false;
      lockLtrb[dx - row + n - 1] = false;
      lockRtlb[dx + row] = false;
    }
  } else {
    count++;
  }
}

void main(List<String> args) {
  if (args.length != 1) {
    print("Usage: dart nqueens.dart <board_size>");
    return;
  }

  try {
    n = int.parse(args[0]);
    if (n <= 0) {
      throw FormatException(
          "Invalid input! Board size must be a positive integer!");
    }
  } catch (e) {
    print("Invalid input! ${e}");
    return;
  }

  var lockCol = List<bool>.filled(n, false, growable: false);
  var lockLtrb = List<bool>.filled(2 * n - 1, false, growable: false);
  var lockRtlb = List<bool>.filled(2 * n - 1, false, growable: false);

  print("Solving: n=$n");
  solve(0, lockCol, lockLtrb, lockRtlb);
  print("Result:  $count");
}

Erlang

-module(nqueens).
-export([main/1]).

main([Arg]) ->
        case catch list_to_integer(Arg) of
        N when is_integer(N), N > 0 ->
            LockCol = init_array(N, false),
            LockLtrb = init_array(2 * N - 1, false),
            LockRtlb = init_array(2 * N - 1, false),

            io:format("Solving: n=~p~n", [N]),
            Count = solve(0, N, LockCol, LockLtrb, LockRtlb),
            io:format("Result:  ~p~n", [Count]);
        _ ->
            io:format("Invalid input! Please provide a positive integer.\n")
    end;
main(_) ->
    io:format("Usage: nqueens <board_size>\n").

init_array(Size, DefaultValue) ->
    array:new(Size, {default, DefaultValue}).

solve(Row, N, LockCol, LockLtrb, LockRtlb) when Row < N ->
    lists:foldl(
        fun(Dx, Acc) ->
            case can_place(Row, Dx, N, LockCol, LockLtrb, LockRtlb) of
                true ->
                    NewLockCol = array:set(Dx, true, LockCol),
                    NewLockLtrb = array:set(Dx - Row + N - 1, true, LockLtrb),
                    NewLockRtlb = array:set(Dx + Row, true, LockRtlb),
                    Acc + solve(Row + 1, N, NewLockCol, NewLockLtrb, NewLockRtlb);
                false ->
                    Acc
            end
        end,
        0,
        lists:seq(0, N - 1)
    );
solve(_, _, _, _, _) ->
    1.

can_place(Row, Dx, N, LockCol, LockLtrb, LockRtlb) ->
    not (array:get(Dx, LockCol) orelse
         array:get(Dx - Row + N - 1, LockLtrb) orelse
         array:get(Dx + Row, LockRtlb)).

Fortran

PROGRAM nqueens
  USE ISO_FORTRAN_ENV
  IMPLICIT NONE
  INTEGER :: n, solutions, arg_count, i
  LOGICAL, ALLOCATABLE :: lock_col(:), lock_ltrb(:), lock_rtlb(:)
  CHARACTER(LEN=32) :: arg

  arg_count = COMMAND_ARGUMENT_COUNT()
  IF (arg_count /= 1) THEN
    PRINT *, "Usage: nqueens <board size>"
    STOP
  END IF

  CALL GET_COMMAND_ARGUMENT(1, arg)
  READ(arg, *) n
  IF (n <= 0) THEN
    PRINT *, "Error: Board size must be a positive integer."
    STOP
  END IF

  ALLOCATE(lock_col(n), lock_ltrb(2*n-1), lock_rtlb(2*n-1))
  lock_col = .FALSE.
  lock_ltrb = .FALSE.
  lock_rtlb = .FALSE.
  solutions = 0

  CALL solve(1, n, solutions, lock_col, lock_ltrb, lock_rtlb)

  WRITE(*, '(A,I0)') "Solving: n=", n
  WRITE(*, '(A,I0)') "Result:  ", solutions
CONTAINS

  RECURSIVE SUBROUTINE solve(row, n, solutions, lock_col, lock_ltrb, lock_rtlb)
    INTEGER, INTENT(IN) :: row, n
    INTEGER, INTENT(INOUT) :: solutions
    LOGICAL, INTENT(INOUT) :: lock_col(:), lock_ltrb(:), lock_rtlb(:)
    INTEGER :: col, ltrb_idx, rtlb_idx

    IF (row > n) THEN
      solutions = solutions + 1
      RETURN
    END IF

    DO col = 1, n
      ltrb_idx = col - row + n
      rtlb_idx = col + row - 1

      IF (.NOT. lock_col(col) .AND. .NOT. lock_ltrb(ltrb_idx) .AND. .NOT. lock_rtlb(rtlb_idx)) THEN
        lock_col(col) = .TRUE.
        lock_ltrb(ltrb_idx) = .TRUE.
        lock_rtlb(rtlb_idx) = .TRUE.

        CALL solve(row + 1, n, solutions, lock_col, lock_ltrb, lock_rtlb)

        lock_col(col) = .FALSE.
        lock_ltrb(ltrb_idx) = .FALSE.
        lock_rtlb(rtlb_idx) = .FALSE.
      END IF
    END DO
  END SUBROUTINE solve
END PROGRAM nqueens

GoLang

package main

import (
	"fmt"
	"os"
	"strconv"
)

var n int
var count int

func solve(row int, lockCol, lockLtrb, lockRtlb []bool) {
	if row < n {
		for dx := 0; dx < n; dx++ {
			if lockCol[dx] || lockLtrb[dx-row+n-1] || lockRtlb[dx+row] {
				continue
			}
			lockCol[dx] = true
			lockLtrb[dx-row+n-1] = true
			lockRtlb[dx+row] = true
			solve(row+1, lockCol, lockLtrb, lockRtlb)
			lockCol[dx] = false
			lockLtrb[dx-row+n-1] = false
			lockRtlb[dx+row] = false
		}
	} else {
		count++
	}
}

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage: NQueens <board_size>")
		return
	}

	size, err := strconv.Atoi(os.Args[1])
	if err != nil || size <= 0 {
		fmt.Println("Invalid input! Board size must be a positive integer!")
		return
	}
	n = size

	fmt.Printf("Solving: n=%d\n", n)

	lockCol := make([]bool, n)
	lockLtrb := make([]bool, 2*n-1)
	lockRtlb := make([]bool, 2*n-1)

	solve(0, lockCol, lockLtrb, lockRtlb)

	fmt.Printf("Result:  %d\n", count)
}

Groovy

class NQueens {
    static void main(String[] args) {
        if (args.length != 1) {
            println "Usage: groovy NQueens <board_size>"
            return
        }

        int n
        try {
            n = args[0].toInteger()
            if (n <= 0) {
                throw new IllegalArgumentException("Board size must be a positive integer!")
            }
        } catch (Exception e) {
            println "Invalid input: ${e.message}"
            return
        }

        boolean[] lockCol = new boolean[n]
        boolean[] lockLtrb = new boolean[2 * n - 1]
        boolean[] lockRtlb = new boolean[2 * n - 1]

        println "Solving: n=$n"
        int count = solve(0, n, lockCol, lockLtrb, lockRtlb)
        println "Result:  $count"
    }

    static int solve(int row, int n, boolean[] lockCol, boolean[] lockLtrb, boolean[] lockRtlb) {
        if (row < n) {
            int solutions = 0
            for (int dx = 0; dx < n; dx++) {
                if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row]) {
                    continue
                }

                lockCol[dx] = true
                lockLtrb[dx - row + n - 1] = true
                lockRtlb[dx + row] = true

                solutions += solve(row + 1, n, lockCol, lockLtrb, lockRtlb)

                lockCol[dx] = false
                lockLtrb[dx - row + n - 1] = false
                lockRtlb[dx + row] = false
            }
            return solutions
        } else {
            return 1
        }
    }
}

Haskell

import Control.Monad (forM)
import System.Environment (getArgs)

main :: IO ()
main = do
  args <- getArgs
  case args of
    [sizeArg] -> 
      case reads sizeArg :: [(Int, String)] of
        [(n, "")] | n > 0 -> do
          putStrLn $ "Solving: n=" ++ show n
          result <- solve 0 (replicate n False) (replicate (2 * n - 1) False) (replicate (2 * n - 1) False) n
          putStrLn $ "Result:  " ++ show result
        _ -> putStrLn "Invalid input! Board size must be a positive integer!"
    _ -> putStrLn "Usage: runhaskell nqueens.hs <board_size>"

solve :: Int -> [Bool] -> [Bool] -> [Bool] -> Int -> IO Int
solve row lockCol lockLTRB lockRTLB boardSize
  | row < boardSize = do
      results <- forM [0..boardSize-1] $ \dx -> 
        if lockCol !! dx || lockLTRB !! (dx - row + boardSize - 1) || lockRTLB !! (dx + row)
          then return 0
          else do
            let newLockCol  = updateList lockCol dx True
            let newLockLTRB = updateList lockLTRB (dx - row + boardSize - 1) True
            let newLockRTLB = updateList lockRTLB (dx + row) True
            
            solve (row + 1) newLockCol newLockLTRB newLockRTLB boardSize
      return (sum results)
  | otherwise = return 1

updateList :: [Bool] -> Int -> Bool -> [Bool]
updateList xs index newValue = take index xs ++ [newValue] ++ drop (index + 1) xs

Java

public class NQueens {

    private static int n = 10;
    private static int count = 0;

    public static void main( String[] args ) {
        if( args.length != 1 ) {
            System.out.println( "Usage: NQueens <board_size>" );
            return;
        }

        try {
            n = Integer.parseInt( args[ 0 ] );
        } catch( NumberFormatException e ) {
            System.out.println( "Invalid input! Board size must be a positive integer!" );
            return;
        }

        if( n <= 0 ) {
            System.out.println( "Invalid input! Board size must be a positive integer!" );
            return;
        }

        System.out.printf( "Solving: n=%d\n", n );
        solve( 0, new boolean[ n ], new boolean[ 2 * n - 1 ], new boolean[ 2 * n - 1 ] );
        System.out.printf( "Result:  %d\n", count );
    }

    private static void solve( int row, boolean[] lockCol, boolean[] lockLtrb, boolean[] lockRtlb ) {
        if( row < n ) {
            for( int dx = 0; dx < n; dx++ ) {
                if( lockCol[ dx ] || lockLtrb[ dx - row + n - 1 ] || lockRtlb[ dx + row ] ) {
                    continue;
                }
                lockCol[ dx ] = true;
                lockLtrb[ dx - row + n - 1 ] = true;
                lockRtlb[ dx + row ] = true;
                solve( row + 1, lockCol, lockLtrb, lockRtlb );
                lockCol[ dx ] = false;
                lockLtrb[ dx - row + n - 1 ] = false;
                lockRtlb[ dx + row ] = false;
            }
        } else {
            count++;
        }
    }
}

JavaScript

function main() {
    const args = process.argv.slice(2);
    if (args.length !== 1) {
        console.log("Usage: node nqueens.js <board_size>");
        return;
    }

    let n;
    try {
        n = parseInt(args[0], 10);
        if (isNaN(n) || n <= 0) {
            throw new Error("Board size must be a positive integer!");
        }
    } catch (error) {
        console.log("Invalid input! " + error.message);
        return;
    }

    const lockCol = Array(n).fill(false);
    const lockLtrb = Array(2 * n - 1).fill(false);
    const lockRtlb = Array(2 * n - 1).fill(false);
    
    console.log(`Solving: n=${n}`);
    const result = solve(0, n, lockCol, lockLtrb, lockRtlb);
    console.log(`Result:  ${result}`);
}

function solve(row, n, lockCol, lockLtrb, lockRtlb) {
    if (row < n) {
        let solutions = 0;

        for (let dx = 0; dx < n; dx++) {
            if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row]) {
                continue;
            }

            lockCol[dx] = true;
            lockLtrb[dx - row + n - 1] = true;
            lockRtlb[dx + row] = true;

            solutions += solve(row + 1, n, lockCol, lockLtrb, lockRtlb);

            lockCol[dx] = false;
            lockLtrb[dx - row + n - 1] = false;
            lockRtlb[dx + row] = false;
        }
        return solutions;
    } else {
        return 1;
    }
}

main();

JayMo

n = 10
count = 0

If( __ARGS.len != 1 )
	Print "Usage: NQueens <board_size>"
	Return

Try
	n = __ARGS[1].toInt
	If( n <= 0 )
		Error( "Number too small", "n="+n ).throw
.catch
	Print "Invalid input! Board size must be a positive integer!"
	Return

LOCK_COL = [].init(n, false)
LOCK_TLBR = [].init(n * 2 - 1, false)
LOCK_TRBL = [].init(n * 2 - 1, false)

Print "Solving: n=" + n
this.solve( 0 )
Print "Result:  " + count

::solve( ROW )
	If( ROW < n )
		For( x = 1, x <= n, x =++ )
			If( LOCK_COL[x] || LOCK_TLBR[x - ROW + n - 1] || LOCK_TRBL[x + ROW] )
				Next

			LOCK_COL[x] = true
			LOCK_TLBR[x - ROW + n - 1] = true
			LOCK_TRBL[x + ROW] = true

			this.solve( ROW + 1 )

			LOCK_COL[x] = false
			LOCK_TLBR[x - ROW + n - 1] = false
			LOCK_TRBL[x + ROW] = false
	.else
		count =++

Julia

function main()
    n = 10
    m = Ref(0)

    if length(ARGS) == 1
        try
            n = parse(Int, ARGS[1])
        catch e
            println("Invalid input! Board size must be a positive integer!")
        end
    else
        println("Usage: julia nqueens.jl <board_size>")
        exit()
    end
    
    if n <= 0
        print("Invalid input! Board size must be a positive integer!")
        exit()
    end
    
    println( "Solving: n=", n)
    solve(0, n, falses(n), falses(n * 2 - 1), falses(n * 2 - 1), m)
    println( "Result:  ", m[])
end

function solve(row, n, lock_col, lock_ltrb, lock_rtlb, m)
    if row < n
        for dx in 1:n
            if lock_col[dx] || lock_ltrb[dx - row + n - 1] || lock_rtlb[dx + row]
                continue
            end
            
            lock_col[dx] = true
            lock_ltrb[dx - row + n - 1] = true
            lock_rtlb[dx + row] = true
 
            solve(row + 1, n, lock_col, lock_ltrb, lock_rtlb, m)
            
            lock_col[dx] = false
            lock_ltrb[dx - row + n - 1] = false
            lock_rtlb[dx + row] = false
        end
    else
        m[] += 1
    end
end

main()

Kotlin

fun main(args: Array<String>) {
    if (args.size != 1) {
        println("Usage: kotlin NQueens.kt <board_size>")
        return
    }

    val n: Int
    try {
        n = args[0].toInt()
        if (n <= 0) {
            throw IllegalArgumentException("Board size must be a positive integer!")
        }
    } catch (e: Exception) {
        println("Invalid input! ${e.message}")
        return
    }

    val lockCol = BooleanArray(n) { false }
    val lockLtrb = BooleanArray(2 * n - 1) { false }
    val lockRtlb = BooleanArray(2 * n - 1) { false }

    println( "Solving: n=$n" )
    val result = solve( 0, n, lockCol, lockLtrb, lockRtlb )
    println( "Result:  $result" )
}

fun solve( row: Int, n: Int, lockCol: BooleanArray, lockLtrb: BooleanArray, lockRtlb: BooleanArray ): Int {
    return if ( row < n ) {
        var solutions = 0
        for ( dx in 0 until n ) {
            if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row]) {
                continue
            }

            lockCol[dx] = true
            lockLtrb[dx - row + n - 1] = true
            lockRtlb[dx + row] = true

            solutions += solve( row + 1, n, lockCol, lockLtrb, lockRtlb )

            lockCol[dx] = false
            lockLtrb[dx - row + n - 1] = false
            lockRtlb[dx + row] = false
        }
        solutions
    } else {
        1
    }
}

Lua

local function solve(row, n, lock_col, lock_ltrb, lock_rtlb)
    if row < n then
        for dx = 0, n-1 do
            if lock_col[dx] or lock_ltrb[dx - row + n - 1] or lock_rtlb[dx + row] then
                goto continue
            end

            lock_col[dx] = true
            lock_ltrb[dx - row + n - 1] = true
            lock_rtlb[dx + row] = true
            
            solve(row + 1, n, lock_col, lock_ltrb, lock_rtlb)
            
            lock_col[dx] = false
            lock_ltrb[dx - row + n - 1] = false
            lock_rtlb[dx + row] = false

            ::continue::
        end
    else
        count = count + 1
    end
end

if #arg ~= 1 then
    print("Usage: nqueens.lua <board_size>")
    return
end

local n = tonumber(arg[1])
if not n or n <= 0 then
    print("Invalid input! Board size must be a positive integer!")
    return
end

count = 0

local lock_col = {}
local lock_ltrb = {}
local lock_rtlb = {}

for i = 0, n-1 do
    lock_col[i] = false
    lock_ltrb[i] = false
    lock_rtlb[i] = false
end

print("Solving: n=" .. n)
solve(0, n, lock_col, lock_ltrb, lock_rtlb)
print("Result:  " .. count)

Nim

import os, strutils

var
  count = 0

proc solve(n: int, row: int, lockCol: var seq[bool], lockLtrb: var seq[bool], lockRtlb: var seq[bool]) =
  if row < n:
    for dx in 0..<n:
      if lockCol[dx] or lockLtrb[dx - row + n - 1] or lockRtlb[dx + row]:
        continue

      lockCol[dx] = true
      lockLtrb[dx - row + n - 1] = true
      lockRtlb[dx + row] = true

      solve(n, row + 1, lockCol, lockLtrb, lockRtlb)

      lockCol[dx] = false
      lockLtrb[dx - row + n - 1] = false
      lockRtlb[dx + row] = false
  else:
    inc(count)

proc main() =
  let args = commandLineParams()
  if args.len != 1:
    echo "Usage: nqueens <board_size>"
    return

  let n = parseInt(args[0])
  if n <= 0:
    echo "Invalid input! Board size must be a positive integer!"
    return
  
  var
    lockCol = newSeq[bool](n)
    lockLtrb = newSeq[bool](n*2-1)
    lockRtlb = newSeq[bool](n*2-1)

  for i in 0..<lock_col.len:
    lock_col[i] = false
  for i in 0..<lock_ltrb.len:
    lock_ltrb[i] = false
  for i in 0..<lock_rtlb.len:
    lock_rtlb[i] = false

  echo "Solving: n=", n
  solve(n, 0, lockCol, lockLtrb, lockRtlb)
  echo "Result:  ", count

main()

Ocaml

let () =
  if Array.length Sys.argv <> 2 then
    Printf.printf "Usage: ./nqueens <board_size>\n"
  else
    let n =
      try int_of_string Sys.argv.(1)
      with Failure _ ->
        Printf.printf "Invalid input! Board size must be a positive integer!\n";
        exit 1
    in
    if n <= 0 then
      Printf.printf "Invalid input! Board size must be a positive integer!\n"
    else
      let count = ref 0 in
      let rec solve row lock_col lock_ltrb lock_rtlb =
        if row < n then
          for dx = 0 to n - 1 do
            if not lock_col.(dx) && not lock_ltrb.(dx - row + n - 1) && not lock_rtlb.(dx + row) then begin

              lock_col.(dx) <- true;
              lock_ltrb.(dx - row + n - 1) <- true;
              lock_rtlb.(dx + row) <- true;
              
              solve (row + 1) lock_col lock_ltrb lock_rtlb;
              
              lock_col.(dx) <- false;
              lock_ltrb.(dx - row + n - 1) <- false;
              lock_rtlb.(dx + row) <- false;
            end
          done
        else
          incr count
      in

      let lock_col = Array.make n false in
      let lock_ltrb = Array.make (2 * n - 1) false in
      let lock_rtlb = Array.make (2 * n - 1) false in

      Printf.printf "Solving: n=%d\n" n;
      solve 0 lock_col lock_ltrb lock_rtlb;
      Printf.printf "Result:  %d\n" !count

Pascal

program NQueens;

uses SysUtils;

var
  n, code: Integer;
  count: Int64;

procedure Solve(row: Integer; var lock_col, lock_ltrb, lock_rtlb: array of Boolean);
var
  dx: Integer;
begin
  if row < n then
  begin
    for dx := 0 to n - 1 do
    begin
      if not lock_col[dx] and not lock_ltrb[dx - row + n - 1] and not lock_rtlb[dx + row] then
      begin
        lock_col[dx] := True;
        lock_ltrb[dx - row + n - 1] := True;
        lock_rtlb[dx + row] := True;

        Solve(row + 1, lock_col, lock_ltrb, lock_rtlb);

        lock_col[dx] := False;
        lock_ltrb[dx - row + n - 1] := False;
        lock_rtlb[dx + row] := False;
      end;
    end;
  end
  else
    Inc(count);
end;

var
  lock_col, lock_ltrb, lock_rtlb: array of Boolean;
  i: Integer;
begin
  if ParamCount <> 1 then
  begin
    Writeln('Usage: NQueens <board_size>');
    Halt(1);
  end;

  Val(ParamStr(1), n, code);
  if code <> 0 then
  begin
    Writeln('Invalid input! Board size must be a positive integer!');
    Halt(1);
  end;

  if n <= 0 then
  begin
    Writeln('Invalid input! Board size must be a positive integer!');
    Halt(1);
  end;

  Writeln('Solving: n=', n);

  count := 0;

  SetLength(lock_col, n);
  SetLength(lock_ltrb, 2 * n - 1);
  SetLength(lock_rtlb, 2 * n - 1);

  for i := 0 to n - 1 do
    lock_col[i] := False;

  for i := 0 to 2 * n - 2 do
  begin
    lock_ltrb[i] := False;
    lock_rtlb[i] := False;
  end;

  Solve(0, lock_col, lock_ltrb, lock_rtlb);

  Writeln('Result:  ', count);
end.

Perl

use strict;
use warnings;

my $n;
my $result = 0;

if (@ARGV != 1) {
    print "Usage: perl nqueens.pl <board_size>\n";
    exit;
}

if ($ARGV[0] =~ /^\d+$/) {
    $n = $ARGV[0];
} else {
    print "Invalid input! Board size must be a positive integer!\n";
    exit;
}

if ($n <= 0) {
    print "Invalid input! Board size must be a positive integer!\n";
    exit;
}

my @lock_col = (0) x $n;
my @lock_ltrb = (0) x (2 * $n - 1);
my @lock_rtlb = (0) x (2 * $n - 1);

print "Solving: n=$n\n";
$result = solve(0, $n, \@lock_col, \@lock_ltrb, \@lock_rtlb);
print "Result:  $result\n";

sub solve {
    my ($row, $n, $lock_col, $lock_ltrb, $lock_rtlb) = @_;
    return 1 if $row >= $n;

    my $solutions = 0;
    
    for my $dx (0 .. $n - 1) {
        if ($lock_col->[$dx] || $lock_ltrb->[$dx - $row + $n - 1] || $lock_rtlb->[$dx + $row]) {
            next;
        }

        $lock_col->[$dx] = 1;
        $lock_ltrb->[$dx - $row + $n - 1] = 1;
        $lock_rtlb->[$dx + $row] = 1;

        $solutions += solve($row + 1, $n, $lock_col, $lock_ltrb, $lock_rtlb);

        $lock_col->[$dx] = 0;
        $lock_ltrb->[$dx - $row + $n - 1] = 0;
        $lock_rtlb->[$dx + $row] = 0;
    }

    return $solutions;
}

PHP

<?php

if ($argc != 2) {
    echo "Usage: php NQueens.php <board_size>\n";
    exit;
}

if (is_numeric($argv[1]) && $argv[1] > 0) {
    $n = (int)$argv[1];
} else {
    echo "Invalid input! Board size must be a positive integer!\n";
    exit;
}

$lock_col = array_fill(0, $n, false);
$lock_ltrb = array_fill(0, 2 * $n - 1, false);
$lock_rtlb = array_fill(0, 2 * $n - 1, false);

echo "Solving: n=$n\n";
$result = solve(0, $n, $lock_col, $lock_ltrb, $lock_rtlb);
echo "Result:  $result\n";

function solve($row, $n, &$lock_col, &$lock_ltrb, &$lock_rtlb) {
    if ($row >= $n) {
        return 1;
    }

    $solutions = 0;
    for ($dx = 0; $dx < $n; $dx++) {
        if ($lock_col[$dx] || $lock_ltrb[$dx - $row + $n - 1] || $lock_rtlb[$dx + $row]) {
            continue;
        }

        $lock_col[$dx] = true;
        $lock_ltrb[$dx - $row + $n - 1] = true;
        $lock_rtlb[$dx + $row] = true;

        $solutions += solve($row + 1, $n, $lock_col, $lock_ltrb, $lock_rtlb);

        $lock_col[$dx] = false;
        $lock_ltrb[$dx - $row + $n - 1] = false;
        $lock_rtlb[$dx + $row] = false;
    }

    return $solutions;
}

?>

Python

import sys

def main():
    if len( sys.argv ) != 2:
        print("Usage: python NQueens.py <board_size>")
        return

    try:
        n = int( sys.argv[1] )
    except ValueError:
        print("Invalid input! Board size must be a positive integer!")
        return

    if n <= 0:
        print("Invalid input! Board size must be a positive integer!")
        return

    lock_col = [False] * n
    lock_ltrb = [False] * (2 * n - 1)
    lock_rtlb = [False] * (2 * n - 1)

    print( f"Solving: n={n}" )
    result = solve( 0, n, lock_col, lock_ltrb, lock_rtlb )
    print( f"Result:  {result}" )

def solve( row, n, lock_col, lock_ltrb, lock_rtlb ):
    if row >= n:
        return 1
    else:
        count = 0
        
        for dx in range( n ):
            if lock_col[dx] or lock_ltrb[dx - row + n - 1] or lock_rtlb[dx + row]:
                continue

            lock_col[dx] = True
            lock_ltrb[dx - row + n - 1] = True
            lock_rtlb[dx + row] = True

            count += solve( row + 1, n, lock_col, lock_ltrb, lock_rtlb )

            lock_col[dx] = False
            lock_ltrb[dx - row + n - 1] = False
            lock_rtlb[dx + row] = False

        return count

if __name__ == "__main__":
    main()

Racket

#lang racket

(define (main args)
  (if (= (length args) 1)
      (let ([n (string->number (car args))])
        (if (and (integer? n) (> n 0))
            (begin
              (printf "Solving: n=~a\n" n)
              (let ([solutions (solve 0 n (make-vector n #f)
                                      (make-vector (+ (* 2 n) -1) #f)
                                      (make-vector (+ (* 2 n) -1) #f))])
                (printf "Result:  ~a\n" solutions)))
            (printf "Invalid input. Please provide a positive integer.\n")))
      (printf "Usage: racket nqueens.rkt <board_size>\n")))

(define (solve row n lock-col lock-ltrb lock-rtlb)
  (if (< row n)
      (let loop ([dx 0] [solutions 0])
        (if (< dx n)
            (if (or (vector-ref lock-col dx)
                    (vector-ref lock-ltrb (+ (- dx row) (- n 1)))
                    (vector-ref lock-rtlb (+ dx row)))
                (loop (+ dx 1) solutions)
                (begin
                  (vector-set! lock-col dx #t)
                  (vector-set! lock-ltrb (+ (- dx row) (- n 1)) #t)
                  (vector-set! lock-rtlb (+ dx row) #t)
                  (let ([new-solutions (+ solutions
                                         (solve (+ row 1) n lock-col lock-ltrb lock-rtlb))])
                    (vector-set! lock-col dx #f)
                    (vector-set! lock-ltrb (+ (- dx row) (- n 1)) #f)
                    (vector-set! lock-rtlb (+ dx row) #f)
                    (loop (+ dx 1) new-solutions))))
            solutions))
      1))

;; Entry point
(main (vector->list (current-command-line-arguments)))

Ruby

class NQueens
  @n = 10
  @count = 0

  def self.solve(row, lock_col, lock_ltrb, lock_rtlb)
    if row < @n
      (0...@n).each do |dx|
        if lock_col[dx] || lock_ltrb[dx - row + @n - 1] || lock_rtlb[dx + row]
          next
        end

        lock_col[dx] = true
        lock_ltrb[dx - row + @n - 1] = true
        lock_rtlb[dx + row] = true

        solve(row + 1, lock_col, lock_ltrb, lock_rtlb)

        lock_col[dx] = false
        lock_ltrb[dx - row + @n - 1] = false
        lock_rtlb[dx + row] = false
      end
    else
      @count += 1
    end
  end

  def self.main
    if ARGV.length != 1
      puts "Usage: NQueens <board_size>"
      return
    end

    begin
      @n = Integer(ARGV[0])
    rescue ArgumentError
      puts "Invalid input! Board size must be a positive integer!"
      return
    end

    if @n <= 0
      puts "Invalid input! Board size must be a positive integer!"
      return
    end

    lock_col = Array.new(@n, false)
    lock_ltrb = Array.new(2 * @n - 1, false)
    lock_rtlb = Array.new(2 * @n - 1, false)

    puts "Solving: n=#{@n}"
    solve(0, lock_col, lock_ltrb, lock_rtlb)
    puts "Result:  #{@count}"
  end
end

NQueens.main

Rust

use std::env;

fn solve(
    row: usize,
    n: usize,
    lock_col: &mut Vec<bool>,
    lock_ltrb: &mut Vec<bool>,
    lock_rtlb: &mut Vec<bool>,
) -> usize {
    if row == n {
        return 1;
    }

    let mut count = 0;

    for dx in 0..n {
        let ltrb_index = dx + row;
        let rtlb_index = n - 1 + dx - row;

        if lock_col[dx] || lock_ltrb[ltrb_index] || lock_rtlb[rtlb_index] {
            continue;
        }

        lock_col[dx] = true;
        lock_ltrb[ltrb_index] = true;
        lock_rtlb[rtlb_index] = true;

        count += solve(row + 1, n, lock_col, lock_ltrb, lock_rtlb);

        lock_col[dx] = false;
        lock_ltrb[ltrb_index] = false;
        lock_rtlb[rtlb_index] = false;
    }

    count
}

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() != 2 {
        eprintln!("Usage: {} <board size>", args[0]);
        std::process::exit(1);
    }

    let n: usize = match args[1].parse() {
        Ok(num) if num > 0 => num,
        _ => {
            eprintln!("Error: Board size must be a positive integer.");
            std::process::exit(1);
        }
    };

    let mut lock_col = vec![false; n];
    let mut lock_ltrb = vec![false; 2 * n - 1];
    let mut lock_rtlb = vec![false; 2 * n - 1];

    println!("Solving: n={}", n);
    let result = solve(0, n, &mut lock_col, &mut lock_ltrb, &mut lock_rtlb);
    println!("Result:  {}", result);
}

Scala

object NQueens {

  var n = 10
  var count = 0

  def solve(): Int = {
    val lockCol = Array.fill(n)(false)
    val lockLtrb = Array.fill(2 * n - 1)(false)
    val lockRtlb = Array.fill(2 * n - 1)(false)

    solveRow(0, lockCol, lockLtrb, lockRtlb)
  }

  def solveRow(row: Int, lockCol: Array[Boolean], lockLtrb: Array[Boolean], lockRtlb: Array[Boolean]): Int = {
    if (row >= n) {
      1
    } else {
      var solutions = 0
      for (dx <- 0 until n) {
        if (lockCol(dx) || lockLtrb(dx - row + n - 1) || lockRtlb(dx + row)) {
          // Skip if the current position is not safe
          // Continue to next column
        } else {
          lockCol(dx) = true
          lockLtrb(dx - row + n - 1) = true
          lockRtlb(dx + row) = true

          solutions += solveRow(row + 1, lockCol, lockLtrb, lockRtlb)

          // Backtrack
          lockCol(dx) = false
          lockLtrb(dx - row + n - 1) = false
          lockRtlb(dx + row) = false
        }
      }
      solutions
    }
  }

  def main(args: Array[String]): Unit = {
    if (args.length != 1) {
      println("Usage: NQueens <board_size>")
      return
    }

    try {
      n = args(0).toInt
    } catch {
      case _: NumberFormatException =>
        println("Invalid input! Board size must be a positive integer!")
        return
    }

    if (n <= 0) {
      println("Invalid input! Board size must be a positive integer!")
      return
    }

    println(s"Solving: n=$n")
    count = solve()
    println(s"Result:  $count")
  }
}

TCL

#!/usr/bin/env tclsh

proc solve {row n} {
    global lock_col lock_ltrb lock_rtlb count

    if {$row == $n} {
        incr count
        return
    }

    for {set dx 0} {$dx < $n} {incr dx} {
        set ltrb_index [expr {$dx - $row + $n - 1}]
        set rtlb_index [expr {$dx + $row}]

        if {[info exists lock_col($dx)] && $lock_col($dx) == 1} continue
        if {[info exists lock_ltrb($ltrb_index)] && $lock_ltrb($ltrb_index) == 1} continue
        if {[info exists lock_rtlb($rtlb_index)] && $lock_rtlb($rtlb_index) == 1} continue

        set lock_col($dx) 1
        set lock_ltrb($ltrb_index) 1
        set lock_rtlb($rtlb_index) 1

        solve [expr {$row + 1}] $n

        unset lock_col($dx)
        unset lock_ltrb($ltrb_index)
        unset lock_rtlb($rtlb_index)
    }
}

if {[llength $argv] < 1} {
    puts "Usage: $argv0 <board size>"
    exit 1
}

set n [lindex $argv 0]

array set lock_col {}
array set lock_ltrb {}
array set lock_rtlb {}

set count 0

puts "Solving: n=$n"
solve 0 $n
puts "Result:  $count"

TypeScript

let n = 10;
let count = 0;

function solve(row: number, lockCol: boolean[], lockLtrb: boolean[], lockRtlb: boolean[]): number {
    if (row >= n) {
        return 1;
    } else {
        let solutions = 0;
        for (let dx = 0; dx < n; dx++) {
            if (lockCol[dx] || lockLtrb[dx - row + n - 1] || lockRtlb[dx + row]) {
                continue;
            }

            lockCol[dx] = true;
            lockLtrb[dx - row + n - 1] = true;
            lockRtlb[dx + row] = true;

            solutions += solve(row + 1, lockCol, lockLtrb, lockRtlb);

            lockCol[dx] = false;
            lockLtrb[dx - row + n - 1] = false;
            lockRtlb[dx + row] = false;
        }
        return solutions;
    }
}

function main() {
    const args = process.argv.slice(2);

    if (args.length !== 1) {
        console.log("Usage: NQueens <board_size>");
        return;
    }

    const input = parseInt(args[0]);
    if (isNaN(input)) {
        console.log("Invalid input! Board size must be a positive integer!");
        return;
    }

    n = input;

    if (n <= 0) {
        console.log("Invalid input! Board size must be a positive integer!");
        return;
    }

    let lockCol: boolean[] = new Array(n).fill(false);
    let lockLtrb: boolean[] = new Array(2 * n - 1).fill(false);
    let lockRtlb: boolean[] = new Array(2 * n - 1).fill(false);

    console.log(`Solving: n=${n}`);
    count = solve(0, lockCol, lockLtrb, lockRtlb);
    console.log(`Result:  ${count}`);
}

main();

Vala

public class NQueens {
	
	private static int n = 10;
	private static int count = 0;

	public static void main( string[] args ) {
		if( args.length != 2 ) {
			stdout.printf( "Usage: NQueens <board_size>\n" );
			return;
		}

		try {
			n = int.parse( args[ 1 ] );
		} catch( Error e ) {
			stdout.printf( "Invalid input! Board size must be a positive integer!" );
			return;
		}

		if( n <= 0 ) {
			stdout.printf( "Invalid input! Board size must be a positive integer!" );
			return;
    }

		stdout.printf( "Solving: n=%i\n", n );
		solve( 0, new bool[ n ], new bool[ n * 2 - 1 ], new bool[ n * 2 - 1 ] );
		stdout.printf( "Result:  %i\n", count );
	}
	
	private static void solve( int row, bool[] lock_col, bool[] lock_ltrb, bool[] lock_rtlb ) {
		if( row < n )
			for( int dx = 0; dx < n; dx++ ) {
				if( lock_col[ dx ] || lock_ltrb[ dx - row + n - 1 ] || lock_rtlb[ dx + row ] )
					continue;
				lock_col[ dx ] = true;
				lock_ltrb[ dx - row + n - 1 ] = true;
				lock_rtlb[ dx + row ] = true;
				solve( row + 1, lock_col, lock_ltrb, lock_rtlb );
				lock_col[ dx ] = false;
				lock_ltrb[ dx - row + n - 1 ] = false;
				lock_rtlb[ dx + row ] = false;
			}
		else
			count++;
	}
}

YABasic

open "n.txt" for reading as #1
line input #1 n
close #1

dim lock_col(n), lock_ltrb(n * 2 - 1), lock_rtlb(n * 2 - 1)
for i = 0 to n - 1
    lock_col(i) = 0
next
for i = 0 to 2 * n - 2
    lock_ltrb(i) = 0
    lock_rtlb(i) = 0
next

result = 0

print "Solving: n="; 
print n;
print "\n";

solve(0)

print "Result:  ";
print result
end

sub solve(row)
    if row >= n then
        result = result + 1
        return
    end if

    local col
    for col = 0 to n - 1
        if lock_col(col) = 1 or lock_ltrb(col - row + n - 1) = 1 or lock_rtlb(col + row) = 1 then
            rem continue
            rem next
        else
            lock_col(col) = 1
            lock_ltrb(col - row + n - 1) = 1
            lock_rtlb(col + row) = 1

            solve(row + 1)

            lock_col(col) = 0
            lock_ltrb(col - row + n - 1) = 0
            lock_rtlb(col + row) = 0
        end if

        next
    return
end sub