32 views

Uploaded by ZellDinch

Sample answer for the classical N-Queens problem using Prolog.

save

- Class19_Recursive and Recusrvively Enumerable Languages
- 1st Grand Test Correct Answer Key1
- 13697_String Buffer Methods
- resume-2
- Discrete Math
- Foundation of Digital Design- Sample Questions
- Discrete Mathematical Structures IS314 SUPPLEMENTARY EXAM 3RD SEM AUG 2017.Doc
- Chapter 6 Integers
- Questions
- Asymptotic Analysis of Superorthogonal Turbo Codes
- 1
- Opposite Generator Final Version
- Louis H. Kauffman- Space and Time in Computation and Discrete Physics
- ml
- Ht 3313461349
- Unit 2 Binary Traversal
- Beauty of Maths Pameran2 2011
- Untitled
- 3NF Synthesis Full Example
- Figura 1
- Combinatorial Methods With Computer Applications PDF
- Discrete Mathemetics MCA 114
- algebra1 equations two integers
- Lesson 17
- brianbrubach-cv
- CSC108 - Week 3 Notes
- The Axioms
- Tutorial 1
- Generalized Andrica Conjecture
- 1.2.1 Polynomial Functions
- Examination-timetable-GCE-Jan-115
- ROLI Fusing Technology and HCD Approaches in the World of Music
- 101231-town
- A Lovers Concerto
- BeethovenMoonlightSonata_mvt1
- Hiv
- dersEU3

**276: Introduction to Prolog Exercise 5: N Queens
**

(Based on an Exercise and Solution by Robert Craven)

**Solutions and Comments
**

November 2013

A chessboard is an 8 × 8 grid; the chess piece known as a ‘queen’ can attack along any horizontal, vertical and diagonal, as shown below:

The problem: place 8 queens on a chessboard, in such a way that no queen is attacking any other queen. Suppose that a queen in the mth column and the nth row is represented by the Prolog term q(m,n) (like Cartesian co-ordinates); a conﬁguration of the board is to be represented by a Prolog list. For example, the list [q(5,6),q(6,2),q(7,4),q(8,1)] would represent the partially-completed non-solution: 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 Notice that if all solutions are forced to have the ‘canonical’ form [q(1,Y1),q(2,Y2),q(3,Y3),q(4,Y4),q(5,Y5),q(6,Y6),q(7,Y7),q(8,Y8)] then we do not need to check that there are no vertical attacks. (Why?)

Page 1

mjs/276/5

