Data update

Task/N-queens-problem/6502-Assembly/n-queens-problem-1.6502

@@ -0,0 +1,74 @@
+n       equ 8 ; queens
+maximum equ 32 ; only limited by time
+place   equ $00
+count   equ maximum+place ; 64 bits (8 bytes)
+length  equ maximum+8
+        org $80
+start
+	LDY #n ; n queens on an n x n board
+	STY  greater+1
+	DEY
+	STY  safe+1
+	LDX #length
+	LDA #$00
+clear
+	STA  place,X
+	DEX
+	BPL  clear
+next
+	INX
+	LDA #$FF
+	STA  place,X
+loop
+	INC  place,X
+	LDA  place,X
+greater
+	CMP #n
+	BCS  max
+	STX  index+1
+index
+	LDY #$00 ; index+1
+	BEQ  safe
+	DEY
+	STA  compare+1
+	STA  add+1 ; compare
+	STA  sub+1 ; compare
+issafe
+	LDA  place,Y
+compare
+	CMP #$00 ; compare+1
+	BEQ  loop ; unsafe
+	INC  add+1
+add
+	CMP #$00 ; add+1
+	BEQ  loop ; unsafe
+	DEC  sub+1
+sub
+	CMP #$00 ; sub+1
+	BEQ  loop ; unsafe
+	DEY
+	BPL  issafe
+safe
+	CPX #n-1
+	BNE  next
+	INC  count ; 64 bits (8 bytes)
+	BNE  loop
+	INC  count+1
+	BNE  loop
+	INC  count+2
+	BNE  loop
+	INC  count+3
+	BNE  loop
+	INC  count+4
+	BNE  loop
+	INC  count+5
+	BNE  loop
+	INC  count+6
+	BNE  loop
+	INC  count+7
+	BNE  loop
+	BRK
+max
+	DEX
+	BPL  loop
+;	RTS

Task/N-queens-problem/6502-Assembly/n-queens-problem-2.6502

@@ -0,0 +1,20 @@
+	org  $C00
+	PHP
+	SEI
+	JSR  swap
+	JSR  $0080
+	JSR  swap
+	PLP
+	jmp end
+swap
+	LDX #$00
+loop
+	LDY  $D00,X
+	LDA  $00,X
+	STY  $00,X
+	STA  $D00,X
+	INX
+	BNE  loop
+	RTS
+end
+;	RTS

Task/N-queens-problem/Applesoft-BASIC/n-queens-problem.basic

@@ -0,0 +1,3 @@
+ 1  READ N,T,M,R(0): FOR Y = 0 TO M STEP 0: FOR L = 0 TO T STEP 0:R(Y) = R(Y) + T:X = R(Y):C =  NOT Y: IF  NOT C THEN  FOR I = T TO Y:A = R(Y - I): IF  NOT (A = X OR A = X - I OR A = X + I) THEN  NEXT I:C = T
+ 2 L = R(Y) > N OR C: NEXT L:D =  - (R(Y) > N): IF  NOT D AND Y < N THEN R(Y + T) = M:D = D + T
+ 3 S = S +  NOT D:Y = Y + D: NEXT Y: PRINT "THERE " MID$ ("AREIS",4 ^ (S = 1),3)" "S" SOLUTION" MID$ ("S",1,S <  > 1)" FOR "N + T" X "N + T: DATA7,1,-1,-1

Task/N-queens-problem/Ecstasy/n-queens-problem.ecstasy

