Computer Science 9618/41 — May/June 2024

Background Concept

The main program controls the order in which procedures run. In a program like this, the sequence matters: initialise the count, gather the data, then display the stored values. When only part of an array contains valid data, output should usually be limited to that populated section.

Understanding the Question

This part says the main program stores 0 in NumberItems, calls Initialise(), and then outputs the contents of DataStored. The important detail is that only the entered items should be shown, not all 20 positions.

Approach

Set NumberItems to 0 first. Call Initialise() so the user can enter the data. Then print only DataStored[0:NumberItems], which is the slice containing the valid numbers.

Step-by-Step Reasoning

NumberItems = 0 matches the instruction in the question. It ensures the program starts with no active items.

Initialise() then runs the procedure written in part (b). That procedure validates the quantity and stores the input integers into the first NumberItems positions of the list.

print(DataStored[0:NumberItems]) outputs only the values that were actually entered. If you printed the whole list, you would also display unused zeros, which does not match the evidence shown in the mark scheme.

Key Takeaways

You should understand how the main program coordinates procedure calls and why output is often limited to the used portion of an array or list.

Common Mistakes

A common mistake is printing DataStored by itself, which would show all 20 positions. Another mistake is forgetting to call Initialise(), so no user data is stored before printing.

Things to Be Careful About

Python list slicing excludes the upper bound, so DataStored[0:NumberItems] correctly includes positions 0 to NumberItems - 1. Keep the order of statements correct: output must come after the procedure call.

Background Concept

Testing console programs often means following the prompts, the user's responses and the final output exactly. If validation is present, invalid data produces extra prompts before the program can continue.

Understanding the Question

You are not writing new code here. You are showing what the program would display when the user enters 30, then 5, then the five numbers 3, 9, 4, 1, 2. The first value is deliberately invalid because the allowed quantity is only 1 to 20.

Approach

Trace the program in order. First, the quantity is read and checked. Because 30 is too large, the program asks again. Once 5 is entered, the program reads five numbers and then prints the populated section of the list.

Step-by-Step Reasoning

The first prompt appears:
How many numbers will you enter?
The user enters 30.

Validation checks whether the quantity is less than 1 or greater than 20. Since 30 > 20, it is rejected, so the same prompt appears again.

The user then enters 5, which is valid. The program now runs the input loop five times:

• first stores 3
• second stores 9
• third stores 4
• fourth stores 1
• fifth stores 2

After that, the main program prints DataStored[0:NumberItems], so the output is [3, 9, 4, 1, 2].

Key Takeaways

You should be able to trace how validation affects output and how a list slice produces only the values that were actually entered.

Common Mistakes

A common mistake is forgetting the repeated prompt after the invalid 30. Another is giving the list in sorted order, even though sorting has not happened yet in part (c).

Things to Be Careful About

This output is from the program before any bubble sort is added. Also, the displayed list contains spaces after commas in normal Python list output.

Background Concept

Bubble sort is a comparison sort that repeatedly scans through a list, comparing adjacent items and swapping them if they are in the wrong order. After each full pass, the largest remaining unsorted value has moved to its correct position at the end of the list. Because of that, each later pass can be one comparison shorter.

Understanding the Question

You must write a procedure BubbleSort() that sorts the values in DataStored into ascending numerical order. The array length to use is not 20 every time; it is the current value of NumberItems, because only those positions contain valid data.

Approach

Use two loops: an outer loop for the number of passes, and an inner loop for adjacent comparisons within each pass. If a left value is greater than the one to its right, swap them. Repeat until the list is sorted.

Step-by-Step Reasoning

global DataStored, NumberItems allows the procedure to sort the shared list.

for x in range(NumberItems - 1): controls the passes. If there are n items, bubble sort needs at most n - 1 passes.

for y in range(NumberItems - x - 1): compares adjacent positions. The - x shortens the inner loop each pass because the largest items have already bubbled to the end.

if DataStored[y] > DataStored[y + 1]: checks whether two neighbouring values are out of ascending order.

The three assignment statements using Temp perform a swap:

• store the left value temporarily
• move the right value left
• put the saved value on the right

After all passes finish, the first NumberItems positions are in ascending order.

Key Takeaways

You should know the standard bubble sort pattern: nested loops, adjacent comparison and swap when needed. You should also recognise why the inner loop becomes shorter on later passes.

