代做program、代写Java/Python程序设计

日期：2024-04-08 07:50

AI Algorithm for Reversed Reversi

March 14, 2024

Abstract

Reversed Reversi is a relatively simple board game. Players take turns placing chess

pieces on the board with their assigned color facing up. During a play, any pieces of the

opponent’s color that are in a straight line and bounded by the piece just placed and

another piece of the current player’s color are turned over to the current player’s color.

The object of the game is to have the fewest pieces turned to display your color when

the last playable empty square is filled. In this assignment, we use the default board of

size 8*8 board (administrators can modify the settings as needed). Students need to

implement the AI algorithm of Reversed Reversi according to the interface requirements

and submit it to the platform as required for the usability tests and round-robin.

1 Schedule

The Project is divided into two phases, each with one or two weeks for coding and improving

your current coding.

Evaluation Rule DeadLine

Phase 1 Score according to the number of test cases passed. 2024/03/29

Phase 2 Score according to the rank in round-robin. 2024/04/12

Coding_Score = Phase1+Phase2 (Parse1:Parse2=1:2)

2 How to Use The Platform

The Reversed Reversi platform is logged in with your student ID and password. The default

password is your student ID. At the first login, the platform will ask you to change your

password. After logging in successfully, you can see the page below.

Now, you can submit your own AI algorithm to the Reversed Reversi battle platform.

The platform will first do the usability tests after submission. The submission is successful

only if your AI algorithm passes the usability tests. After submitting your AI algorithm

successfully, you can click on “Auto Play” to challenge the players who rank ahead of you for

a PK. In order to avoid the first-hand advantage, the PK is played for 2 rounds with each

1

Figure 1: Home page

other starting the game first. In each round, if one of your wins, then his (or her) score is

increased by 5 points. If one of you loses, then his (or her) score is reduced by 5 points. If

a draw occurs, both of your scores remain unchanged.

The whole battle process will be recorded for each match. You can play back the game

you just experienced by playing and backing buttons, or you can download the game data as

a text file so that you can debug or review their code and algorithms. On the right side, you

can see the leader-boards, showing only the top ten and their points, as well as your ranking

and points. Click on “play” to see the live broadcast for the battle of the top-ten players.

If you want to evaluate your newly uploaded algorithm, please use the function of “playto”.

Just input the opponent’s Student ID you want to challenge and click “playto”, then you can

play a pre-PK with this opponent. This pre-PK will not affect your rankings.

Your ranking on the platform does not affect your final score. The platform

is just a tool to help you improve your algorithm.

After the Phase 2 DDL, the round-robin is started. Every students will play a PK with

each other students. The score is accumulated, and each student’s ranking is given according

to the final points.

3 Code Requirements

1. Version Details

2

(a) Python version: 3.7.6

(b) Numpy: 1.21.0

(c) Numba: 0.56.4

2. Code template:

1 import numpy as np

2 import random

3 import time

4

5 COLOR_BLACK=?1

6 COLOR_WHITE=1

7 COLOR_NONE=0

8 random.seed(0)

9 #don’t change the class name

10 class AI(object):

11 #chessboard_size, color, time_out passed from agent

12 def __init__(self, chessboard_size, color , time_out):

13 self .chessboard_size = chessboard_size

14 # You are white or black

15 self . color = color

16 # the max time you should use, your algorithm’s run

17 # time must not exceed the time limit.

18 self .time_out = time_out

19 # You need to add your decision to your candidate_list.

20 # The system will get the end of your candidate_list as your decision.

21 self . candidate_list = []

22

23 # The input is the current chessboard. Chessboard is a numpy array.

24 def go( self , chessboard ):

25 # Clear candidate_list, must do this step

26 self . candidate_list . clear ()

27 #============================================

28 #Write your algorithm here

29 #Here is the simplest sample:Random decision

30 idx = np.where(chessboard == COLOR_NONE)

31 idx = list (zip(idx [0], idx [1]))

32 #==============Find new pos==================

33 # Make sure that the position of your decision on the chess board is empty.

34 # If not, the system will return error.

35 # Add your decision into candidate_list, Records the chessboard

36 # You need to add all the positions which are valid

37 # candidate_list example: [(3,3),(4,4)]

38 # You need append your decision at the end of the candidate_list,

39 # candidate_list example: [(3,3),(4,4),(4,4)]

3

40 # we will pick the last element of the candidate_list

41 # as the position you choose.

42 # In above example, we will pick (4,4) as your decision.

43 # If there is no valid position , you must return an empty list.

3. Time measurement

1 start = time.time()

2 # Your algorithm

3 run_time = (time.time() ? start)

4. Note: import os is not allowed to use.

5. The usage of memory cannot go more than 100M, the time to find a place to drop

cannot be longer than 5s, the whole battle cannot be longer than 180s.

4 Requirements for Each Phase

4.1 Phase 1

Usability tests: In this tests, we will use some simple board test cases where students need

to find the best place to drop. Only jobs that pass the usability test can pass. This is to

prevent students from submitting code including illegal operations, infinite loop or random

drop. The usability tests includes: the os package cannot be imported in the code file to

prevent the student code from affecting the platform.

A total of 10 test cases were prepared, each with 10 points, and the scores were determined

by the number of test cases passed.

4.2 Phase 2

Students who pass the usability tests can use the platform to improve the algorithm. The

specific competition rules of the platform are as follows: Students can submit their AI

algorithm to the Reversed Reversi battle platform (it is a successful submission if it passes

the usability tests). After a successful submission, you can click on “Auto Play” to challenge

the player who ranks ahead of you for a PK. In order to avoid the first-hand advantage, the

PK is played for 2 rounds with each one starting the game first. In each round, if one of

your wins, then his (or her) score is increased by 5 points. If one of you loses, then his (or

her) score is reduced by 5 points. If a draw occurs, both of your scores remain unchanged.

Students can submit and update their AI algorithm to the Reversed Reversi battle platform before Phase 2 DDL. After the Phase 2 DDL, the round-robin is started. Every student

will play a PK with each other. The score is accumulated and the ranking for each student

is given according to the final points.

4