Computer Science 9618/41 — May/June 2022

Background Concept

The main program controls the order in which procedures run. In a procedural solution, you normally:

1. set up or read the data
2. process it
3. output the result

Calling procedures in the right sequence is essential, because later procedures often depend on earlier ones having already prepared the data.

Understanding the Question

This part says the main program should first call ReadHighScores() and then OutputHighScores(). That means the stored values must be loaded from the file before attempting to print them.

Approach

Write a minimal Python main block that:

• starts program execution
• reads the file into the arrays
• outputs the values that were read

Step-by-Step Reasoning

if __name__ == "__main__":

• marks the main program section in Python
• ensures this code runs when the program is executed directly

ReadHighScores()

• must come first
• fills the arrays with the ten player names and scores from the file

OutputHighScores()

• comes second
• uses the data now stored in the arrays and prints it in the required format

If these were reversed, the output procedure would run before the arrays had been populated, so the results would be incorrect.

Key Takeaways

• Main programs organise the order of execution.
• Input or file reading usually comes before output.
• A procedure call is only useful if the required data is already available.

Common Mistakes

• Calling OutputHighScores() before ReadHighScores().
• Omitting one of the procedure calls.
• Writing the procedures again instead of just calling them.

Things to Be Careful About

• The question is about the main program only, not the full program listing again.
• Keep the call order exactly as stated.
• Make sure the procedure names match earlier declarations exactly.

Background Concept

A test run for a program that reads a file and prints values can be predicted exactly if the input file contents are known. Since this question gives the full contents of HighScore.txt, the expected output can be worked out without ambiguity.

Understanding the Question

You are testing the main program from part (d)(i). That main program:

1. reads the 10 players and scores from the file
2. outputs them in the format PlayerName Score

So the screenshot should simply show the ten lines from the file, paired correctly.

Approach

Take the file two lines at a time:

• first line is the player name
• second line is the score

Then write each pair on one output line.

Step-by-Step Reasoning

From the file:

• FYI and 10000 become FYI 10000
• ABC and 9092 become ABC 9092
• KEL and 8500 become KEL 8500
• PAI and 8203 become PAI 8203
• BBB and 7980 become BBB 7980
• ACE and 7246 become ACE 7246
• GKL and 7001 become GKL 7001
• JSI and 6490 become JSI 6490
• EIF and 6003 become EIF 6003
• DIS and 2000 become DIS 2000

Because the main program in part (d)(i) has no user input prompts, the console output contains only these ten lines.

Key Takeaways

• When a file is fully provided, you can derive exact test output.
• Parallel arrays should preserve the correct pairing between fields.
• Testing often checks both the content and the formatting of output.

Common Mistakes

• Forgetting that the score is printed on the same line as the name.
• Printing blank lines because the file newline was not stripped.
• Including an extra unused 11th element.

Things to Be Careful About

• The order must stay descending, exactly as stored in the file.
• There are no prompts or extra headings in this specific test run.
• The output must contain ten entries, not nine or eleven.

Background Concept

Input validation checks whether data meets required rules before the program continues. Two common types appear here:

• length validation for the player name
• range validation for the score

Validation is important because later parts of the program assume the name is exactly 3 characters and the score is a valid integer within the allowed limits.

Understanding the Question

You are asked to amend the main program so that it asks for:

• a 3-character player name
• an integer score from 1 to 100000 inclusive

This does not yet require insertion; it only requires collecting valid input ready for later use.

Approach

Keep the existing main program structure, then add:

1. an input for the player name
2. a loop that repeats until the name length is exactly 3
3. an input for the score
4. a loop that repeats until the score is inside the allowed range

Step-by-Step Reasoning

ReadHighScores() and OutputHighScores() remain from the earlier main program.

NewPlayer = input("Enter username\n")

• asks the user to type a player name
• the newline in the prompt makes the typed value appear on the next line

while len(NewPlayer) != 3:

• checks the name length
• repeats the prompt if the name is not exactly 3 characters

NewScore = int(input("Enter score\n"))

• asks for the score
• converts the typed text into an integer

while NewScore < 1 or NewScore > 100000:

• checks that the score is within the inclusive range
• repeats the prompt if it is too small or too large

Once both values are valid, they are stored in NewPlayer and NewScore for later use.

Key Takeaways

• Validation ensures input satisfies the rules before processing.
• Exact-length checks and range checks are very common exam patterns.
• Store validated input in variables ready for later procedures.

Common Mistakes

• Checking <= 3 or >= 3 instead of exactly 3 characters.
• Using the wrong score limits.
• Forgetting that the range is inclusive, so 1 and 100000 are both valid.
• Not converting the score to int.

Things to Be Careful About

• This code assumes the user enters numeric text for the score; handling non-numeric errors is a separate issue unless specifically asked.
• Use the same variable names later when calling the insertion procedure.
• Do not lose the earlier file-reading step when amending the main program.

Background Concept

This is an insertion into a sorted list. The scores are already stored in descending order, so the new score should be placed into the spare 11th position and then moved upward until it reaches the correct place. Because the player name and score are related, any movement of a score must also move the matching name.

This is similar to one backward pass of bubble sort or an insertion operation in a sorted array.

Understanding the Question

The procedure must:

• take a player name and score as parameters
• create a new top-ten list if the score is good enough

The question has already provided an 11-element structure, so the intended method is to use the extra slot for the new value and then reorder the list.

Approach

