Programming Fundamentals代做、Java设计代写、代做Java编程语言

日期：2019-05-24 11:19

Programming Fundamentals (48023) Autumn 2019 Assignment Page 6

128 Of the 12 students who scored between 51 and 64 (i.e. a Pass) in Programming

129 Fundamentals, 33% failed Applications Programming.

130 Of the 20 students who scored 65 (i.e. the minimum mark for a Credit) in

131 Programming Fundamentals, 35% failed Applications Programming.

132 Of the 22 students who scored between 66 and 74 (i.e. a Credit) in Programming

133 Fundamentals, 27% failed Applications Programming.

134 Of the 24 students who scored between 75 and 84 (i.e. a Distinction) in Programming

135 Fundamentals, 8% failed Applications Programming.

136 Of the 34 students who scored between 85 and 100 (i.e. a High Distinction) in

137 Programming Fundamentals, 12% failed Applications Programming.

138

139 Solution requirements

140 To receive any marks, your solution must meet the following minimum requirements:

141 The tasks must be implemented in the order specified in section “Tasks” below.

142 As a general rule, your solution must use only the features of Java that are taught in this

143 subject. For example, students must not use inheritance, exceptions, varargs (e.g.

144 printf), interfaces, or generics. Also, students must not use arrays (or equivalent, such

145 as collections) in Parts A and B, even though arrays are taught in this subject.

146 Your program's output must exactly match the output given by PLATE. White space

147 (i.e. spaces, tabs and new lines) is significant in PLATE.

148 You must define methods with the exact names and parameters as specified below (i.e.

149 you must define methods with the given “signatures”), however you are permitted to

150 define any number of additional methods of your own. Unless otherwise stated, you

151 must not add additional fields to classes.

152 Overview of Parts A and B

153 In this assignment you will create a simple Pacman-like game with one player, 3 dots, an exit

154 and an enemy. The player can move left, right, up or down and must collect all 3 dots and

155 reach the exit without being killed by the enemy. The enemy is programmed to chase down the

156 player. The game finishes when either:

157 (1) all the dots have been collected or the exit has been reached, or

158 (2) when the enemy has killed the player.

159 Sample output is shown below. Your program should produce input/output in exactly the

160 following format, with user’s input shown underlined and in bold:

Programming Fundamentals (48023) Autumn 2019 Assignment Page 7

161

Initial x: 5

Initial y: 0

Player[](5,0) Dot(1,1) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(5,5)

Move (l/r/u/d): l

Player[](4,0) Dot(1,1) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(5,4)

Move (l/r/u/d): l

Player[](3,0) Dot(1,1) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(5,3)

Move (l/r/u/d): l

Player[](2,0) Dot(1,1) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(5,2)

Move (l/r/u/d): l

Player[](1,0) Dot(1,1) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(5,1)

Move (l/r/u/d): d

Player[*](1,1) Dot(-,-) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(4,1)

Move (l/r/u/d): r

Player[*](2,1) Dot(-,-) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(3,1)

Move (l/r/u/d): d

Player[**](2,2) Dot(-,-) Dot(-,-) Dot(3,3) Exit(4,4) Enemy(2,1)

Move (l/r/u/d): r

Player[**](3,2) Dot(-,-) Dot(-,-) Dot(3,3) Exit(4,4) Enemy(2,1)

Move (l/r/u/d): d

Player[***](3,3) Dot(-,-) Dot(-,-) Dot(-,-) Exit(4,4) Enemy(2,2)

Move (l/r/u/d): r

Player[***](4,3) Dot(-,-) Dot(-,-) Dot(-,-) Exit(4,4) Enemy(2,3)

Move (l/r/u/d): d

Player[***](4,4) Dot(-,-) Dot(-,-) Dot(-,-) Exit(-,-) Enemy(2,4)

You win!

162

163 Explanation of the above sample output

164 The program begins by asking the user to input the initial position for the player. The x

165 coordinate increases from left to right and the y-coordinate increases from top to bottom.

166 The position of each Player, each Dot, the Exit and the Enemy are shown in the format (x,y).

167 Once a dot has been collected, or the exit has been successfully reached or the player has been

168 killed, its position is instead shown as (-,-) with coordinates replaced by the - symbol. The user

