N-Queens Problem [geschlossen]

9

Im Schach kann sich eine Königin so weit bewegen, wie sich das Brett horizontal, vertikal oder diagonal erstreckt.

Drucken Sie bei einem Schachbrett der Größe NxN aus, wie viele Positionen N Königinnen auf dem Brett platziert werden können und sich nicht in einem Zug gegenseitig schlagen können.

code-challenge combinatorics chess

— Dan McGrath
quelle

Müssen wir 2 <= N <= 4 Fälle behandeln? Wenn das so ist, wie?

— st0le

Für den Fall gibt es keine Lösung: N = 2,3. Die Wikipedia hat eine ausgezeichnete Beschreibung dieses klassischen Problems. Es dokumentiert sehr gut über die Lösungsnummer von N = 1 bis N = 14. (Ich bin noch neu bei Code Golf. Ich bin mir nicht sicher, wie ich am besten teilnehmen kann. :))

— Dongshengcn

A000170

— Peter Taylor

4

Hier ist eine Lösung (ursprünglich aus diesem Blogeintrag ), in der ich eine logische Beschreibung der Lösung in konjunktiver Normalform konstruiere, die dann von Mathematica gelöst wird:

(* Define the variables: Q[i,j] indicates whether there is a 
   Queen in row i, column j *)
Qs = Array[Q, {8, 8}];

(* Define the logical constraints. *)
problem =
  And[
   (* Each row must have a queen. *)
   And @@ Map[(Or @@ #) &, Qs],
   (* for all i,j: Q[i,j] implies Not[...] *)
   And @@ Flatten[
     Qs /. Q[i_, j_] :>
       And @@ Map[Implies[Q[i, j], Not[#]] &, 
         Cases[Qs, 
          Q[k_, l_] /;
           Not[(i == k) && (j == l)] && (
             (i == k) ||          (* same row *)
                 (j == l) ||          (* same column *)
             (i + j == k + l) ||  (* same / diagonal *)
             (i - j == k - l)),   (* same \ diagonal *)
          2]]]];

(* Find the solution *)
solution = FindInstance[problem, Flatten[Qs], Booleans] ;

(* Display the solution *)
Qs /. First[solution] /. {True -> Q, False -> x} // MatrixForm

Hier ist die Ausgabe:

x   x   x   x   Q   x   x   x
x   Q   x   x   x   x   x   x
x   x   x   Q   x   x   x   x
x   x   x   x   x   x   Q   x
x   x   Q   x   x   x   x   x
x   x   x   x   x   x   x   Q
x   x   x   x   x   Q   x   x
Q   x   x   x   x   x   x   x

— Nibot
quelle

0

Rubin

Ich sehe kein golfTag, also gehe ich davon aus, dass es nur eine Herausforderung ist.

Hier ist eine Implementierung des auf Wikipedia erwähnten Algorithmus. Es ist nicht von mir, es ist bei Rosetta Stone und kann hier gefunden werden

CommWikied diese Antwort.

— st0le
quelle

0

Python 2, 190 185 Zeichen

aus itertools importieren *
n = Eingabe ()
print len (Filter (Lambda x: alle (1 ^ (y in (z, z + ij, z-i + j)) für i, y in Aufzählung (x) für j, z in Aufzählung (x [: i]) + (1e9,) + x [i + 1:])), Permutationen (Bereich (1, n + 1), n)))

Ich habe nur den Code Golf Tag angenommen, obwohl er nicht da war. Wird N aus stdin gelesen, berechnet das Programm Lösungen bis zu n = 10 in akzeptabler Zeit.

— cemper93
quelle

0

Groovy

n=8
s=(1..n).permutations().findAll{ 
  def x=0,y=0
  Set a=it.collect{it-x++} 
  Set b=it.collect{it+y++} 
  a.size()==it.size()&&b.size()==it.size() 
}

Liefert eine Liste aller Queen-Lösungen wie folgt:

[ [4, 7, 3, 0, 6, 1, 5, 2], 
  [6, 2, 7, 1, 4, 0, 5, 3], 
  ... ]

Zur grafischen Darstellung hinzufügen:

s.each { def size = it.size()
         it.each { (it-1).times { print "|_" }
                   print "|Q"
                   (size-it).times { print "|_" }
                   println "|"
                 }
         println ""
         }

das sieht so aus:

|_|Q|_|_|_|_|_|_|
|_|_|_|Q|_|_|_|_|
|_|_|_|_|_|Q|_|_|
|_|_|_|_|_|_|_|Q|
|_|_|Q|_|_|_|_|_|
|Q|_|_|_|_|_|_|_|
|_|_|_|_|_|_|Q|_|
|_|_|_|_|Q|_|_|_|

— Jonas Eicher
quelle