1. Put the new name and score into index 10, the spare slot.
2. Move backwards through the list.
3. Whenever the new score is greater than the score above it, swap them.
4. Whenever scores are swapped, also swap the corresponding names.

After this pass, the list is still in descending order, and the lowest item ends up in the unused last position.

Step-by-Step Reasoning

def InsertScore(NewPlayerName, NewPlayerScore):

• defines the procedure with the required parameters

PlayerName[10] = NewPlayerName
PlayerScore[10] = NewPlayerScore

• place the new entry into the extra slot

for Index in range(10, 0, -1):

• starts at the last position and moves backwards to 1
• compares each item with the one above it

if PlayerScore[Index] > PlayerScore[Index - 1]:

• checks whether the lower item should move up because its score is higher
• this maintains descending order

The temporary variables perform a swap:

• first swap the scores
• then swap the names

Swapping both arrays is essential, otherwise names and scores would no longer match.

If the new score is too small, no swap happens, so it stays in the 11th slot and is effectively ignored when only the top ten are later output or written to file.

Key Takeaways

• A sorted list can accept a new item by inserting it and shifting or swapping into place.
• Parallel arrays must always be updated together.
• Working backwards is a natural way to insert into a descending list with one spare slot.

Common Mistakes

• Swapping scores but forgetting to swap names.
• Comparing in the wrong direction, which would produce ascending order.
• Starting at the wrong index and missing the spare slot.
• Using only 10 elements, leaving nowhere to place the new value temporarily.

Things to Be Careful About

• Index 10 is the 11th element in Python because indexing starts at 0.
• The list is descending, so higher scores move towards the front.
• Equal scores are not moved by this version because the test uses > rather than >=, which keeps the existing order stable enough for this task.

Background Concept

A main program often acts as the coordinator for a series of smaller procedures. Good decomposition means each procedure does one job:

• ReadHighScores() loads the data
• OutputHighScores() displays the current list
• InsertScore() updates the list structure

The main program decides when each one runs.

Understanding the Question

This part asks you to amend the main program again so that it:

• asks for the new player name and score
• outputs the current list before insertion
• calls the insertion procedure
• outputs the list after insertion

So the important idea is not just calling the procedure, but showing the effect of the procedure clearly.

Approach

Use this order:

1. read the original top ten from file
2. input and validate the new values
3. print before
4. output the original list
5. call InsertScore()
6. print after
7. output the updated list

Step-by-Step Reasoning

ReadHighScores()

• loads the original ten entries into the arrays

The input and validation code stores valid values in NewPlayer and NewScore.

print("before")

• labels the first output clearly

OutputHighScores()

• shows the original top ten before any change

InsertScore(NewPlayer, NewScore)

• passes the newly entered values into the insertion procedure
• the procedure updates the global arrays into the new sorted order

print("after")

• labels the second output

OutputHighScores()

• shows the updated top ten after the insertion logic has been applied

This ordering makes it easy to verify that the procedure worked correctly.

Key Takeaways

• Main programs integrate smaller procedures into a complete solution.
• Printing data before and after an update is a strong testing technique.
• Parameter passing allows the main program to supply user input to a procedure.

Common Mistakes

• Printing only after insertion and forgetting the before output.
• Calling InsertScore() before showing the original list.
• Not passing both the player name and score as parameters.
• Losing the validation code from part (e)(i).

Things to Be Careful About

• The labels before and after should be output in the correct places.
• The arrays must be read from the file before the insertion is attempted.
• Keep the order of procedure calls logical and consistent.

Background Concept

Testing a sorted insertion routine means checking both the original state and the updated state. Because the list is in descending order, a higher score must appear nearer the top. If a new score is inserted into the top ten, the lowest previous score is pushed out of the visible list.

Understanding the Question

The test data is fixed:

• player name: JKL
• score: 9999

You must show the expected output of the amended main program from part (e)(iii), which prints:

• the prompt and entered values
• the list before insertion
• the list after insertion

Approach

Compare 9999 with the existing scores:

• less than 10000
• greater than 9092

So JKL 9999 must be inserted into second place.

Then everything below that position shifts down by one place, and the old last visible top-ten entry is removed from the displayed list.

Step-by-Step Reasoning

Original list:

1. FYI 10000
2. ABC 9092
3. KEL 8500
4. PAI 8203
5. BBB 7980
6. ACE 7246
7. GKL 7001
8. JSI 6490
9. EIF 6003
10. DIS 2000

Now insert JKL 9999.

Since 9999 is less than 10000 but greater than 9092, it goes between those two. The updated top ten becomes:

1. FYI 10000
2. JKL 9999
3. ABC 9092
4. KEL 8500
5. PAI 8203
6. BBB 7980
7. ACE 7246
8. GKL 7001
9. JSI 6490
10. EIF 6003

DIS 2000 is pushed into 11th place, so it is no longer shown when only the top ten are output.

Key Takeaways

• In a descending list, compare the new score against existing scores to locate its position.
• Showing before and after output is an effective test of insertion logic.
• When a list is limited to the top ten, the lowest previous item may be dropped.

Common Mistakes

• Putting JKL 9999 in first place even though 10000 is higher.
• Leaving DIS 2000 in the output after insertion, which would incorrectly show 11 items.
• Forgetting the before section and showing only the final list.

Things to Be Careful About

• The program prompts appear before the lists.
• The output remains in descending order after insertion.
• The new player is inserted only once, not added again at the bottom as well.