169 plays the game by entering move commands (l/r/u/d) indicating move left, right up or down,

170 until the game is over.

171 In Part A, you will build only a fragment of this game. In Part B, you will complete all

172 functionality.

173

Programming Fundamentals (48023) Autumn 2019 Assignment Page 8

174 Part A

175 Due date: 11:59pm on Sunday June 9, 2019 (i.e. 9/6/2019, 11:59pm).

176 Value: 10%

177 Topics: Data flow, OO programming basics, Control flow.

178 Objectives: This assignment supports objectives 1-4.

179 Students who expect to follow this subject by doing Applications Programming (48024) are

180 STRONGLY ENCOURAGED to do Part A of the assignment to prepare for Applications

181 Programming.

182 NOTE: Unlike the lab tests, there is no “skeleton” file for the assignment. To start the

183 assignment, select “New project” off the “Project” menu, as shown below:

184

185 After creating the project, to create each new class, select “New Class” as shown below:

186

187 Do NOT save your JAR file to your BlueJ Project Folder

188 Do NOT save your JAR file into the same folder as your BlueJ files for the

189 assignment. When you do that, each time you make a new JAR file, the new JAR contains the

190 old JAR, and eventually you end up with a REALLY REALLY BIG JAR file. The JAR file

191 for benchmark solution used in PLATE is only 5KB. Your JAR file should not be much bigger

192 than that.

193

194 If you have already been saving the assignment JAR file into the same folder as the BlueJ files,

195 then you'll need to:

Programming Fundamentals (48023) Autumn 2019 Assignment Page 9

196 (a) create a new BlueJ project folder,

197 (b) copy-and-paste your code from the old folder into the new folder, and then

198 (c) in future, don't save the jar file into this same new folder as the BlueJ files.

199

200

201

202 In this part, you will create the various classes that comprise the game. After completing part

203 A, your project in BlueJ will look something like this:

204

205 The actual position of your class icons will probably vary from what is shown above.

206 Tasks

207 These tasks must be completed in the order listed below.

208 Task 1: Classes and fields

209 In a new BlueJ project write code to produce the following three classes (written in italics) and

210 their “fields” / “private data members” / “variables” (enclosed in double quotes):

211 A Game has 1 instance of the Player class, called “player”, and 3 instances of the Dot

212 class (called “dot1”, “dot2” and “dot3”). (An instance of a class is an object.)

213 A Player has an “x” and “y” value (both integers) which together describe the position

214 of the player. The coordinate system of the x and y position is as follows: the x-

215 coordinate increases from left to right, and the y-coordinate increases from top to

Programming Fundamentals (48023) Autumn 2019 Assignment Page 10

216 bottom. The player also keeps a counter (an integer) of the number of dots collected

217 (called “collectedDots”).

218 A Dot has an “x” and “y” position with the same coordinate system as the player, and

219 also has a boolean status (i.e. a variable which has either the value true or the value

220 false; look it up) called “exists” which is initially true and is set to false whenever the

221 dot has been collected by the player.

222 You should also add a fourth class, called Util, which for Part A is given to you and is as

223 follows:

224 public class Util {

225 public static String coordStr(int x, boolean shown) {

226 return shown (""+x) : "-";

227 }

228

229 public static String objectStr(int x, int y, boolean shown) {

230 return "(" + coordStr(x, shown) + "," + coordStr(y, shown) + ")";

231 }

232 }

233

234

235

236 The operator in the Util method called “coordStr” has not been discussed in lectures.

237 You don’t need to understand the “?” operator to use Util, but if you are curious you can, for

238 example google the words … java tutorial question mark operator.

239 The names of your classes and fields should exactly match those in the above system

240 description, and must follow Java’s naming conventions (i.e. class names begin with an

241 uppercase letter, field names begin with a lowercase letter, compound nouns (google it) are

242 joined without a space and the second word begins with an uppercase letter).

243 All classes must be public and all fields must be private.

244 Submit your project to PLATE now to receive your marks and feedback. You can resubmit

245 unlimited times before the due date. Use the feedback from plate to improve your code and

246 then resubmit to improve your mark.

247

248

Note: Don’t copy and paste the above code from this PDF document. Instead, copy it

from the file “ClassUtilCode.txt” which was attached to the same email that distributed

