代写program编程、代做Java/C++程序

日期：2025-03-22 03:42

JUMPY3

The Game of Jumpy3

Jumpy3 is a board game between two players: White and Black. The board has 16 horizontal squares in a

single row. Each player has four pieces, consisting of 3 pawns and a king. The game starts with the white

king on the leftmost square, followed by the three white pawns. Black’s pieces are positioned in the same

way on the right, as shown below (the kings are in capital letters):

W w w w b b b B

The game starts with a move of white, followed by a move of black, followed by a move of white, etc., until

one of the players wins. The winner is the first player that manages to remove its king out of the board. A

move of white (black) is a change in the location of ONE white (black) piece by advancing it one step to the

right (left). If the target square is occupied white (black) jumps to the nearest free square. If white (black)

jumps over a single black (white) piece, that piece is moved to the 16th (1st) square, or to the rightmost

(leftmost) free square. Observe that a king and a pawn move exactly the same. The difference between them

is only in determining the winner. Here are a few examples:

If it is Black’s move and the current position is:

W w w b w b b B

the position after Black’s move is one of the following:

W w w b w b B b

W w w b w b b B

W w w w b b b B

W b w w w b b B

If it is White’s move and the current position is:

B w b w b W

the position after White’s move is one of the following:

B w b w b

B w b w b W

B b w w b W

1

A computer program that plays Jumpy3

The basic components of a computer program that plays Jumpy3 are a procedure that generates moves,

a procedure that gives a static estimation value for a given position, and a MINMAX or ALPHA-BETA

procedure.

One way of representing a position is by an array P of length 16, containing the pieces as the letters

W, w, B, b, x. (The letter x stands for a “non-piece”.)

Given a position specified by the array P, here is one approach for a procedure that computes the positions

generated by White moves.

Scan the array P for White pieces (the letters w or W). For each White piece found, let i be its

index in the array. The value of i satisfies: 0 ≤ i ≤ 15.

• if i == 15, set P[i] = x and return P. (Move out of board.)

• else if P[i + 1] == x, set P[i + 1] = P[i], P[i] = x, and return P. (Move one forward.)

• else (jump) compute j, the index of the first empty square to the right of i.

– if such j does not exist set P[i] = x and return P. (Jump out of board.)

– else set P[j] = P[i], P[i] = x and check if the jump is over one black piece.

∗ if(j − i > 2) (Jump over several) return P.

∗ else (here j==i+2, jump over one piece)

· if(P[i + 1] == w or W) (jump over one white piece) return P.

· else (here the jump is over one black piece)

compute k, the index of the rightmost empty square.

set P[k] = P[i + 1], P[i + 1] = x.

return P.

Programming notes:

! The above procedure should be applied to a copy of P. Make sure you do not destroy the

original P.

! The easiest way to compute the moves for black is to implement a procedure called flip that

would flip the position, replacing white/black pieces with black/white pieces and reversing

the array order. Then, to compute the moves for black it is enough to flip the position,

compute the white moves, and flip each one of the newly generated positions.

The following functions can be used to check if a position is a win for White or a win for Black:

WhiteWin(P): if(P does not contain a value W) return white win.

BlackWin(P): if(P does not contain a value B) return black win.

Using these functions a simple static estimate of a position can be:

EstimatePosition(P):

if WhiteWin(P) return(100)

else if BlackWin(P) return(-100)

else let i be the array index of W, and let j be the array index of B. return(i + j − 15)

2