Programming Fundamentals讲解、Java设计辅导、讲解Java编程语言
讲解R语言程序|讲解Java程序
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.
173Programming 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.
273Programming 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.
321Programming 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.
434Programming 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.
475Programming 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).