this PDF document. If you have deleted that email without keeping “ClassUtilCode.txt”,

it can be found in UTSonline, , under the "Assessment" menu item on the left hand side of

UTSonline..

Programming Fundamentals (48023) Autumn 2019 Assignment Page 11

249 Task 2: Constructors

250 In this task, you will add constructors to each class to initialise the program.

251 2.1 Dot

252 Define a constructor for class Dot that takes the initial x and y values as parameters, and copies

253 these initial values into the x and y fields. The Dot constructor should also initialise the

254 “exists” field to true.

255 2.2 Player

256 Define a constructor for class Player that takes the initial x and y values as parameters, and

257 copies these initial values into the x and y fields. The collectedDots fields should also be

258 initialised to 0.

259 Submit your code to PLATE to receive marks for this part and do the same for each subsequent

260 part below. You are required to submit your progress to plate while you are making progress.

261 2.3 Game

262 Define a constructor for class Game that takes the initial x and y positions of the player as

263 parameters and creates and initialises the player, dot1, dot2 and dot3 fields. Hint: creating and

264 initialising player, dot1, dot2 and dot3 is analogous to creating and initialising:

265 “scanner” in the lab test class “ThreeNumbers”

266 “summer1” or “summer2” in the main method of the lab test class “SummerOO”

267 The player should be created at the position given by the parameters. dot1, dot2 and dot3 must

268 be created at positions (1,1), (2,2) and (3,3) respectively.

269 Preamble to Task 3 and Task 4

270 Tasks 3 and 4 can mostly be completed in any order. It is recommended that you do the easy

271 parts first and leave any hard parts (labelled “advanced”) until after you have completed the

272 easy parts.

273

Programming Fundamentals (48023) Autumn 2019 Assignment Page 12

274 Task 3: move() method

275 Add the following method “move” to the class Game:

276 public void move(int dx, int dy) {

277 player.move(dx, dy);

278 }

279 Then add a “move()” method to the Player class that moves a player by the given relative

280 distance (dx,dy). That is, if the player is currently at position (x,y), the player should be moved

281 to position (x+dx, y+dy). For example, if the player is currently at position (3,4) and the move

282 method is used with parameters dx=2 and dy=3, then the player should move to position (5,7).

283 Advanced: (You can try this after completing Task 4)

284 Add the following lines of code to the move() method in class Game:

285 player.collect(dot1);

286 player.collect(dot2);

287 player.collect(dot3);

288 Then add a “collect()” method to the Player class to collect the dot specified as the parameter if

289 that is possible. The player can collect a dot only if the player is at the same position as the dot.

290 When the player collects a dot, the player’s “collectedDots” count should be increased by 1.

291 When the player collects a dot, the dot should disappear. To implement that, as part of the

292 “collect()” method in the class Player, there should be a call to a “disappear()” method in the

293 class Dot. That method in Dot should contain a single line of code in the body:

294 exists = false;

295 Task 4: toString()

296 Add “toString()” methods to each of the classes Game, Player and Dot containing the

297 following code in the body of the method:

298

299 Class Game:

300 o return player + " " + dot1 + " " + dot2 + " " + dot3;

301

302 Class Player:

303 o return "Player[" + collectedDots + "]" + Util.objectStr(x, y, true);

304

305 Class Dot:

306 o return "Dot" + Util.objectStr(x, y, exists);

Programming Fundamentals (48023) Autumn 2019 Assignment Page 13

307

308 (Do not vary from the lines of code specified above; a returned string must exactly match the

309 above format in order to receive the marks from PLATE.)

310 Thus a call to the toString() method of class Game returns (but does not print) a string of the

311 form:

312

313 Player[0](0,0) Dot(1,1) Dot(2,2) Dot(3,3)

314 The above string indicates the positions of the player and 3 dots, as well as the number of dots

315 collected by the player. Here, [0] indicates the player has collected 0 dots, and each (x,y)

316 indicates the position of a player or dot.

317 If a player moves to position (2,2) and collects dot2, the string should appear as follows:

318 Player[1](2,2) Dot(1,1) Dot(-,-) Dot(3,3)

319 Showing the dot’s position as (-,-) indicates that the dot has been collected and has

320 disappeared.

321

Programming Fundamentals (48023) Autumn 2019 Assignment Page 14

322 Marking scheme for Part A

