问Javascript:两个皇后的对角线验证以及它们是否可以互相攻击

EN

// What is the total number of positions that two queens can exist on a chess board where they cannot attack each other?
function answer() {

    var Q1;
    var Q2;
    var cnt = 0; // count of when they can attack each other
    
    for (Q1 = 0; Q1 < 64; Q1++) {
        //console.log(Q1);
        
        
        let Q1_y = Math.floor(Q1 / 8); // 0..7 ~ 0, 8..15 ~ 1, and so on
        let Q1_x = Q1 % 8;
        
        // console.log(Q1_x + ", " + Q1_y);
        
        for (Q2 = 0; Q2 < 64; Q2++) {
            
            let Q2_y = Math.floor(Q2 / 8); // 0..7 ~ 0, 8..15 ~ 1, and so on
            let Q2_x = Q2 % 8;
            
            if (Q1 != Q2) {
                // rule out both on same square
            
                let canAttack = false;
                // Now determine if on same X
                if (Q1_x == Q2_x) {
                    canAttack = true;
                }
                
                // Now determine if on same Y
                if (Q1_y == Q2_y) {
                    canAttack = true;
                }
                
                // Now determine if on same diagnoal
                let diag = (Math.abs(Q1_x - Q2_x) / Math.abs(Q1_y - Q2_y)) == 1;
                
                if (diag) {
                    canAttack = true;
                }
                
                // Update count for this square combo
                
                if (canAttack) {
                    cnt++;
                }
                
            }
            
        }
    }
    
    // console.log (cnt);
    
    return ((64 * 64) - 64) - cnt; // 64*64 total space pairs, minus the 64 times they are on same square, minus the number of times they *can* attack
    
    
    
}

console.log (answer());

// Establish array with each bitboard representing the square on the board
// that the bitboard index represents.
let squares = new BigUint64Array( 64 ).map( ( v , i ) => 1n << BigInt( i ) );

// Generate possible moves for Rooks and Bishops for each square
// that they can occupy.
let rookMoves = new BigUint64Array( 64 );
let bishopMoves = new BigUint64Array( 64 );

for ( pieceRank = 0; pieceRank < 8; pieceRank++ ) {
  for ( pieceFile = 0; pieceFile < 8; pieceFile++ ) {
    let squareIndex = pieceRank * 8 + pieceFile;
    let rookMap = 0n;
    let bishopMap = 0n;
    for ( let r = 0; r < 8; r++ ) {
      for ( let f = 0; f < 8; f++ ) {
        let rf = r * 8 + f;
        if ( ( r === pieceRank || f === pieceFile ) && rf !== squareIndex ) {
          rookMap |= squares[ rf ];
        }
        if ( ( Math.abs( r - pieceRank ) === Math.abs( f - pieceFile ) ) && rf !== squareIndex ) {
          bishopMap |= squares[ rf ];
        }
      }
    }
    rookMoves[ squareIndex ] = rookMap;
    bishopMoves[ squareIndex ] = bishopMap;
  }
}  
 
// Generate the possible moves for Queens for each square that
// they can occupy.  This is done my looping through the Rook
// moves and simply ORing with the bishop moves.
let queenMoves = rookMoves.map( ( v, i ) => v | bishopMoves[ i ] );

// Helper function to print out the bitmap as a board, where 'X' 
// represents a bit that is set to 1 and '-' a bit that is set to '0'.
function printBitMap( bitBoard ) {
  let bm = '';
  for ( rank = 7; 0 <= rank; rank-- ) {
    for ( file = 0; file < 8; file++ ) {
      bm += bitBoard & squares[ rank * 8 + file ] ? ' X ' : ' - ';
    }
    bm += '\n';
  }
  return bm + '\n';
}

// Let's print the bitmaps for the rook, bishop, and queen at square d3,
// which is rank 2 ( range 0 - 7 ) file 3, or 2 * 8 + 3 which is square
// index 19.
console.log( 'Rook, Bishop, and Queen moves from square d3:' );
console.log( printBitMap( rookMoves[ 19 ] ) );
console.log( printBitMap( bishopMoves[ 19 ] ) );
console.log( printBitMap( queenMoves[ 19 ] ) );

// Now that the bitmaps are set up, the effort is simple... Loop through
// all combinations of two queens on the board...
let nonIntersectCount = 0;
for ( let Q1square = 0; Q1square < 64; Q1square++ ) {
  for ( let Q2square = 0; Q2square < 64; Q2square++ ) {
    // ...and if the queens are not on the same square and the intersection of
    // the possible moves for Q1 with the Q2 square is 0 bits, then we have
    // a situation where the queens are not attacking each other... 
    if ( Q1square !== Q2square && ( queenMoves[ Q1square ] & squares[ Q2square ] ) === 0n ) {
      nonIntersectCount++;
    }
  }
}

console.log( 'For every combination of 2 queens on a board, the number of combinations where they do not attack each other is:' );
console.log( nonIntersectCount );