# CSCI1540代做、代写C++设计编程

- 首页 >> Algorithm 算法
CSCI1540 Fundamental Computing Using C++, Fall 2023/24
Department of Computer Science and Engineering, The Chinese University of Hong Kong
Assignment 6: Rush Hour
Due: 23:59, Sat 9 Dec 2023 File names: RushHour.cpp
playgame.cpp
Full marks: 100
Introduction
The objective of this assignment is to practice object-oriented programming. You will write a class
and a client program to play a sliding block puzzle game called Rush Houra
.
The game is played on a grid of size 8 × 8 with at most 10 cars on it. The cars are aligned either
vertically or horizontally in the grid and occupy two or three tiles. There is an exit hole on the right
side of the grid. The goal of the puzzle is to move the cars forward or backward (but not change
direction) so that a designated car (called Car 0) moves to the exit hole. Figure 1(a) shows an
example puzzle configuration, in which Cars 0, 1, 6, and 7 are horizontal and can move left or right,
and Cars 2, 3, 4, and 5 are vertical and can move up or down. Moving Car 1 to the right by one tile
yields the state in Figure 1(b). Continuing to move the cars carefully, you can yield the solved state as
in Figure 1(c) where Car 0 reaches the exit hole on the right.
########
#11...2#
#3..4.2#
#3004.2.
#3..4..#
#5...66#
#5.777.#
########