323 Your solution will be marked according to the following scheme:

Task 1: Classes and fields

Task 2: Constructors

Task 3: move() method

Task 4: toString() function

Design

Indentation

20 marks

20 marks

20 marks

20 marks

15 marks

5 marks

324 Design marks are awarded for the quality of your solution for tasks 3 and 4. More marks are

325 awarded for placing code into the most appropriate classes so as to increase cohesion and

326 reduce coupling. (To understand coupling and cohesion better, google the words … java

327 tutorial coupling cohesion.)

328 Indentation marks are awarded for correctly shifting code to the right by one tab between

329 { and } and within if statements.

330 Note: Once a student’s mark is 95 out of 100 or higher (i.e. when expressed as a mark out of

331 10, it is ≥ 9.5) the mark will be rounded UP to full marks. Thus a student should NOT spend

332 time trying to get a perfect score of 100/100 (i.e. 10/10).

333 Note: It is possible to receive partial marks for partially completing a task. The exact formula

334 PLATE uses to award marks for each task is displayed on the PLATE submission page for this

335 assignment, which you can view when you click on the link “Your submission”.

336 YOU WILL HAVE TO IMPLEMENT CORRECT FUNCTIONALITY FOR THE

337 CONSTRUCTORS AND METHODS IN TASKS 1 – 4 IF YOUR ATTEMPT AT PART B IS

338 TO WORK.

339 HOWEVER, YOU DO NOT HAVE TO GET FULL MARKS ON DESIGN AND

340 IMPLEMENTATION IN PART A BEFORE ATTEMPTING PART B.

341

342 Note: You have to use your solution to Part A to do Part B, so you have to do Part A first. But

343 you do NOT need to score full marks on Part A before doing Part B. You need PLATE to

344 award you a “PASS” for Tasks 1-5, but you do not need the “indentation” marks to start on

345 Part B.

Programming Fundamentals (48023) Autumn 2019 Assignment Page 15

346 Part B

347 Due date: 11:59pm on Sunday June 9, 2019 (i.e. 9/6/2019, 11:59pm).

348 Value: 20%

349 Topics: Data flow, OO programming basics, Control flow.

350 Objectives: This assignment supports objectives 1-5.

351 Introduction

352 In Part B you will finish the game that you started building in Part A. You will use your

353 solution to Part A as your starting point.

354

355

356

357

358

359 In Part B, you are free to redesign any aspect of your code except for the following:

360 Certain class names must be as specified:

361 From Part A: Game, Player, Dot.

362 Introduced in Part B: Enemy, Exit, Main.

363 Certain method headers must be as specified:

364 From Part A: Game.move(dx,dy).

365 Introduced in Part B: Game.input() and Game.start(). Also, each object must

366 provide an appropriate toString() function.

367 Apart from these requirements, you may add, remove or rename fields, add, remove or rename

368 methods, and add classes. Your design choices will be reflected in your design mark (see the

369 section “Marking Scheme” below).

Note!! Your Part B solution should be submitted on PLATE under the link “Assignment 1

Part B”. Be careful not to submit under the link “Assignment 1 Part A”.

Programming Fundamentals (48023) Autumn 2019 Assignment Page 16

370 Tasks

371 Task 1: Exit

372 Add 1 “exit” object to the game which has the position (4,4). Design the class “Exit” such that

373 its position can be specified by constructor parameters. Your Game’s toString() function

374 should now produce a string in the following format:

375

376 Player[](0,0) Dot(1,1) Dot(2,2) Dot(3,3) Exit(4,4)

377

378 A player reaches the exit when the player’s position is the same as the exit’s position. Note that

379 the number of dots collected by the player is now represented as [] if no dots have been

380 collected. These square brackets are to be filled with a * symbol for each dot collected. For

381 example, if two dots have been collected, this is represented as [**].

382 If the player reaches the exit and has already collected all 3 dots, the exit is “opened” and the

383 game’s toString() function displays the exit as “Exit(-,-)” instead of “Exit(4,4)”. That is, the

384 game’s toString() function returns:

385

386 Player[***](4,4) Dot(-,-) Dot(-,-) Dot(-,-) Exit(-,-)

387

388 The suggested development sequence for submitting to PLATE is:

389 1. Define class Exit with appropriate fields and an appropriate constructor, and create the

