Eight queens puzzle solutions

#include <stdio.h>
#include <stdbool.h>
int row[8], s = 0;
bool safe(int x, int y)
{
        int i;
        for (i = 1; i <= y; i++)
                if (row[y - i] == x || row[y - i] == x - i || row[y - i] == x + i) return false;
        return true;
}
void putboard()
{
        printf("\nSolution #%d:\n---------------------------------\n", ++s);
        int x,y;
        for (y = 0; y < 8; printf("|\n---------------------------------\n"), y++)
                for (x = 0; x < 8; printf(x++ == row[y] ? "| Q " : "|   "));
}
int main(int y)
{
        int x;
        for (x = 0; x < 8; x++)
                if (safe(row[y - 1] = x, y - 1))
                        if (y < 8) main(y + 1);
                        else putboard();
        return 0;
}

# As always in Python, rows and columns are indexed from zero.
 
def n_queens(n, width):
    """
    Return a list of solutions to the `n`-queens problem 
    on an `n`-by-width board.  A solved board is expressed 
    as a list of column positions for queens, indexed by row.
    """
    if n == 0:
        return [[]] # one solution, the empty list
    else:
        return add_queen(n-1, width, n_queens(n-1, width))
 
def add_queen(new_row, width, previous_solutions):
    """
    Try all ways of adding a queen to a column of row `new_row`, 
    returning a list of solutions.  `previous_solutions` must be 
    a list of `new_row`-queens solutions.
    """
    solutions = []
    for sol in previous_solutions:
        # Try to place a queen on each column on row new_row.
        for new_col in range(width):
            # print 'trying', new_col, 'on row', new_row
            if safe_queen(new_row, new_col, sol):
                # No interference, so add this solution to the list.
                solutions.append(sol + [new_col])
    return solutions
 
def safe_queen(new_row, new_col, sol):
    """
    Is it safe to add a queen to `sol` at `(new_row, new_col)`?  
    Return True if so.  `sol` must be a solution to the `new_row`-queens 
    problem.
    """
    # Check against each piece on each of the new_row existing rows.
    for row in range(new_row):
        if (sol[row] == new_col or                  # same column clash
            abs(sol[row] - new_col) == abs(row - new_row)):   # diagonal clash
                return 0
    return 1
 
for sol in n_queens(8, 8):
   print sol

#!/usr/bin/ruby
 
$count = 0
 
# Given a list of k queens in consectutive columns, determine if
# they're in a safe position.  Queens are a list of [y] where the
# origin is at the lower left of the board, starting from 0.
def safe?(queens)
  $count += 1
  queens.each_with_index do |x1,y1| queens[y1+1..-1].each_with_index do |x2,y2|
      # floating point tolerances ok for small values of queens.size.
      # Check for diagonal or row attacks.
      return false if ((y2+1).to_f/(x2-x1)).abs == 1.0 || x1 == x2
  end end
  return true
end
 
def find_next_for_one(queens)
  (0..7).collect{|y| safe?(queens + [y]) ? queens + [y] : nil}.compact
end
 
def find_next_for_all(layouts)
  # The inject serves to flatten a [[[]...]...] into a [[]...] structure
  layouts.collect{|queens| find_next_for_one(queens)}.inject([]){|a,q| a+q}
end
 
def print_solution(soln)
  len = soln.length
  puts ('+-' * len) + '+'
  soln.reverse.each{|x| puts '|'+(' |'*x)+'*|'+(' |'*(len-x-1)),('+-'*len)+'+'}
end
 
if __FILE__ == $0
  s = (1..7).inject((0..7).map{|n| [n]}){|layouts,i| find_next_for_all(layouts)}
  puts "Total: #{$count} solutions tried, #{s.length} found."
  s.each do |soln|
    print_solution soln
    $stdin.gets
  end
end