########
#.11..2#
#3..4.2#
#3004.2.
#3..4..#
#5...66#
#5.777.#
########
→ … →
########
#311...#
#3.....#
#3....00
#5..4.2#
#5664.2#
#7774.2#
########
(a) Initial (b) Move Car 1 (c) Solved
Figure 1: An Example Rush Hour Configuration and its Solved State
Program Specification
You shall write your program in two source files RushHour.cpp and playgame.cpp. The former is
the implementation of the class RushHour, while the latter is a client program of class RushHour
which performs the program flow. You are recommended to finish the RushHour class first before
writing the client program. When you write the RushHour class, implement the member functions
and test them individually one by one. Your two files will be graded separately, so you should not mix
the functionalities of the two files.
Class RushHour (RushHour.cpp)
You are given the interface of the RushHour class in the header file RushHour.h. You shall not
modify the contents of this header file. Descriptions of the class are given below.
a You may play Rush Hour online at: https://www.mahjongfun.com/rush-hour/
CSCI1540 Fundamental Computing Using C++, Fall 2023/24
Department of Computer Science and Engineering, The Chinese University of Hong Kong
class RushHour {
public:
RushHour(const string g[]);
bool locateCar(int car, int &row, int &col);
int moveCar(int car, int step);
bool isSolved();
int getTotalSteps();
void print();
private:
string grid[8];
int totalSteps;
};
Private Data Members
string grid[8];
The Rush Hour puzzle is represented by an array of string. Each element grid[𝑖] stores the
contents in row 𝑖 of the grid. E.g., for the configuration in Figure 1(a), grid[0] is “########”,
grid[1] is “#11...2#”, grid[2] is “#3..4.2#”, etc. All characters in the strings are either ‘#’
(border), ‘.’ (empty), or digits ‘0’–‘9’ (cars). All the strings are of length 8.
int totalSteps;
The total number of steps that a player has moved during puzzle play. Note that moving a car by, say,
two tiles, is counted as two steps.
Public Constructor and Member Functions
RushHour(const string g[]);
This constructor initializes the Rush Hour puzzle using the array parameter g, which contains
contents for row 1 to row 6 of the grid. (That is, g[0] is used to initialize grid[1]; g[1] is used to
initialize grid[2]; …; g[5] is used to initialize grid[6].) Note that row 0 and row 7 are not
needed in the parameter because the two rows always contain only the ‘#’ symbol. You just have to
initialize grid[0] and grid[7] as “########”. E.g., suppose g is {"#11...2#", "#3..4.2#",
"#3004.2.", "#3..4..#", "#5...66#", "#5.777.#"}. Then grid shall be initialized such
that grid[0]…grid[7] become “########”, “#11...2#”, “#3..4.2#”, “#3004.2.”,
“#3..4..#”, “#5...66#”, “#5.777.#”, and “########” respectively (that is, the configuration in
Figure 1(a)).
You can assume that:
➢ Array parameter g is always of size 6;
➢ Each string g[0], …, g[5] is always of length 8, and always contains eight symbols of either ‘#’
(border), ‘.’ (empty), or digits ‘0’–‘9’ (cars);
➢ The strings g[0], …, g[5] always start and end with the border ‘#’. An exception is on g[2] (for
grid[3]), where its last character is always the exit hole (‘.’).
➢ The cars always occupy either two or three tiles, and are always properly aligned vertically or
horizontally.
CSCI1540 Fundamental Computing Using C++, Fall 2023/24
Department of Computer Science and Engineering, The Chinese University of Hong Kong
You do not have to handle situations where the parameter g does not conform to these assumptions.
Remember to also initialize the data member totalSteps as 0.
bool locateCar(int car, int &row, int &col);
Finds the position of the parameter car in the puzzle. The position of a vertical car is its topmost tile.
The position of a horizontal car is its leftmost tile. The row and column indices of the found position
are assigned to the reference parameters row and col respectively, and the member function shall
return true. E.g., locating Car 2 in Figure 1(a) shall write 1 to row and 6 to col and return true,
because Car 2 appears at row 1, column 6. In case car cannot be located in the grid (e.g., there is no
Car 8 in Figure 1(a)), the member function shall not update row and col and return false.
int moveCar(int car, int step);
Performs the action of moving the parameter car by step tiles. A positive value for step means
moving down (for vertical car) or right (for horizontal car); a negative value means moving up (for
vertical car) or left (for horizontal car). E.g., in Figure 1(a), moving Car 6 left by three tiles has a step
of -3. A move is valid only if all the followings are satisfied:
➢ The parameter car exists in the grid.
➢ The parameter step is non-zero. (Moving a car by 0 tile is meaningless.)
➢ There is enough space to allow the car to move by step tiles, without hitting other cars or the
border, or going beyond the exit hole. (E.g., in Figure 1(a), Car 6 cannot move left by four tiles (-4
steps), as it would hit Car 5.)
If the move is valid, then data members grid and totalSteps shall be updated accordingly.
Otherwise, no updates to grid and totalSteps are needed. This member function shall return
either 0, 1, or 2, according to the following conditions:
Condition Return value
Move is valid 0
car does not exist in the grid or step is zero 1
Hit other cars or border or go beyond the exit hole 2
Implementation hint: First, find the position of car (with the help of locateCar()). Then
determine which one of the four cases the prospective move is: move left/right/up/down. Implement
the four cases one by one. For each case, check whether the move is valid or not. If valid, update the
car to the new position (by updating the grid contents).
bool isSolved();
Returns true if Car 0 touches the exit hole; returns false otherwise.
int getTotalSteps();
Returns the total number of steps that a player has moved the cars. That is, the value of the data
member totalSteps.
void print();
Prints out the Rush Hour puzzle and the number of steps that the player has used. The following is
an example output of print().
CSCI1540 Fundamental Computing Using C++, Fall 2023/24
Department of Computer Science and Engineering, The Chinese University of Hong Kong
########
#311..2#
#3....2#
#300..2.
#5..4..#
#5664..#
#7774..#
########
Steps: 10
Client Program (playgame.cpp)
Your main program is a client of the RushHour class. You create a RushHour object here and call its
member functions to implement the following program flow.
1. The program starts with prompting the user to enter six strings (separated by spaces), which are
the initial grid contents for row 1 to row 6 of the puzzle. Then create a RushHour object using
the user input. You can assume that the six strings follow the same assumptions stated in the
constructor above).
2. Prompt the user to move a car. You can assume that the user always enters two integers,
denoting the car and the steps of the prospective move respectively. (Positive step means
moving down/right; negative step means moving up/left.)
3. In case the input is not a valid move (see definition in the moveCar() member function above),
the program prints a warning message and goes back to Step 2. Otherwise, move the car
accordingly.
Note: there are two kinds of warning messages. When the car does not exist or the step is zero,
the message “Invalid car or step! Try again.” shall be printed. When the move would hit other
cars or border or go beyond the exit hole, the message “Hit! Try again.” shall be printed.
4. If the puzzle is not yet solved after the move and the total number of steps is smaller than 100,
go back to Step 2.
5. Finally, print the puzzle and either the winning message “Congrats! You finished in 𝑋 steps.”
(where 𝑋 is the number of steps used) or the losing message “Oops! You could not solve in 100
steps.”
Some Points to Note
➢ You cannot declare any global variables in all your source files (except const ones).
➢ Remember to #include "RushHour.h" in both RushHour.cpp and playgame.cpp.
➢ You can write extra functions in any source files if necessary. However, extra member functions
(instance methods), no matter private or public, are not allowed.
➢ Your RushHour class shall not contain any cin statements. All user inputs shall be done in the
client program (playgame.cpp) only.
➢ The RushHour class shall not contain any cout statements except in the print() member
function for printing the puzzle.
CSCI1540 Fundamental Computing Using C++, Fall 2023/24
Department of Computer Science and Engineering, The Chinese University of Hong Kong
Sample Run
In the following sample run, the blue text is user input and the other text is the program output. You
can try the provided sample program for other input. Your program output should be exactly the
same as the sample program (same text, symbols, letter case, spacings, etc.). Note that there is a
space after the ‘:’ in the program printout. More sample runs and initial grids are available in
Blackboard.
Enter initial grid: #11...2# #3..4.2# #3004.2. #3..4..# #5...66# #5.777.#
########
#11...2#
#3..4.2#
#3004.2.
#3..4..#
#5...66#
#5.777.#
########
Steps: 0
Move a car: 1 4
Hit! Try again.
Move a car: 1 1
########
#.11..2#
#3..4.2#
#3004.2.
#3..4..#
#5...66#
#5.777.#
########
Steps: 1
Move a car: 3 0
Invalid car or step! Try again.
Move a car: 3 -2
Hit! Try again.
Move a car: 8 1
Invalid car or step! Try again.
Move a car: 3 -1
########
#311..2#
#3..4.2#
#3004.2.
#...4..#
#5...66#
#5.777.#
########
Steps: 2
Move a car: 5 -1
CSCI1540 Fundamental Computing Using C++, Fall 2023/24
Department of Computer Science and Engineering, The Chinese University of Hong Kong
########
#311..2#
#3..4.2#
#3004.2.
#5..4..#
#5...66#
#..777.#
########
Steps: 3
Move a car: 7 -2
########
#311..2#
#3..4.2#
#3004.2.
#5..4..#
#5...66#
#777...#
########
Steps: 5
Move a car: 6 -3
########
#311..2#
#3..4.2#
#3004.2.
#5..4..#
#566...#
#777...#
########
Steps: 8
Move a car: 4 2
########
#311..2#
#3....2#
#300..2.
#5..4..#
#5664..#
#7774..#
########
Steps: 10
Move a car: 2 3
########
#311...#
#3.....#
#300....
#5..4.2#
#5664.2#
#7774.2#
########
Steps: 13
Move a car: 0 5
Hit! Try again.
Move a car: 0 4
CSCI1540 Fundamental Computing Using C++, Fall 2023/24
Department of Computer Science and Engineering, The Chinese University of Hong Kong
########
#311...#
#3.....#
#3....00
#5..4.2#
#5664.2#
#7774.2#
########
Steps: 17
Congrats! You finished in 17 steps.
Submission and Marking
➢ Your program file names should be RushHour.cpp and playgame.cpp. Submit the two files in
Blackboard (https://blackboard.cuhk.edu.hk/). You do not have to submit RushHour.h.
➢ Insert your name, student ID, and e-mail as comments at the beginning of all your files.
➢ Besides the above information, your program should include suitable comments as