390 Exit.

391 2. Define an appropriate toString() function for Exit and submit to PLATE.

392 3. Modify your program so that the player performs actions in this order: (1) the player

393 moves, (2) the player collects a dot if possible, (3) the player reaches an exit if possible.

394 You may define new methods as appropriate for the task, but the design choice is yours.

395 Submit to PLATE.

396 4. Modify the Player’s toString() to display collectedDots as a series of * symbols. Submit

397 to PLATE.

398 Task 2: input() method

399 Define a method called input() in class Game that takes no parameters. This method should

400 present the user with the following menu:

401 Move (l/r/u/d):

402 This prompt should be printed with a single space following the colon, and should be printed in

403 a way that allows the user to type a movement command on the same line.

Programming Fundamentals (48023) Autumn 2019 Assignment Page 17

404 If the user types l, r, u or d at the prompt, you should invoke the move() method with

405 appropriate directional arguments that cause the player to move one step left, right, up or down

406 respectively. If the user enters an invalid movement command, you should print the error

407 message “Invalid move”.

408 HINT: You should probably use a switch statement to implement this movement menu.

409 The switch statement

410 The switch statement is more clear than a if/else statement when a variable is compared to a series of different

411 constant values:

If Statement Equivalent Switch Statement

if (place == 1)

{

System.out.println("Gold medal!");

}

else if (place == 2)

{

System.out.println("Silver medal!");

}

else if (place == 3)

{

System.out.println("Bronze medal!");

}

else

{

System.out.println(

"Sorry, you didn't place.");

}

switch (place)

{

case 1: System.out.println("Gold medal!");

break;

case 2: System.out.println("Silver medal!");

break;

case 3: System.out.println("Bronze medal!");

break;

default: System.out.println(

"Sorry, you didn't place.");

break;

}

412 An example of using a switch statement to process menu of commands

413 System.out.print("Would you like to quit? (Y/N) ");

414 String line = keyboard.nextLine();

415 char answer = line.charAt(0);

416 switch (answer)

417 {

418 case 'y':

419 case 'Y':

420 System.out.println("Bye.");

421 break;

422

423 case 'n':

424 case 'N':

425 System.out.println("Excellent!");

426 break;

427

428 default:

429 System.out.println("Invalid answer.");

430 break;

431 }

432 At this point, submit your solution to PLATE to receive marks for this task. Then continue

433 reading to earn the remainder of the marks.

434

Programming Fundamentals (48023) Autumn 2019 Assignment Page 18

435 Task 3: start() method

436 Define a start() method in class Game taking no parameters. This method should repeatedly

437 print the game’s string representation and invoke the game’s input() method until the game is

438 over. The game is over when the exit is open. After the game is over, the game’s string

439 representation should be printed once more followed on a separate line by the message “You

440 win!”.

441 Define a class called Main with a public static void main(String []

442 args)method. The main() method should ask the user for the initial (x,y) position of the

443 player according to the following sample I/O:

444 Initial x: 2

445 Initial y: 0

446 The numbers underlined and in bold represent input typed by the user. This is “sample” input.

447 Your program should read actual numbers from the user via the Scanner class. The user must

448 not enter negative numbers and is given 3 chances to input a valid number for each coordinate.

449 To handle this, your program must follow the sample I/O below:

450 Initial x: -3

451 Must not be negative.

452 Initial x: -1

453 Must not be negative.

454 Initial x: 4

455 Initial y: -7

456 Must not be negative.

457 Initial y: -7

458 Must not be negative.

459 Initial y: -7

460 Must not be negative.

461 Too many errors. Exiting.

462 Note that the user made only 2 mistakes when entering the x position, and the third input was

463 finally accepted. However, the user made 3 mistakes when entering the y position, and so the

464 program was aborted.

465 NOTE: due to a quirk in the behaviour of Scanner’s nextInt() method, you must follow each

466 use of nextInt() by an invocation of nextLine() as shown in the example below:

467 int number = keyboard.nextInt(); keyboard.nextLine();

468 Without adding the extra nextLine(), your program might generate the error

469 “StringIndexOutOfBoundsException”

470 If the user enters valid initial x and y position, create the Game with the user’s chosen initial

471 and (x,y) position for the player, and invoke the game’s start() method.