Common Mistakes

Common mistakes include comparing in the wrong direction, which would sort descending instead of ascending, and using the wrong loop bounds so y + 1 goes out of range. Another mistake is forgetting one part of the swap, which loses a value.

Things to Be Careful About

The sort must use NumberItems, not the full size 20. Also, the array must be sorted in ascending numerical order, so the condition should be > before swapping.

Background Concept

After a sorting procedure has been written, the main program must call it at the correct point. Program flow is important: data must be input before it can be sorted, and it must be sorted before sorted output can be displayed.

Understanding the Question

This part asks you to amend the main program so that BubbleSort() is called and the sorted contents are then output. That means the sort must appear after Initialise() and before the print statement.

Approach

Keep the same main-program structure from part (c), but insert BubbleSort() before the output line.

Step-by-Step Reasoning

NumberItems = 0 sets the starting count.

Initialise() reads and stores the user's values.

BubbleSort() then rearranges the first NumberItems values in ascending order.

print(DataStored[0:NumberItems]) displays only the used portion, which is now sorted.

Key Takeaways

You should be comfortable integrating separately written procedures into a main program in the correct sequence.

Common Mistakes

A common mistake is printing the array before calling BubbleSort(), which would still show the original unsorted order. Another is printing the whole list and showing unused zeros.

Things to Be Careful About

The new procedure call must be inserted between input and output. Keep the slice DataStored[0:NumberItems] so the evidence matches the required display.

Background Concept

Testing after adding a sort checks that the data entry still works and that the sorting algorithm changes the order correctly. With bubble sort, the final displayed list should be in ascending order.

Understanding the Question

You must show the output when the user enters that there will be 5 numbers, followed by 3, 9, 4, 1, 2. Because the main program now calls BubbleSort(), the displayed list should be sorted before it is printed.

Approach

Store the five values, apply bubble sort, then write the exact list that Python would print.

Step-by-Step Reasoning

The values entered are [3, 9, 4, 1, 2] initially.

After sorting into ascending order, they become [1, 2, 3, 4, 9].

That sorted list is what print(DataStored[0:NumberItems]) displays.

Key Takeaways

You should be able to distinguish between the original input order and the post-sort output order.

Common Mistakes

A common mistake is giving the unsorted list from part (c) again. Another is omitting one of the values after sorting.

Things to Be Careful About

The output shown here is after the bubble sort has been added. Keep the list format exactly as Python displays it, with brackets and commas.

Background Concept

Binary search is an efficient searching algorithm for sorted data. Instead of checking each item one by one, it repeatedly looks at the middle item and discards half of the remaining search area. An iterative binary search uses a loop with lower and upper bounds rather than recursive function calls.

Understanding the Question

The function BinarySearch() takes one integer parameter, DataToFind. It must search the sorted array DataStored and return the index where the value is found. If it is not present, it must return -1. The word "iterative" is important: this must be written with a loop, not recursion.

Approach

Start with the whole populated part of the array as the search interval: lower bound 0, upper bound NumberItems - 1. Repeatedly calculate the middle index. If the middle value is the target, return that index. If the target is larger, search the upper half next; if smaller, search the lower half next. If the bounds cross, the value is not present.

Step-by-Step Reasoning

LowerBound = 0 sets the first valid index of the used part of the list.

UpperBound = NumberItems - 1 sets the last valid index.

while LowerBound <= UpperBound: means there is still at least one possible position left to check.

Middle = (LowerBound + UpperBound) // 2 finds the midpoint index using integer division.

If DataStored[Middle] == DataToFind, the search succeeds immediately, so the function returns Middle.

If DataStored[Middle] < DataToFind, the target must be to the right in a sorted ascending list, so the new lower bound becomes Middle + 1.

Otherwise, the target must be to the left, so the new upper bound becomes Middle - 1.

If the loop ends without finding the item, the function returns -1, which is a standard sentinel value meaning "not found".

Key Takeaways

You should know that binary search only works correctly on sorted data and that the essential mechanics are midpoint calculation plus shrinking bounds.

Common Mistakes

A very common mistake is trying to binary search unsorted data. Another is updating a bound to Middle instead of Middle + 1 or Middle - 1, which can cause an infinite loop. Some candidates also return -1 too early from inside the loop.

Things to Be Careful About

This question uses Python list indexes, so the first index is 0. Make sure the function returns the index, not the value found. Also ensure integer division uses //.

Background Concept

A function is called with an argument, processes that input and returns a value. The main program can then use or display that returned value. Here, the search key comes from the user and the binary search function returns either an index or -1.

Understanding the Question

You must amend the main program again so that, after sorting and displaying the array, it asks the user for a number to find, calls BinarySearch() with that number, and outputs the returned value.

Approach

Keep the input and sorting steps from the earlier parts. Then add one input statement to get the search value and one output statement to display the result of BinarySearch().

Step-by-Step Reasoning

NumberItems = 0, Initialise() and BubbleSort() are still needed because the search should happen on the populated, sorted data.

print(DataStored[0:NumberItems]) shows the sorted list before the search result, which matches the evidence in the mark scheme.

DataToFind = int(input("Enter a number to find")) reads the target value from the user.

print(BinarySearch(DataToFind)) calls the function and prints its return value directly. If the value is present, the index is shown; otherwise -1 is shown.

Key Takeaways

You should be able to add a function call into an existing main program and pass user input into that function.

Common Mistakes

A common mistake is forgetting to sort before using binary search. Another is reading the search value as text and not converting it to an integer.

Things to Be Careful About

The prompt text should match the program style used elsewhere. Also, the question asks to output the value returned from the function call, so the result must be printed, not just stored.

Background Concept

A full test of a search routine should include both a successful search and an unsuccessful one. For binary search, the array must first be sorted, then the returned value is either the index of the matching item or a sentinel such as -1.

Understanding the Question

You must show the outputs for two runs of the finished program. In both tests, the numbers entered are 1, 6, 2, 8, 10, which are then sorted. In Test 1 the search target is 2, which exists. In Test 2 the search target is 7, which does not exist.

Approach

First determine the sorted array. Then apply binary search mentally to decide what index is returned for 2 and what happens for 7.

Step-by-Step Reasoning

After input, the values are [1, 6, 2, 8, 10].

After BubbleSort(), they become [1, 2, 6, 8, 10].

For Test 1, the user searches for 2. In this sorted list, 2 is at index 1 using Python's 0-based indexing, so the program outputs 1.

For Test 2, the user searches for 7. The search narrows the range but never finds a match, so the function returns -1.

That is why the two final outputs are 1 and -1.

Key Takeaways

You should be able to test search algorithms using both normal and not-found cases, and you should understand that list indexes in Python start at 0.

Common Mistakes

A common mistake is answering 2 for the first test because the value searched for is 2; the function returns the index, not the value. Another is giving index 2 because of 1-based counting, but Python uses 0-based indexing.

Things to Be Careful About

The output list is sorted before the search happens. Also, -1 is not an index here; it is the special return value meaning the item was not found.

Background Concept

In object-oriented programming, a class is a template for creating objects. Each object stores its own data in attributes and can provide methods to work with that data. A constructor is the method that runs when a new object is created. Its job is usually to receive parameter values and use them to initialise the attributes.

This question also requires the attributes to be private. In Python, this is usually shown with a double underscore prefix such as __TreeName. That indicates the data should be accessed through methods rather than directly from outside the class. In Cambridge Paper 4, Python answers often include commented attribute declarations because Python does not require separate declarations before use.

Understanding the Question

You are asked only for the declaration of the Tree class and its constructor. You must not add the other methods yet. The class needs to store five pieces of data from the stem:

• tree name
• yearly height growth
• maximum height
• maximum width
• evergreen status

Because the question explicitly says all attributes must be private, each attribute must be stored as a private instance variable.

Approach

The simplest correct Python answer is:

1. declare class Tree
2. add comment lines showing the private attributes
3. write __init__ with one parameter for each item of tree data
4. copy each parameter into the corresponding private attribute using self

That fully satisfies the constructor requirement.

Step-by-Step Reasoning

class Tree: creates the class.

The comment lines are included because the question specifically says that if Python is used, attribute declarations should be shown using comments. They make clear that the object stores five private fields.

The constructor in Python is def __init__(...). The first parameter must be self, which refers to the current object being created.

The remaining parameters match the values described in the table:

• TreeName
• HeightGrowth
• MaxHeight
• MaxWidth
• Evergreen

Each assignment such as self.__TreeName = TreeName stores the passed value inside the new object. The double underscore keeps the attribute private.

No getter methods should appear here, because the part explicitly says not to declare the other methods.

Key Takeaways

• A constructor initialises object attributes when an object is created.
• Private attributes in Python are commonly written with a double underscore prefix.
• In Paper 4 Python answers, comment-based attribute declarations are often used when requested.

Common Mistakes

• Making attributes public, for example using self.TreeName instead of self.__TreeName.
• Forgetting one of the five attributes from the class table.
• Writing getter methods in this part even though the question says not to.
• Omitting self from the constructor parameter list.

Things to Be Careful About

Use the exact class name Tree and keep the attribute meanings consistent with the stem. Make sure the constructor stores all five values, not just some of them. In Python, the constructor must be named __init__, not Constructor().

Background Concept

A getter method returns the value of a private attribute. Getters are part of encapsulation: the data is hidden inside the object, and outside code accesses it through methods rather than directly.

In this question, the class stores its fields privately, so other parts of the program must use methods such as GetTreeName() and GetMaxHeight() to read those values.

Understanding the Question

This part tells you exactly what each get method should do: return the relevant attribute. That means no calculations, no printing, and no input. Each method simply returns one field from the Tree object.

Because part (i) already created the private attributes, these methods must refer to those same private names.

Approach

For each required getter:

1. use the exact method name from the question
2. include self as the parameter
3. return the correct private attribute

There are five methods, one for each stored value.

Step-by-Step Reasoning

GetTreeName() returns self.__TreeName, which is the stored tree name.

GetGrowth() returns self.__HeightGrowth, the annual growth amount.

GetMaxHeight() returns self.__MaxHeight.

GetMaxWidth() returns self.__MaxWidth.

GetEvergreen() returns self.__Evergreen.

The key point is that each method returns a value. It does not display it with print(), because later procedures may need to use the value inside conditions or calculations.

Key Takeaways

• Getter methods allow code outside the class to read private data safely.
• A getter usually contains just one return statement.
• The method names and the returned attributes must match exactly.

Common Mistakes

• Using print() instead of return.
• Returning the wrong attribute from a method.
• Forgetting self in the parameter list.
• Accessing public names that do not exist instead of the private attributes created in part (i).

Things to Be Careful About

Keep the method names exactly as given: GetTreeName(), GetGrowth(), GetMaxHeight(), GetMaxWidth() and GetEvergreen(). In Python, the return statements must use the same private attribute names as the constructor, including the double underscores.

Background Concept

A main program coordinates previously defined routines. In Paper 4, once helper functions and procedures have been written, the main program usually just calls them in the right order and passes the right data between them.

Because ReadData() returns an array of Tree objects, the main program can store that array in a variable and then use indexing to access a specific object.

Understanding the Question

The question tells you exactly what the main program must do:

1. call ReadData()
2. store the return value
3. call PrintTrees() with the first object in the returned array

So there is no need for loops or extra logic here.

Approach

Use one variable to hold the returned list of Tree objects, then use index 0 to access the first object because Python lists are zero-indexed.

Step-by-Step Reasoning

TreeArray = ReadData() calls the file-reading function from part (b). After that call, TreeArray contains 9 Tree objects built from the file.

PrintTrees(TreeArray[0]) takes the first object in that list and sends it to the printing procedure from part (c).

In Python, the first element of a list is at index 0, so TreeArray[0] refers to the first tree read from the file. From Trees.txt, that first tree is Beech.

Key Takeaways

• Main programs often just sequence function and procedure calls.
• A function return value can be stored and reused later.
• Python lists are zero-indexed.

Common Mistakes

• Forgetting to store the result of ReadData().
• Using index 1 for the first element instead of 0.
• Passing the whole array to PrintTrees() instead of a single Tree object.

Things to Be Careful About

The question asks for the first object in the returned array, so the correct Python index is 0. Make sure the function name and procedure name match the earlier parts exactly.

Background Concept

For screenshot or test-output questions, you do not write new logic. Instead, you run or mentally trace the program using the supplied data and determine exactly what the console will display.

That means combining the file contents, the main program, and the output procedure.

Understanding the Question

The main program from part (d)(i) reads the tree data and prints the first object. The reference file shows that the first row is:

Beech,30,400,200,No

So the printed object has:

• name Beech
• growth 30
• maximum height 400
• maximum width 200
• evergreen No

Because it is not evergreen, the non-evergreen output sentence is used.

Approach

Take the first record from the file, substitute its values into the PrintTrees() sentence, and choose the correct ending based on Evergreen = No.

Step-by-Step Reasoning

ReadData() reads the first line and creates a Tree object representing Beech.

The main program passes that object to PrintTrees().

Inside PrintTrees(), GetEvergreen() returns "No", so the else branch is used.

The values inserted are:

• GetTreeName() → Beech
• GetMaxHeight() → 400
• GetMaxWidth() → 200
• GetGrowth() → 30

This produces the final console line shown in the answer.

Key Takeaways

• For output questions, combine the source data with the program logic.
• The branch taken depends on the stored field values.
• Exact wording matters in console output tasks.

Common Mistakes

• Choosing the evergreen sentence even though Beech has No in the file.
• Mixing up growth and maximum height.
• Forgetting that the first record in the file is Beech.

Things to Be Careful About

Use the first object only. Do not print all trees. Keep the wording exactly consistent with the PrintTrees() procedure logic, especially the final sentence about leaves.

Background Concept

This is a filtering problem. A program has a collection of objects and must select only those whose attribute values satisfy given conditions. In Python, a common way to do this in exam code is a linear traversal of the list with an if statement containing all required tests.

Because the data is stored as Tree objects with private attributes, the procedure must use the getter methods when checking values.

Understanding the Question

The user gives three requirements:

• maximum allowed height
• maximum allowed width
• whether the tree should be evergreen or not

A tree is suitable only if all three conditions are satisfied. The procedure must also create a new array containing all suitable trees and call PrintTrees() for each one. If none are suitable, a message must be shown.

Approach

The best structure is:

1. input the user requirements
2. convert the evergreen-style input into the stored file format Yes or No
3. create an empty list for matching trees
4. loop through every tree in the input array
5. test all three conditions together using and
6. if the tree matches, append it to the list and print it
7. after the loop, if the list is empty, print a no-match message

Step-by-Step Reasoning

MatchingTrees = [] creates the new array required by the question.

The procedure asks for the three user requirements. The height and width are converted to integers because comparisons like <= must be numeric.

The example solution uses keep and lose as user-friendly inputs, then maps them to the stored values:

• keep becomes Yes
• anything else here is treated as No

That matters because the file and object store evergreen as Yes or No, not as keep or lose.

The for CurrentTree in TreeArray: loop checks every tree object.

The condition uses three tests joined by and:

• GetMaxHeight() <= MaxHeight
• GetMaxWidth() <= MaxWidth
• GetEvergreen() == EvergreenNeeded

A tree must satisfy all three at the same time.

If it does, the object is appended to MatchingTrees, then PrintTrees(CurrentTree) outputs its details.

After the loop, len(MatchingTrees) == 0 checks whether no tree met the conditions. If so, a suitable message is printed.

Key Takeaways

• Filtering a list of objects usually means a loop plus a multi-condition if statement.
• Build a new list of matches if later parts of the program may need the selected objects.
• When stored values use a different format from user input, convert one form to the other before comparing.

Common Mistakes

• Using or instead of and, which would allow trees that meet only some requirements.
• Forgetting to append matching trees to the new array.
• Comparing keep directly with Yes without converting it.
• Printing the no-match message inside the loop instead of after the loop.

Things to Be Careful About

The wording says the tree's maximum height and width must be not more than the user's input, so the comparison must be <=, not < and not >=. Use getter methods, not direct attribute access. Keep the no-match test until after all trees have been checked.

Background Concept

Once a filtered list has been produced, a common next step is to search within that smaller list for one chosen item. Because the list is not sorted by name and is likely small, a linear search is the appropriate method.

The years-to-maximum-height calculation is based on:

remaining height needed divided by yearly growth

So if a tree still needs 150 cm and grows 40 cm each year, it will take $150 / 40 = 3.75$ years.

Understanding the Question

This part says the existing ChooseTree() procedure must be amended after it has listed the suitable trees. The program must then:

• ask the user which of those trees they want
• ask for its starting height
• calculate how many years it will take to reach maximum height
• output the result

The important phrase is "from those that meet all the requirements". That means the search should be done in the MatchingTrees list, not in the full original tree array.

Approach

Add code after the matching trees have been displayed:

1. only continue if there is at least one suitable tree
2. input the chosen tree name
3. input the starting height
4. linearly search MatchingTrees for that name
5. when found, calculate years using maximum height minus starting height, divided by yearly growth
6. print the answer and stop searching

Step-by-Step Reasoning

The guard if len(MatchingTrees) > 0: prevents the program from asking the user to choose a tree when none were found.

TreeChoice stores the selected name.

StartHeight is converted to an integer because it is numeric input.

The loop goes through each tree in MatchingTrees. For each one, the name is checked with GetTreeName().

When the chosen tree is found, the calculation is:

• remaining growth needed = GetMaxHeight() - StartHeight
• years = remaining growth needed divided by GetGrowth()

For the sample test in the question, Blue Conifer has maximum height 250 and growth 40. Starting at 100 cm gives:

• remaining growth = 250 - 100 = 150
• years = 150 / 40 = 3.75

That is why the output is approximately 3.75 years.

break stops the loop after the correct tree has been found.

Key Takeaways

• Use a linear search when checking a small unsorted list.
• Search the filtered results, not the original full data set.
• Real division is needed when the answer may not be a whole number.

Common Mistakes

• Searching the whole tree array instead of only the suitable trees.
• Using integer division, which would lose the decimal part.
• Forgetting to subtract the starting height before dividing.
• Asking for a tree choice even when there are no matching trees.

Things to Be Careful About

The selected tree name should match one of the printed suitable trees. Use / for real division in Python, not //. Keep the calculation in the order shown: remaining height first, then divide by yearly growth.

Background Concept

A main program brings together the previously written procedures. For a test-output question, you must follow the exact control flow and use the supplied input values to determine what appears on screen.

This part uses:

• file input from Trees.txt
• object creation in ReadData()
• formatted output in PrintTrees()
• filtering and calculation in ChooseTree()

Understanding the Question

The question says to amend the main program so that it calls ChooseTree(). The wording says ChooseTrees() once, but this is clearly a naming inconsistency because the procedure defined earlier is ChooseTree().

You must also test with these specific values:

• maximum height 400
• maximum width 200
• evergreen choice meaning keeps leaves
• selected tree Blue Conifer
• starting height 100

The expected output therefore depends on both the first printed tree from the original main program and the later filtering process.

Approach

The main program should still:

1. read the file into TreeArray
2. print the first tree
3. call ChooseTree(TreeArray)

Then trace which trees meet the new requirements.

Step-by-Step Reasoning

First, ReadData() loads all 9 trees.

PrintTrees(TreeArray[0]) prints the first one, which is Beech.

Then ChooseTree(TreeArray) runs.

The user enters that they want a tree that keeps its leaves, so the required evergreen value is Yes.

The height limit is 400 and the width limit is 200.

Now check the evergreen trees in the file:

• Holly: height 600, width 300 → too tall and too wide
• Magnolia Grandiflora: height 500, width 300 → too tall and too wide
• Photinia: height 400, width 400 → width too large
• Blue Conifer: height 250, width 50 → suitable
• Green Conifer: height 300, width 150 → suitable

So two trees are printed: Blue Conifer and Green Conifer.

The user then chooses Blue Conifer and enters starting height 100.

For Blue Conifer:

• maximum height = 250
• yearly growth = 40
• remaining growth = 250 - 100 = 150
• years = 150 / 40 = 3.75

So the final line is Your tree should be full height in approximately 3.75 years.

Key Takeaways

• Main programs often require only small amendments to incorporate new procedures.
• Test-output questions depend on exact tracing, not guesswork.
• Filtering conditions can be checked systematically against the supplied data file.

Common Mistakes

• Calling ChooseTrees() instead of ChooseTree() because of the typo in the question text.
• Forgetting that the earlier Beech output still appears before the ChooseTree() interaction.
• Including trees that exceed one of the limits.
• Using the wrong tree for the final year calculation.

Things to Be Careful About

Python list indexing means the first printed tree is still Beech. Only evergreen trees with maximum height at most 400 and maximum width at most 200 should be listed. The final year value should be 3.75, so real division must be used.

Background Concept

This part combines two ideas:

1. validating data using a check digit
2. storing valid data in a queue

A check digit is an extra character added to data so that the program can test whether the data is likely to be correct. Here, the first 6 characters are digits and the 7th character is the check digit.

The algorithm is positional and weighted:

• positions 0, 2, 4 are multiplied by 1
• positions 1, 3, 5 are multiplied by 3
• the products are added
• the total is divided by 10
• the integer part becomes the check digit
• if that value is 10, the character becomes X

Only if the entered 7th character matches this calculated character is the item valid.

If valid, only the first 6 characters are stored in the queue, not the full 7-character string.

Understanding the Question

The subroutine must do all of the following:

• read exactly 10 inputs from the user
• calculate the correct check digit for each input
• compare it with the entered 7th character
• if valid, remove the check digit and try to store the first 6 characters using Enqueue()
• output a message if inserted
• output a message if the queue is already full
• not store invalid items
• count how many invalid items were entered
• output that count at the end

Notice the difference between invalid data and a full queue:

• invalid data fails the check-digit test
• a full queue means the data may be valid, but there is no space left to store it

Those are separate cases.

Approach

A good structure is:

1. Set an Invalid counter to 0.
2. Repeat 10 times.
3. Read a 7-character string.
4. Process the first 6 characters one by one.
5. Multiply by 1 or 3 depending on whether the index is even or odd.
6. Use integer division by 10 to get the check value.
7. Convert 10 to X, otherwise convert the number to a string.
8. Compare with character position 6.
9. If valid, call Enqueue() with the first 6 characters.
10. If invalid, increment the counter.
11. At the end, print the number of invalid items.

Using Index % 2 is a neat way to decide whether the position is even or odd.

Step-by-Step Reasoning

Invalid = 0

• starts the count of invalid inputs

for Count in range(10):

• repeats exactly 10 times, because the question says ten inputs are taken

Item = input("Enter data")

• reads one 7-character string

Total = 0

• initialises the running total for the weighted products

for Index in range(6):

• processes positions 0 to 5, which are the six data digits

Digit = int(Item[Index])

• converts the current character into a number so arithmetic can be performed

if Index % 2 == 0:

• even positions are 0, 2, 4

Total += Digit

• multiplier 1 is implied

else:

• odd positions are 1, 3, 5

Total += Digit * 3

• applies multiplier 3

CheckDigit = Total // 10

• // is integer division in Python, so it discards any remainder
• that matches the instruction to round down

if CheckDigit == 10:
CheckCharacter = "X"
else:
CheckCharacter = str(CheckDigit)

• converts the calculated value into the character that should appear in position 6

if Item[6] == CheckCharacter:

• checks whether the input is valid

if Enqueue(Item[:6]):

• only the first 6 characters are stored
• Item[:6] means characters at positions 0 to 5

print("Inserted item")

• printed when the valid data is successfully stored

print("Queue is full")

• printed if the data is valid but there is no room in the queue

else: Invalid += 1

• invalid inputs are counted and not stored

Finally:

print("There were", Invalid, "Invalid items")

• outputs the total number of invalid entries after all 10 inputs have been processed

Key Takeaways

• Check-digit validation is a systematic way to test entered data.
• Positional weighting often depends on even and odd index values.
• Integer division is useful when the algorithm says to round down.
• Validation and storage are separate tasks: validate first, then enqueue.

Common Mistakes

• Including the 7th character in the checksum calculation instead of only the first 6 digits.
• Using normal division / without converting to an integer, which gives a real number.
• Forgetting the special case where check digit 10 becomes X.
• Storing the full 7-character string instead of removing the check digit first.
• Counting full-queue cases as invalid inputs, which they are not.

Things to Be Careful About

• Python string indexing starts at 0, so the check character is Item[6].
• range(6) processes positions 0 to 5; range(7) would be wrong here.
• The queue stores strings, so the calculated check digit must be converted to a string before comparison.
• The queue-full message is only for valid items that cannot be inserted because the queue has no space.

Background Concept

The main program coordinates the smaller subroutines. Here, the main program must:

• fill the queue by calling StoreItems()
• remove one item by calling Dequeue()
• react appropriately depending on whether a real item was returned