public class Queens
    {
        List<PiecePosition> position;
        int queens = 8;
 
        /// <summary>
        /// Class that holds the position information for a piece
        /// </summary>
        protected class PiecePosition
        {
            int _column = -1;
            int _row = -1;
 
            public PiecePosition(int column, int row)
            {
                _column = column;
                _row = row;
            }
 
            public int Column
            {
                get { return _column; }
                set { _column = value; }
            }
 
            public int Row
            {
                get { return _row; }
                set { _row = value; }
            }
 
            public bool IsOrigin
            {
                get { return (_column == 0 && _row == 0) ? true : false; }
            }
 
            public bool IsCrossSection
            {
                get { return (_column == _row) ? true : false; }
            }
        }
 
        /// <summary>
        /// Main method outputs to the console
        /// </summary>
        /// <param name="NoOfQueens">Number of queens to solve for</param>
        public void Solve(int NoOfQueens)
        {
            int iterations = 0;
            queens = NoOfQueens;
 
            position = new List<PiecePosition>();
            int conflictIndex, newConflictIndex;
            PlaceQueens();
 
            conflictIndex = GetHighestConflict(-1);
            PiecePosition newPiecePosition;
            while (conflictIndex > -1)
            {
                newPiecePosition = GetLowestConflictPosition(conflictIndex);
                if (newPiecePosition == null)
                    break;
                position[conflictIndex] = newPiecePosition;
 
                if (iterations > (queens *2 ))
                {
                    iterations = 0;
                    PlaceQueens();
                }
 
                newConflictIndex = GetHighestConflict(-1);
                if (newConflictIndex == conflictIndex)
                    conflictIndex = GetHighestConflict(newConflictIndex);
                else
                    conflictIndex = newConflictIndex;
 
                iterations++;
            }
            Console.WriteLine("-----------------------------------------------------------------");
            Console.WriteLine("{0} x {0} board", queens);
            Console.WriteLine("{0} steps needed", iterations);
            for (int index = 0; index < queens; index++)
            {
                Console.WriteLine("{0} : {1} ", new object[] { position[index].Column,
                 position[index].Row });
            }
 
            Console.WriteLine("-----------------------------------------------------------------");
        }
 
        /// <summary>
        /// Places the queens one per column and one per row on the chessboard, .
        /// </summary>
        protected void PlaceQueens()
        {
 
            int[] pos = new int[queens];
 
            for (int i = 0; i < queens; i++)
            {
                pos[i] = i;
            }
 
            for (int i = 0; i < queens; i++)
            {
                pos=Shuffle(pos);
            }
 
            position.Clear();
            for (int i = 0; i < queens; i++)
            {
                position.Add(new PiecePosition(i, pos[i]));
            }
        }
 
        /// <summary>
        /// Gets the Piece with the highest number of conflicts.
        /// </summary>
        /// <param name="SkipIndex">Is the index of the piece to skip if it returns as the highest more than once</param>
        /// <returns>the index of the piece with the highest number of conflicts.</returns>
        protected int GetHighestConflict(int SkipIndex)
        {
            int conflictCount = 0;
            int highest = 0;
            int pos = -1;
            for (int pieceIndex = 0; pieceIndex < queens; pieceIndex++)
            {
                if (pieceIndex == SkipIndex)
                    continue;
 
                conflictCount = GetPieceConflicts(pieceIndex);
 
                if (highest < conflictCount)
                {
                    highest = conflictCount;
                    pos = pieceIndex;
                }
            }
 
            return pos;
        }
 
        /// <summary>
        /// Gets the number of conflicts a piece has.
        /// </summary>
        /// <param name="index">Index of piece being checked</param>
        /// <returns>Number of conflicts</returns>
        protected int GetPieceConflicts(int index)
        {
            int conflicts = 0;
            for (int pieceIndex = 0; pieceIndex < queens; pieceIndex++)
            {
                if (pieceIndex == index)
                    continue;
 
                if ((position[index].Row == position[pieceIndex].Row) || (position[index].Column == position[pieceIndex].Column))
                    conflicts++;
                else
                    if (AreDiagonal(position[index], position[pieceIndex])) conflicts++;
            }
 
            return conflicts;
        }
 
        /// <summary>
        /// Gets the number of conflicts that a position has.
        /// </summary>
        /// <param name="column">Column of the position</param>
        /// <param name="row">Row of the position</param>
        /// <returns>Number of conflicts</returns>
        protected int GetPositionConflicts(int column, int row)
        {
            int conflicts = 0;
            for (int i = 0; i < queens; i++)
            {
                if ((row == position[i].Row) || (column == position[i].Column))
                    conflicts++;
                else
                    if (AreDiagonal(new PiecePosition(column, row), position[i])) conflicts++;
            }
 
            return conflicts;
        }
 
        /// <summary>
        /// Gets the position in the same column as the chosen piece that has the least number of conflicts
        /// </summary>
        /// <param name="index">Index of the piece</param>
        /// <returns>New piece position</returns>
        protected PiecePosition GetLowestConflictPosition(int index)
        {
            int conflictCount = 0;
            int lowest = 7;
            int row = -1;
            for (int iRow = 0; iRow < queens; iRow++)
            {
                if (iRow == position[index].Row)
                    continue;
 
                conflictCount = GetPositionConflicts(position[index].Column, iRow);
 
                if (lowest > conflictCount)
                {
                    lowest = conflictCount;
                    row = iRow;
                }
            }
            if (row < 0)
                return null;
            else
                return new PiecePosition(position[index].Column, row);
        }
 
        /// <summary>
        /// Shuffles an array 
        /// </summary>
        /// <param name="arr">The array to be shuffled</param>        
        protected int[] Shuffle(int[] arr)
        {
            int curValue = 0, newPos = 0;
            Random rand = new Random((int)DateTime.Now.Ticks);
            int max = arr.Length;
            for (int i = 0; i < max; i++)
            {
                newPos = rand.Next(0, max);
                curValue = arr[i];
                arr[i] = arr[newPos];
                arr[newPos] = curValue;
            }
 
            return arr;
        }
 
        /// <summary>
        /// Determines if two pieces are diagonal from each other
        /// </summary>
        /// <param name="piece1">First piece</param>
        /// <param name="piece2">Second piece</param>
        /// <returns>Boolean true if they are diagonal, or false if they are not</returns>
        protected static bool AreDiagonal(PiecePosition piece1, PiecePosition piece2)
        {
            if (piece1.IsCrossSection && piece2.IsCrossSection)
                return true;
            else if (piece1.IsOrigin || piece2.IsOrigin)
                return false;
 
            int diffRow = 0;
            int diffCol = 0;
            diffRow = Math.Abs(piece1.Row - piece2.Row);
            diffCol = Math.Abs(piece1.Column - piece2.Column);
 
            if (diffRow == diffCol)
                return true;
 
            return false;
        }
    }