Y)) :Y \= Y1. attack_pair(q(X. Queen) ). Here is one more method. attack_pair(q(X. Y1-Y =:= X1-X.no_attack([q(7. Queen) :attack(Rest.q(8. q(X. Here are a few possibilities and (Rob Craven) % ----. (PartialSoln will be ground. q(6.4).Y). variations._). mjs/276/5 Page 2 .Y1)) :- The ﬁrst clause for attack_pair/2 is not strictly necessary but I will include it since it is cheap and perhaps makes things clearer.Y)). no ?. so that checking for vertical attacks is unnecessary. yes You can assume that solutions are in the canonical form described above. q(6. q(X1.) For example (with reference to the grid above): ?. q(X.no_attack/2 (alternative) no_attack(Partial. Queen). Queen) : attack(Partial. attack_pair(Qx.no_attack/2 no_attack([]. attack_pair(q(_.N)) when a queen can be placed in the mth column and nth row without falling under attack from any of the queens in PartialSoln.1)]. attack_pair(q(X. Y1-Y =\= X-X1. q(X. You should assume that none of the queens in PartialSoln attack each other.q(8. Queen). There are many diﬀerent solutions to each of these exercises. Y1-Y =\= X1-X.Y1)) :q(X1.Y1)|Rest]. no_attack/2 above could also be written equivalently as: % ----.Y). % ----.Y). attack_pair(Qx.no_attack/2 (alternative. Solution.1. Partial). Queen) ).no_attack(PartialSoln. Queen) :forall(member(Qx. Write a program no attack/2. Partial). q(M. Queen) :attack_pair(Q. q(_. attack([_|Rest]. that combines attack_pair and member into one. no_attack([q(X1.Y))._)).no_attack([q(7. Y1-Y =:= X-X1. Queen). equivalently) no_attack(Partial.1)]. Alternatively: % ----.no_attack/2 no_attack(Partial. Queen) : (member(Qx. which succeeds on a call ?. This the solution I prefer (because it will be easiest to modify and generalise later). _).4).1)).2)). no_attack(Rest. attack([Q|_].

mjs/276/5 Page 3 . [1. you can just write: ?. Note how this works: template/1 gives the general form of the solution. Sols).4. so that ?.Y). q(X.8]). Using your answer from (1). write a program queens8/1. findall(X. queens8([q(X. member(Y. This is easy._).6.Y)|Rest]) :queens8(Rest).template(X). You should have a Prolog fact template/1 in the program.7._). Solution. Min) :Min =< Max. Sols). There is no point doing the (much more expensive) setof instead of findall if you don’t have to.q(5. to give the ‘canonical’ form of the solution. Construct a one-line query which gives you the number of solutions to the 8 Queens problem.q(6. queens8(X). which takes as argument a list representing an empty grid.8]).5. N).6._). setof(X.queens8/1 (Rob Craven) queens8([]). Max._). If you cannot assume that your program does not generate duplicate solutions. Max. How to make it tail recursive? Many ways.template(Sol).q(8. length(Sols. See discussion below. will give solutions. then ?. where in_range/3 is deﬁned as follows: % -----------.q(2.q(7. It is the job of queens8/1 to produce values for the columns by instantiating the variables.8.q(4.3. queens8(X).template(X). % ----. and returns a solution to the 8 Queens problem. X). length(Sols.7.2. Max. but represents one of the most intuitive ways to solve the problem.Y)). Note Instead of member(Y.q(3.5._). % to be on the safe side in_range(Min. we could write in_range(1._). NextMin is Min + 1._)._)]). [1.template/1 template([q(1. Given the previous answers. in_range(NextMin. % ----. queens8(Sol).4. Solution. X) :Min < Max. N).in_range/3 in_range(Min.2. 3. The following solution by Rob Craven is not tail recursive.3.2. no_attack(Rest.

Row).6. 8) ) ). Here is one way. QueenCol. nl.print_row/3 print_row(End. write(’_ ’) ). 8) ) ). % ----. Y).5.2. Max) :End > Max.1]).Row). forall( member(q(Col. ( member(q(Col. [8.7.3. _.5.4. forall( member(Row. print_row(1. NextCol is Col + 1.Board).forall/2 forall(X. nl. given the canonical list representation of the solution as input. [8.print_board/1 (Rob Craven. Write a program print board/1 which will output a picture of a completed solution. print_row(1. % ----. forall( member(Row. Y) : (X.7. There are many ways to do this.3.4. % could put a ’cut’ here nl. equivalently) print_board(Board) :nl. Solution.Board).print_board/1 (Rob Craven) print_board(Board) :nl. % could be omitted if ’cut’ above ( Col = QueenCol -> write(’Q ’) .4. Max) :Col =< Max. mjs/276/5 Page 4 . Something like the following should result: _ _ _ Q _ _ _ _ _ Q _ _ _ _ _ _ _ _ _ _ _ _ Q _ _ _ Q _ _ _ _ _ _ _ _ _ _ Q _ _ _ _ _ _ _ _ _ Q _ _ _ _ Q _ _ _ Q _ _ _ _ _ _ _ Prolog I/O primitives are not an examinable part of the course but what follows is a typical bit of procedural Prolog code. print_row(Col. using forall/2: % ----.2. print_board/1 could also have been expressed equivalently as follows: % ----. Col.1]). Col. Max). print_row(NextCol.6. QueenCol.

Question: Why are they equivalent? forall( P. R ) ) is the same as ( P. Q). y ) ) ) ∀x ∀y ( (P (x) ∧ Q(x. Col.5. nl. ( Q.2. R ) which is the same as forall( ( P. y )) → R(x. y ) → R(x. Q).3. 8) ). member(q(Col. forall( Q.1]). R ) In logic: ∀x ( P (x) → ∀y ( Q(x. y ) ) ) ≡ ≡ ∀x ∀y ( P (x) → ( Q(x.Board) ). ( Q. R ) ) is not logically equivalent but equivalent procedurally — but only because R is print_row(1. R ) ) is the same as (conjunction is associative) ( ( P. Pick whichever you think is clearest. 8) and so • never fails • is only used for its side-eﬀects (printing) mjs/276/5 Page 5 . y ) → R(x. R ) ) is the same as ( P. R ) ) is the same as ( P.4. print_row(1. forall( ( member(Row.print_board/1 (Rob Craven. equivalently again) print_board(Board) :nl. forall( Q. ( Q.And also like this: % ----. [8.Row).7. Col.6. y ) ) Rob Craven’s forall( P.

Row) :( Y = Row -> write(’Q ’) .We can also write print_row diﬀerently. q(2. 8).7. ] So to print row N we just recurse down the list representing the board looking for an entry q( . Row). q(4. q(3. write(’_ ’) ). print_row([q(X.N ).. . Row) ).6).5. print_row(Board. nl.4. _Row) :nl. [8. print_row(RestBoard.print_board/1 print_board(Board) :nl. by exploiting the fact that the board is represented in canonical form.Y)|RestBoard]. mjs/276/5 Page 6 . % ----. forall( member(Row.3).. Since the board is in ’canonical form’ it will look something like this [q(1.print_row/2 (recursive) print_row([].2.5).6.1]). as follows: % ----.3.

6.4. [q(X. CandCols. select(X.queens8_tr_opt/3 queens8_tr_opt([].8]). PartialSol) :member(Y. Y. [X|Y].Y)|PartialSol]. the PartialSol will be built up in reverse order. [q(X.Discussion: Some alternative (tail recursive) solutions First. Note(2) We do not need an additional argument to represent the ﬁnal solution. ColsRem). % ----. queens8_tr(Rest.Y)). using a ‘template’ for the ﬁnal solution: ?. % slightly optimised version (improved) queens8_tr_opt(Sol) :queens8_tr_opt(Sol.6.8]). initially []. % ----.2. queens8_tr_opt(Rest. Note(1) As written above. The second argument in queens8_tr/2 represents the partial solution constructed so far. let us keep a list of candidate column numbers (columns not used so far). _CandCols). mjs/276/5 Page 7 . Y). % _CandCols will be [] queens8_tr_opt([q(X. [U|Y]. no_attack(PartialSol.7. []).Y)).Y)|Rest]. queens8_tr([q(X. []. Note(3) We can improve the eﬃciency slightly. as above.select/3 select(X. no_attack(PartialSol. Z).5. We do not need to keep an explicit list of candidate column values remaining: the candidate values are just those that have not been used in PartialSol so far.7. []).3.template(Sol). Instead of generating all candidate values from 1 to 8 at every step. CandCols) :select(Y.2.4. Note(4) The above was just for illustration. _Sol. % ---------. [U|Z]) :select(X. ColsRem). % slightly optimised version queens8_tr_opt(Sol) :queens8_tr_opt(Sol. That does not matter because no_attack/2 as written does not depend on the order that items appear in its PartialSol argument. q(X. _PartialSol).3. The ‘template’ already stores the solution.Y)|PartialSol]).Y)|Rest]. q(X.5. [1. from position of the 8th queen back to the 1st.queens8_tr/2 % tail recursive queens8_tr([]. nor any call in the base case to reverse the partial solution into the right order. [1. queens8_tr/2 simply ﬁlls in values for the variables in the template. queens8_tr(Sol. PartialSol.

Y).% ----.6. Sol).Y). queens8_tr(NextM. Y). [1. PartialSoln). % -----.queens8_tr_opt/2 queens8_tr_opt([].queens8_tr/1 (recursive. Sol. ColsRem).Y)). 8 queens8_tr(0. _Sol). in_range(1. Final) :M > 0.5. % PartialSoln has queens in columns M+1 . then 7th queen in column 7.Y)|PartialSol].e. 8.2. PartialSoln. []. % alternatively: % member(Y. Discussion: an alternative (tail recursive) solution Suppose we don’t use a ‘template’. queens8_tr_opt(Rest. % ------queens8_tr/3 % queens8_tr(M. i. q(M. % alternatively: % member(Y. Final) % place queen M.5. is unchanged. [q(X. It is easiest to go from the right. Final). 8. no template) queens8_tr(Sol) :queens8_tr(8. [1. % optional no_attack(PartialSoln.7. [q(M. no_attack(PartialSol. Y). NextM is M-1.4. PartialSoln. Sol).4.. .7. .8]).8]). Solve the problem by means of the query: ?.Y)|PartialSoln].Y)). member(q(_. queens8_tr(M. Let us solve the problem by building up a partial solution. PartialSol) :in_range(1. q(X.Y)|Rest].2. mjs/276/5 Page 8 . The printing of the board etc.3.3. placing 8th queen in column 8. member(q(_. queens8_tr_opt([q(X. .6.queens8_tr(Sol). PartialSol).

Sol). attack_pair(q(_. attack([_|Rest]. rewrite your program to use this new representation.Q). [Y|PartialSoln].3. The only thing we need to change is attack/2 since that is the only component of the program that depends on how the board is represented.6. % ----------. % ----------.7. Sol.5. we could alter our terms so that. PartialSoln). q(_. q(M.6. [1.4.attack_pair/2 attack_pair(q(X. Mx.Y).7). for efficiency Mx is M + 1.1. Queen).2. % ----------. One could do one with a ‘template’ too but I will not bother. % queens8_tr(M. MxNext. Queen) :attack_pair(q(Mx. queens8_tr(NextM.) Every solution will thus be a permutation of [1.6).8]).3. member(Y. attack_pair(q(X. Mx.Y)).4. Final) :M > 0. 8 queens8_tr(0. attack(PartialSoln. instead of [q(1.5. Sol).q(2.q(4.5. NextM is M-1. PartialSoln. queens8_tr(M. Queen)._)). PartialSoln.5] This gives a much more compact representation.2.5)] we have [3. Y1-Y =:= X1-X.Y1)) :q(X1. attack_pair(q(X.8. % alternatively: % member(Y.Y1)) :- Page 9 . There is a redundancy in the data structures we are using to represent our chessboards.Y)).attack/3 % attack(PartialSoln. Queen) % PartialSoln has queens placed in columns Mx .2).Y).4.2. []. Y1-Y =:= X-X1.6. % optional. Final) % place queen M where % PartialSoln has placed queens M+1 . (New ﬁle so we can use the same predicates without name clashes.q(3. Mx..Y). 8 attack([Q|_]. for example. q(X1.8). attack(Rest. Final).q(5.q(8. Queen) :MxNext is Mx + 1.q(7.3). in_range(1. As the mth element of our list represents the mth column. In a new ﬁle. mjs/276/5 q(X. Here is a solution without a ‘template’..1).4). Mx._).Y).7.8.8] Solution.q(6.queens8_tr/1 and queens8_tr/3 queens8_tr(Sol) :queens8_tr(8.7.

1. Max. Both will generate all solutions eventually. nl. NextMax is Max . print_row(RestBoard. mjs/276/5 Page 10 . % ----------- print_board/1 print_board(Board) :length(Board. in_range_desc(Min. but whether we use in_range/3 or in_range_desc/3 to generate candidate values in queens8_tr/3 makes no diﬀerence. % to be on the safe side in_range_desc(Min. X). write(’_ ’) ). though in a diﬀerent order.For printing the Board: % ----------. _Row) :nl. print_row([Y|RestBoard]. % ----------print_row/2 print_row([]. Row) ). NextMax. Note that we could dispense with in_range/3. print_row(Board. We need in_range_desc/3 to print the board rows in the correct order.N. Max) :Min =< Max. forall( in_range_desc(1. Row) :( Y = Row -> write(’Q ’) . highest to lowest.Row). nl. X) :Min < Max.in_range_desc/3 in_range_desc(Min. N). Row). Max.

% to be on the safe side queensN_tr(N. The 8 Queens problem can be generalized to the ‘n Queens’ problem. there is an n × n grid and n queens. attack/3 and attack_pair/2 are unchanged (they do not depend on number of queens). Sol. Mx. NextM is M-1. [Y|PartialSoln]. % this is the only change! member(Y. for efficiency Mx is M + 1.. The printing of the board is unchanged (my version). Solution. Sol).queensN_tr/2 and queensN_tr/3 queensN_tr(N. PartialSoln). attack(PartialSoln. [].6. Modify your answer for (5) to solve the n Queens problem. Sol). in_range(1.) % ----------. N queensN_tr(0. PartialSoln. PartialSoln.Y). queensN_tr(NextM. (One could do one with a ‘template’ too but I will not bother. where instead of an 8 × 8 chessboard. Final) :M > 0. N > 0. Final). mjs/276/5 Page 11 . % queensN_tr(M. Final) % place queen M where % PartialSoln has placed queens M+1 . % optional.N. queensN_tr(M.Y)). Sol) :integer(N). q(M. The generalisation of the previous program to n queens is trivial.

- Class19_Recursive and Recusrvively Enumerable LanguagesUploaded byNavneet Kumar
- 1st Grand Test Correct Answer Key1Uploaded byMohammad Javed Iqbal
- 13697_String Buffer MethodsUploaded byKaran Gaba
- resume-2Uploaded byapi-265700012
- Discrete MathUploaded byKathy Migz
- Foundation of Digital Design- Sample QuestionsUploaded byNavodya Nuwanthi
- Discrete Mathematical Structures IS314 SUPPLEMENTARY EXAM 3RD SEM AUG 2017.DocUploaded byVikas NS
- Chapter 6 IntegersUploaded bynorzalizah
- QuestionsUploaded byTushiana Ragoo
- Asymptotic Analysis of Superorthogonal Turbo CodesUploaded byvmaiz
- 1Uploaded byDhaval Mehta
- Opposite Generator Final VersionUploaded byRM_1958
- Louis H. Kauffman- Space and Time in Computation and Discrete PhysicsUploaded byJiamsD
- mlUploaded byRaduC43
- Ht 3313461349Uploaded byAnonymous 7VPPkWS8O
- Unit 2 Binary TraversalUploaded byAashishBatchali
- Beauty of Maths Pameran2 2011Uploaded byrospokoksena
- UntitledUploaded byapi-174391216
- 3NF Synthesis Full ExampleUploaded byJohn Gong
- Figura 1Uploaded byJacson Ferreira
- Combinatorial Methods With Computer Applications PDFUploaded byKrystal
- Discrete Mathemetics MCA 114Uploaded byRoby Dcosta
- algebra1 equations two integersUploaded byapi-314809600
- Lesson 17Uploaded bydelsonwiest
- brianbrubach-cvUploaded byapi-292952528
- CSC108 - Week 3 NotesUploaded byMmxSeller
- The AxiomsUploaded byPratheebanR
- Tutorial 1Uploaded byEdward Cumberlege
- Generalized Andrica ConjectureUploaded byscience2010
- 1.2.1 Polynomial FunctionsUploaded byElaine Smith

- Examination-timetable-GCE-Jan-115Uploaded byZellDinch
- ROLI Fusing Technology and HCD Approaches in the World of MusicUploaded byZellDinch
- 101231-townUploaded byZellDinch
- A Lovers ConcertoUploaded byZellDinch
- BeethovenMoonlightSonata_mvt1Uploaded byZellDinch
- HivUploaded byZellDinch
- dersEU3Uploaded byZellDinch