@@ -0,0 +1,133 @@
+/**
+ * A solver for the classic 8-queens problem.
+ *
+ * @see https://rosettacode.org/wiki/N-queens_problem
+ */
+module eightQueens {
+    void run() {
+        @Inject Console console;
+        Int count = new Board().solve(b -> console.print($"{b}\n"));
+        console.print($"{count} solutions found");
+    }
+
+    /**
+     * `Board` represents a chess board that holds only queens. The board
+     * is organized as columns 0 ("A") to 7 ("H"), and rows 0 (rank "1")
+     * to 7 (rank "8").
+     */
+    const Board {
+        /**
+         * Construct an empty board.
+         */
+        construct() {}
+
+        /**
+         * Internal: Construct a specifically-populated board.
+         */
+        private construct(Int queens, Int claimed) {
+            this.queens  = queens;
+            this.claimed = claimed;
+        }
+
+        /**
+         * Each bit of this 64-bit integer represents a queen.
+         */
+        private Int queens;
+        /**
+         * Each bit of this 64-bit integer represents a queen or a threat.
+         */
+        private Int claimed;
+
+        /**
+         * Translate a column and row to a bit-mask, used with the
+         * [queens] and [claimed] properties. Examples:
+         * * A1 is (0,0) => 0x0000000000000001
+         * * H8 is (7,7) => 0x8000000000000000
+         */
+        private Int mask(Int col, Int row) = 1 << (row << 3) + col;
+
+        /**
+         * Determine if the specified square has a queen in it.
+         */
+        Boolean occupied(Int col, Int row) {
+            return queens & mask(col, row) != 0;
+        }
+
+        /**
+         * Determine if the specified square is safe from the queens.
+         */
+        Boolean safe(Int col, Int row) {
+            return claimed & mask(col, row) == 0;
+        }
+
+        /**
+         * Attempt to place a queen in a specified square.
+         *
+         * @return True iff a queen can be safely placed in the square
+         * @return (conditional) the new Board with the new queen on it
+         */
+        conditional Board placeQueen(Int col, Int row) {
+            assert 0 <= col < 8 && 0 <= row < 8;
+            if (!safe(col, row)) {
+                return False;
+            }
+
+            Int newQueens  = queens | mask(col, row);
+            Int newClaimed = claimed | queens;
+            // claim all threatened spaces
+            for (Int i : 0..7) {
+                newClaimed |= mask(i, row) | mask(col, i);
+                val diagDownRow = row + i - col;
+                if (0 <= diagDownRow < 8) {
+                    newClaimed |= mask(i, diagDownRow);
+                }
+                val diagUpRow = row - i + col;
+                if (0 <= diagUpRow < 8) {
+                    newClaimed |= mask(i, diagUpRow);
+                }
+            }
+            return True, new Board(newQueens, newClaimed);
+        }
+
+        /**
+         * Attempt to find all solutions to the n-queens problem.
+         */
+        Int solve(function void(Board) yield) = solve(yield, 0);
+
+        /**
+         * Internal: Attempt to find all solutions to the n-queens problem,
+         * starting with the specified column and recursively solving by
+         * moving to the next column for each potential solution found in
+         * the specified column.
+         */
+        private Int solve(function void(Board) yield, Int col) {
+            if (col == 8) {
+                // there is no column 8; we've found a solution
+                yield(this);
+                return 1;
+            }
+
+            Int count = 0;
+            for (Int rank : 8..1) {
+                val row = 8-rank;
+                if (Board afterPlacing := placeQueen(col, row)) {
+                    count += afterPlacing.solve(yield, col + 1);
+                }
+            }
+            return count;
+        }
+
+        @Override String toString() {
+            val buf = new StringBuffer();
+            for (Int rank : 8..1) {
+                buf.append($"{rank} |");
+                val row = 8-rank;
+                for (Int col : 0..7) {
+                    buf.add(occupied(col, row) ? 'q' : '_').add('|');
+                }
+                buf.add('\n');
+            }
+            return buf.append("   A B C D E F G H").toString();
+        }
+    }
+}

Task/N-queens-problem/Rust/n-queens-problem-2.rust

@@ -7,7 +7,7 @@ fn main() {
     }
 }
 
-fn permutations<'a, T, I>(collection: I) -> Box<Iterator<Item=LinkedList<T>> + 'a>
+fn permutations<'a, T, I>(collection: I) -> Box<Iterator<dyn Item=LinkedList<T>> + 'a>
     where I: 'a + IntoIterator<Item=T> + Clone,
           T: 'a + PartialEq + Copy + Clone {
     if collection.clone().into_iter().count() == 0 {
@@ -26,7 +26,7 @@ fn permutations<'a, T, I>(collection: I) -> Box<Iterator<Item=LinkedList<T>> + '
 }
 
 pub struct NQueens {
-    iterator: Box<Iterator<Item=NQueensSolution>>
+    iterator: Box<Iterator<dyn Item=NQueensSolution>>
 }
 
 impl NQueens {

Task/N-queens-problem/Rust/n-queens-problem-3.rust

@@ -0,0 +1,29 @@
+extern crate itertools;
+
+use itertools::Itertools;
+
+fn main() {
+    const N: usize = 8;
+
+    let permutations = (0..N).permutations(N);
+
+    let solution_count = permutations
+        .filter(|p| {
+            let mut diag1 = [false; 2 * N - 1];
+            let mut diag2 = [false; 2 * N - 1];
+
+            for (i, &row) in p.iter().enumerate() {
+                if diag1[row + i] || diag2[N - 1 + row - i] {
+                    return false; // Queens mutual threat
+                }
+
+                diag1[row + i] = true;
+                diag2[N - 1 + row - i] = true;
+            }
+
+            true // No Queens mutual threat
+        })
+        .count();
+
+    println!("{}", solution_count);
+}