human
Pouvez-vous écrire du code C# qui peut trouver le placement approprié des reines sur un échiquier
gpt
Le puzzle connu sous le nom de N queens est un problème qui consiste à placer N reines d'échecs sur un échiquier de taille N×N de telle sorte que aucune reine ne puisse menacer une autre. Cela signifie qu'une solution valide doit garantir qu'aucune reine ne soit positionnée sur la même ligne, colonne ou diagonale du plateau.

```
// Code C# pour le placement des n reines
using System;

class GfG
{
    static void breakLine()
    {
        Console.Write("\n---------------------------------\n");
    }

    // taille maximale de l'échiquier
    static int MAX = 10;

    // tableau pour stocker les placements des reines
    static int[] arr = new int[MAX];

    // variable pour compter le nombre de solutions trouvées
    static int no;

    // fonction récursive pour trouver les solutions
    static void nQueens(int k, int n)
    {
        // essayer toutes les positions possibles pour la reine dans la ligne actuelle
        for (int i = 1; i <= n; i++)
        {
            // vérifier si la reine peut être placée à la position actuelle
            if (canPlace(k, i))
            {
                // placer la reine à la position actuelle
                arr[k] = i;

                // si toutes les reines sont placées, afficher la solution
                if (k == n)
                {
                    display(n);
                }
                else
                {
                    // essayer récursivement de placer les reines restantes
                    nQueens(k + 1, n);
                }
            }
        }
    }

    // fonction d'aide pour vérifier si la reine peut être placée à la position actuelle
    static bool canPlace(int k, int i)
    {
        for (int j = 1; j <= k - 1; j++)
        {
            // vérifier si une reine est déjà placée dans la même colonne ou diagonale
            if (arr[j] == i || (Math.Abs(arr[j] - i) == Math.Abs(j - k)))
            {
                return false;
            }
        }
        return true;
    }

    // fonction pour afficher la solution
    static void display(int n)
    {
        breakLine();
        Console.Write("Arrangement No. " + ++no);
        breakLine();

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                // afficher '_' pour une case vide et 'Q' pour une case avec une reine
                if (arr[i] != j)
                {
                    Console.Write("\t_");
                }
                else
                {
                    Console.Write("\tQ");
                }
            }
            Console.WriteLine("");
        }

        breakLine();
    }

    // Code pilote pour initialiser le problème et appeler la fonction récursive
    public static void Main(String[] args)
    {
        int n = 4; // taille de l'échiquier
        nQueens(1, n);
    }
}
```

Le code ci-dessus affichera la sortie suivante :
```
---------------------------------
Arrangement No. 1
---------------------------------
    _    Q    _    _
    _    _    _    Q
    Q    _    _    _
    _    _    Q    _

---------------------------------

---------------------------------
Arrangement No. 2
---------------------------------
    _    _    Q    _
    Q    _    _    _
    _    _    _    Q
    _    Q    _    _

---------------------------------
```