Capture the Pawns Problem in Java

"Capture the Pawns" is a classic chessboard problem that challenges programmers to develop a solution for finding the minimum number of moves required to capture all pawns on a given chessboard. In this problem, a chessboard of size N x N is considered, and the task is to determine the optimal sequence of moves to capture each pawn while adhering to the rules of chess movement.

Approach:

When it's the white pawn's turn, the game checks if it's located on the 8th row. If so, it signifies a win for Black, since the white pawn cannot make any more moves. Similarly, if the black pawn's turn comes and it's on the 1st row, this results in a victory for White, as the black pawn has no remaining moves.

A check is made for adjacency with the black pawn diagonally during the white pawn's turn. If adjacent, the white pawn captures the black pawn, resulting in a win for the White; otherwise, the white pawn moves forward one step if the destination is unoccupied. A similar process is applied during the black pawn's turn, with adjacency checks and forward movement, potentially leading to a win for the black or a loss if no valid moves are available.

Algorithm:

Step 1: Set the initial positions of the white pawn (rowWhite, colWhite) and the black pawn (rowBlack, colBlack).

Step 2: Initialize counters for the number of moves for white and black (whiteMoves, blackMoves).

Step 3: Set a boolean variable to control the turn-based moves (isWhiteTurn = true).

Step 4: Enter a loop that alternates between white and black moves until a winner is determined.

Step 5: Check if it's the white player's turn (isWhiteTurn is true). Check if the white pawn can move forward (rowWhite != 8).

If yes, check if the white pawn can capture the black pawn (rowBlack == rowWhite + 1 and colBlack is adjacent), then return that white wins.
If not, move the white pawn forward (increment rowWhite). If the white pawn reaches the end of the board (rowWhite == 8), return that white loses.

Step 6: Check if it's the black player's turn (isWhiteTurn is false). Check if the black pawn can move forward (rowBlack != 1).

If yes, check if the black pawn can capture the white pawn (rowBlack == rowWhite + 1 and colBlack is adjacent). If true, return that white loses.
If not, move the black pawn forward (decrement rowBlack). If the black pawn reaches the end of the board (rowBlack == 1), return that white wins.

Step 7: After each complete turn (white and black move), toggle the turn (isWhiteTurn = !isWhiteTurn).

Step 8: After the Loop, check if whiteMoves are greater than blackMoves.

If true, return that white wins.
If false, return that it's a draw or some other outcome.

Implementation:

Filename: ChessGame.java

// Define a new class named ChessGame
public class ChessGame
{ 
    // Function that returns true if white wins 
    static boolean whiteWins(int rowWhite, int colWhite, int rowBlack, int colBlack) 
    { 
        // Initialize variables to keep track of moves for both white and black
        int whiteMoves = 0, blackMoves = 0; 
        // Variable to control the turn-based moves
        boolean isWhiteTurn = true;

        //Loop for alternating moves between white and black
        while (isWhiteTurn)
        { 
            // If White can move
            if (rowWhite != 8) 
            { 
                // If white's pawn can capture Black's pawn, white wins 
                if (rowBlack == rowWhite + 1 && (colBlack == colWhite - 1 || colBlack == colWhite + 1)) 
                    return true; 
                else
                    rowWhite++;  // Move White's pawn forward 
            } 
            else
                return false;  //White has no moves, white loses 

            // If black can move
            if (rowBlack != 1)
            { 
                // If black's pawn can capture White's pawn, white loses 
                if (rowBlack == rowWhite + 1 && (colBlack == colWhite - 1 || colBlack == colWhite + 1)) 
                    return false; 
                else
                    rowBlack--;  // Move black's pawn forward 
            } 
            else
                return true;  //Black has no moves, white wins 
        } 

        // If White has more moves 
        if (whiteMoves > blackMoves) 
            return true; 

        return false; 
    } 

    // Driver code 
    public static void main(String args[])
    { 
        // Set initial positions for white and black
        int rowWhite = 2, colWhite = 2, rowBlack = 3, colBlack = 3; 
        // Check if white wins and print the result
        if (whiteWins(rowWhite, colWhite, rowBlack, colBlack)) 
            System.out.println("White wins by capturing Black's pawn!"); 
        else
            System.out.println("Black wins by avoiding capture or reaching the end of the board!"); 
    } 
}

Output: