एन-क्वींस समस्या [बंद]

Question

शतरंज में, एक रानी जहां तक ​​जा सकती है, बोर्ड क्षैतिज रूप से, लंबवत या तिरछे रूप में फैली हुई है।

एक NxN आकार की बिसात को देखते हुए, यह पता करें कि कितने संभावित पदों पर N रानियों को बोर्ड पर रखा जा सकता है और 1 चाल में एक दूसरे को मारने में सक्षम नहीं हैं।

Comments

क्या हमें 2 <= N <= 4 मामलों को संभालने की आवश्यकता है? यदि हां, तो कैसे?

— 12

मामले का कोई समाधान नहीं है: एन = 2,3। इस क्लासिक समस्या के बारे में विकिपीडिया का एक उत्कृष्ट लेखन है। यह N = 1 से N = 14. के समाधान नंबर के बारे में अच्छी तरह से दस्तावेज करता है (मैं अभी भी कोड गोल्फ में नया हूं। यकीन नहीं कि अभी तक भाग लेने का सबसे अच्छा तरीका क्या है। :))

— Dongshengcn

A000170

— पीटर टेलर

Answer 1

यहाँ एक समाधान है (मूल रूप से इस ब्लॉग प्रविष्टि से ) जहाँ मैं समाधान का तार्किक विवरण सामान्य रूप में तैयार करता हूँ जो बाद में गणितज्ञ द्वारा हल किया जाता है:

(* 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

यहाँ उत्पादन है:

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

Answer 2

माणिक

मुझे एक golfटैग नहीं दिख रहा है , इसलिए मुझे लगता है कि यह सिर्फ एक चुनौती है।

यहाँ विकिपीडिया पर उल्लिखित एल्गोरिथम का कार्यान्वयन है। यह मेरे द्वारा नहीं है, यह रोसेटा स्टोन पर है और यहां पाया जा सकता है

इस उत्तर का जवाब दिया।

Answer 3

पायथन 2, 190 185 वर्ण

itertools आयात से *
एन = इनपुट ()
प्रिंट लेन (फिल्टर (लैम्ब्डा x: all) (1 ^ (y in (z, z + ij, z-i + j)) के लिए i, y के लिए enumerate (x) में j, z में enumerate (x [: i) + (1e9,) + x [i + 1:])), क्रमपरिवर्तन (रेंज (1, n + 1), एन)))

मैंने अभी भी कोड गोल्फ टैग ग्रहण किया था, हालांकि यह वहां नहीं था। स्टड से एन को पढ़ा जाता है, कार्यक्रम स्वीकार्य समय में n = 10 तक के समाधानों की गणना करता है।

Answer 4

ग्रूवी

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() 
}

इस तरह सभी रानी समाधानों की एक सूची वितरित करता है:

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

चित्रमय प्रतिनिधित्व के लिए जोड़ें:

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

जो इस तरह दिखता है:

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