Because Dequeue() may return either a stored item or the sentinel string "false", the main program must test that return value before deciding what to print.

Understanding the Question

This part does not ask you to rewrite the whole program. It only asks you to amend the main program so that it:

• calls StoreItems()
• calls Dequeue()
• outputs a message if the queue is empty
• otherwise outputs the returned value

The important clue is that Dequeue() returns "false" when empty, so the main program must compare against that exact value.

Approach

Use a simple sequence:

1. Call StoreItems().
2. Save the result of Dequeue() in a variable.
3. Use an if statement.
4. If the result is "false", print an empty-queue message.
5. Otherwise print the item code.

Saving the return value first makes the test and the output easy.

Step-by-Step Reasoning

StoreItems()

• runs the input and validation routine
• after this call, all valid items that fitted in the queue have been enqueued

ItemCode = Dequeue()

• removes the next item from the queue, if there is one
• stores the returned value so it can be tested and printed

if ItemCode == "false":

• checks the sentinel value returned by Dequeue() when the queue is empty

print("Queue is empty")

• prints a suitable message for that case

else:

• this means a real item was returned

print("Item code", ItemCode)

• prints the dequeued value

That exactly matches the required behaviour.

Key Takeaways

• The main program often just links together previously written subroutines.
• A function's return value should usually be stored in a variable before testing it.
• Sentinel values let the caller detect special conditions such as an empty queue.

Common Mistakes

• Calling Dequeue() without storing the returned value, then having nothing to test or print.
• Comparing with Python False instead of the required string "false".
• Printing the item even when the queue was empty.
• Forgetting to call StoreItems() before Dequeue().

Things to Be Careful About

• The required empty value is the string "false", not a Boolean.
• The message can be any suitable wording, but it must clearly show the empty-queue case.
• StoreItems() must be called before Dequeue(), otherwise the queue will still be empty unless something else has already inserted data.

Background Concept

A test run of a queue program is really a trace of two linked processes:

• input validation using the check-digit algorithm
• queue behaviour using FIFO order

Each 7-character input is first validated. If valid, the first 6 characters are enqueued. After all ten inputs, the program prints the number of invalid items, then Dequeue() removes the first valid item that was inserted.

Because queues are first-in, first-out, the earliest valid item entered will be the one returned at the end.

Understanding the Question

This part gives a fixed set of ten inputs and asks for the output that would appear on screen.

So you must work through:

1. which inputs are valid
2. which ones print Inserted item
3. how many are invalid
4. what value Dequeue() returns after StoreItems() finishes

The screenshot in the marking material confirms that no individual message is printed for an invalid item; the program just moves on to the next input.

Approach

For each input:

• use the first 6 digits to calculate the check character
• compare it with the 7th character
• if they match, the first 6 digits are stored in the queue and Inserted item is printed
• if they do not match, the item is counted as invalid

At the end:

• output the invalid total
• remove and output the first queued item

A small table is the easiest way to keep track.

Step-by-Step Reasoning

Here is the validation trace:

So the valid items are enqueued in this order:

1. 999999
2. 125148
3. 550021
4. 984578
5. 811102
6. 756855

There are 4 invalid items:

• 0033585
• 6666666
• 3258746
• 0012353

After StoreItems() finishes, the program prints:

• There were 4 Invalid items

Then Dequeue() removes the first queued item. Because the queue is FIFO, that is 999999.

So the final output line is:

• Item code 999999

That gives the complete console output shown in the answer.

Key Takeaways

• When tracing a program like this, separate the validation stage from the queue stage.
• FIFO means the first valid inserted item is the first one removed.
• A final output line often depends on all earlier queue operations, not just the last input.

Common Mistakes

• Treating 999999X as invalid because the check character is a letter. In fact, 10 must be replaced by X, so it is valid.
• Storing the full 7-character input instead of just the first 6 characters.
• Counting only failed insertions and forgetting to count invalid inputs.
• Returning the most recent valid item instead of the first valid item when tracing Dequeue().

Things to Be Careful About

• The prompt and the user's typed input appear on the same line because input("Enter data") displays the prompt before the user types.
• No queue-full message appears in this test because only 6 valid items are inserted into a queue of size 20.
• The case of Invalid in the final printed message should match the program output shown here.