472 Test your program by running the main() method in BlueJ.

473 At this point, submit your solution to PLATE to receive marks for this task. Then continue

474 reading to earn the remainder of the marks.

475

Programming Fundamentals (48023) Autumn 2019 Assignment Page 19

476 Task 4: Enemy

477 If the user specifies the player’s initial x-position to be 5, the game will be started in “advanced

478 mode”. In advanced mode, one more object is introduced into the game called the “Enemy”.

479 The Enemy is created at position (5,5) and the game’s toString() function displays as follows:

480

481 Player[](5,0) Dot(1,1) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(5,5)

482

483 Each time after the player moves one step, the enemy also moves one step in the general

484 direction of the player. If the enemy catches up with the player, the enemy kills the player and

485 the game’s toString() functions displays, for example, as follows:

486

487 Player[*](-,-) Dot(-,-) Dot(2,2) Dot(3,3) Exit(4,4) Enemy(2,1)

488

489 Displaying the Player’s position as (-,-) indicates that the player was killed. In such a case, the

490 main game loop should also terminate and display the message “You lose!” instead of “You

491 win!”.

492 To the user, it will appear as though the player and enemy move simultaneously in each move

493 of the game. However, the computer must still carry out actions in a particular sequence. In this

494 game, the player should be asked to move, collect dots and potentially reach an exit before the

495 enemy is asked to move. If the player reaches an exit and the enemy attempts to kill the player

496 in the same move, the player exits and wins the game without being killed.

497 An interesting case occurs when the player and enemy are adjacent, the enemy takes one step

498 toward the player and the player takes one step toward the enemy. As a result, the enemy and

499 player swap places and neither before nor after the step do the two coincide at the same

500 position. If not programmed carefully, the player might pass right through the enemy without

501 dying. You need to make sure that the enemy does in this case catch and kill the player in

502 passing.

503 Each time the enemy is about to move one step, it either decides to continue moving in the

504 same direction that it moved in its previous step, or if that direction will not bring the enemy

505 closer to the player, the enemy will decide to change direction. The enemy will also invoke this

506 decision process on its first step because it has no previous direction to remember.

507 When deciding to change direction, the enemy considers the distance between the enemy’s and

508 player’s x positions (the “x distance”) and the distance between the enemy’s and player’s y

509 positions (the “y distance”). If the “x distance” is further than the “y distance”, the enemy will

510 change direction toward the player along the x axis (i.e. either left or right). If the “y distance”

511 is further than the “x distance”, the enemy will change direction toward the player along the y

512 axis (i.e. either up or down). Otherwise, the enemy will choose a special neutral direction

513 which has the effect of causing the enemy to not move.

Programming Fundamentals (48023) Autumn 2019 Assignment Page 20

514 This task is complex but it is possible in some cases to receive partial marks for partial

515 completeness. Make sure that you submit regularly to PLATE to see what scenarios are tested

516 and marked first.

517 At this point, submit your solution to PLATE to receive marks for this task.

518

519

520 Marking scheme for Part B

521 Your solution will be marked according to the following scheme:

Task 1: Exit

Task 2: input() method

Task 3: start() method

Task 4: Enemy

Correct indentation

Design

15 marks

10 marks

10 marks

30 marks

5 marks

30 marks

522

523 Correct indentation means that code should be shifted right by one tab between { and } and

524 within nested control structures such as if statements, switch statements and loop statements. In

525 a switch statement, the code within each case should also be indented. NOTE: You are

526 responsible for your own indentation. Do not rely on BlueJ to indent code for you. BlueJ does

527 not always indent code in the way that is required.

528 Design refers to how well you have constructed your code to eliminate repeated code, and how

529 well you have structured your program in terms of coupling and cohesion. (To understand

530 coupling and cohesion better, google the words … java tutorial coupling cohesion.)

531 Note: The exact formula PLATE uses to award marks for each task is displayed on the PLATE

532 submission page for this assignment, which you can view when you click on the link “Your

533 submission”.

534 Note: Once a student’s mark is 98 out of 100 or higher (i.e. when expressed as a mark out of

535 20, it is ≥ 19.6) the mark will be rounded UP to full marks. Thus a student should NOT spend

536 time trying to get a perfect score of 100/100 (i.e. 20/20).