Computer Science 9618/42 — October/November 2023

Background Concept

A stack is a last-in, first-out data structure. In this question, each stack is being implemented using a 1D array. That means we reserve storage first, then use a separate pointer to keep track of where the next item should go.

In Python, there is no built-in fixed-size array in the same sense used by exam questions, so the usual exam approach is to use a list of the required size and add a comment to show the intended declaration. Because the arrays must store up to 100 letters and the first index is 0, the valid positions are 0 to 99.

Understanding the Question

This part only asks for the two global arrays, not the pointers and not any procedures yet. The key details are:

• there are two stacks
• each is a 1D array
• each must hold 100 letters
• indexing starts at 0
• Python answers should include declaration comments

So the job here is to create storage for both stacks in global scope.

Approach

The simplest Python representation is a list with 100 elements already created. That matches the exam idea of a fixed-size array. A blank string is a suitable placeholder value for each unused position.

Because the question specifically mentions global arrays, the declarations should be written outside any function or procedure.

Step-by-Step Reasoning

First, create the vowel stack storage:

• the name must be StackVowel
• it must be global
• it must have 100 positions
• a Python list of [''] * 100 gives exactly 100 string slots

Then do the same for the consonant stack:

• the name must be StackConsonant
• it must also have 100 positions

The comments are included because the paper explicitly says Python candidates should show declarations using comments. That helps show the examiner that you understand these are intended as fixed-size global arrays, not just ordinary variable-length lists.

Key Takeaways

• A stack can be implemented using a 1D array plus a pointer.
• If indexing starts at 0 and there are 100 items, the last valid index is 99.
• In Python practical papers, declaration comments are often used to show intended data structures.

Common Mistakes

• Declaring only one array instead of both arrays.
• Creating empty lists with no size, which does not match the fixed-size array requirement as clearly.
• Using 1 to 100 as the index range even though the question says the first index is 0.
• Putting the arrays inside a function, which would make them local instead of global.

Things to Be Careful About

• Use the exact names StackVowel and StackConsonant.
• Make sure each list has 100 elements, not 99 or 101.
• In Python, the comment is not a substitute for the actual list creation; you should show both the declaration comment and the usable storage.

Background Concept

When a stack is implemented with an array, a pointer is needed to track the current top position. In this question, the pointer does not store the index of the current top item. Instead, it stores the index of the next free space. That is an important detail.

If the next free space is 0, the stack is empty because no items have been placed yet. After one push, the item is stored at index 0 and the pointer becomes 1.

Understanding the Question

This part tells you exactly what the two global variables mean:

• VowelTop stores the next free position in StackVowel
• ConsonantTop stores the next free position in StackConsonant
• both start at 0

So you are not choosing a design here; you are implementing the pointer design the question gives you.

Approach

Declare each pointer as a global integer variable and set it to 0. In Python, include comments to show the declaration type, because Python itself does not require type declarations.

Step-by-Step Reasoning

VowelTop = 0 means the vowel stack is empty and the first vowel pushed will go into index 0.

ConsonantTop = 0 means the consonant stack is also empty and the first consonant pushed will go into index 0.

These variables must be global because later procedures and functions such as PushData(), PopVowel() and PopConsonant() all need to update them.

Key Takeaways

• A stack pointer can represent the next free slot rather than the current top item.
• An empty stack is often represented by pointer value 0 when using 0-based indexing and next-free-space logic.
• Global state is needed here because multiple routines share the same stacks and pointers.

Common Mistakes

• Setting the pointers to -1, which would be a different stack design from the one described.
• Forgetting that the variables must be global.
• Initialising one pointer but not the other.

Things to Be Careful About

• Use the exact variable names and casing from the question.
• Keep the meaning of the pointer consistent throughout the whole program: next free space, not current top item.
• If later code assumes a different meaning for the pointer, the push and pop logic will not match.

Background Concept

A push operation adds an item to the top of a stack. With an array-based stack, that means:

1. check whether there is space
2. store the item at the next free position
3. move the pointer on to the next free position

Because this question has two stacks, the procedure must first decide which stack the letter belongs in. The question defines vowels as a, e, i, o, u, and everything else is treated as a consonant. It also says you do not need to validate whether the input is actually a letter.

Understanding the Question

PushData() receives one lower-case character. If it is a vowel, it must go into StackVowel. Otherwise it must go into StackConsonant.

For either stack, if it is full, the program must output a suitable message instead of writing beyond the end of the array.

The parent stem matters here because:

• both arrays are global and size 100
• both pointers start at 0
• the pointer stores the next free space

Approach

Use a membership test to decide whether the character is a vowel. Then, for the chosen stack:

• test whether the top pointer is still below 100
• if so, store the letter at that index
• increment the pointer
• otherwise output a full-stack message

This is the standard array-based push pattern.

Step-by-Step Reasoning

The procedure needs global VowelTop, ConsonantTop because those values must be changed permanently, not just inside the function.

The condition Letter in ['a', 'e', 'i', 'o', 'u'] separates vowels from consonants.

If it is a vowel:

• VowelTop < 100 checks whether there is room
• if true, store the letter in StackVowel[VowelTop]
• then do VowelTop += 1

That order matters. Because the pointer stores the next free space, the item goes into the current pointer position first, and only then does the pointer move up.

If VowelTop is already 100, the stack is full. The last valid index is 99, so 100 means there is no free space left.

The consonant branch is exactly the same idea but uses StackConsonant and ConsonantTop.

A strong exam answer keeps the two branches parallel so the logic is easy to follow and easy to mark.

Key Takeaways

• Push on an array-based stack means store first, then increment the next-free pointer.
• Overflow must be checked before writing to the array.
• When two similar data structures exist, it is often best to write matching logic for both.

Common Mistakes

• Incrementing the pointer before storing the letter, which skips index 0 and misplaces every later item.
• Testing <= 100 instead of < 100, which allows an attempt to write to index 100.
• Forgetting the global declaration in Python, so the pointer update does not affect the real stack.
• Using a vowel test that misses one of the vowels.

Things to Be Careful About

• The pointer represents the next free slot, not the current top element.
• The full condition is when the pointer reaches 100, because indices run from 0 to 99.
• The question says lower-case letters, so a lower-case vowel check is sufficient.
• You do not need input validation here, so do not waste time adding it unless you are certain it will not break the required logic.

Background Concept

Sequential file processing means reading a file one item after another from start to end. Here, StackData.txt contains 100 lower-case letters, one per line. A typical routine must:

• open the file
• read each line
• convert the raw line into the required data item
• process that item
• close the file

Exception handling is used so the program does not crash if the file is missing. In Python, attempting to open a file that does not exist raises FileNotFoundError.

Understanding the Question

This part does not ask you to decide which stack to use. That logic is already inside PushData(). ReadData() only needs to:

• read the letters from StackData.txt
• pass each letter to PushData()
• use appropriate exception handling if the file does not exist

So the key idea is delegation: reading is done here, stack classification is done in the other procedure.

Approach

Put the file opening and reading inside a try block. Read each line in turn, remove the newline using strip(), then send the cleaned letter to PushData(). If opening the file fails, catch the exception and print a suitable message.

Step-by-Step Reasoning

File = open('StackData.txt', 'r') opens the source file for reading.

for Line in File: loops through every line in order. Since the file stores one lower-case letter per line, each iteration represents one letter.

Letter = Line.strip() removes the newline character. Without this, the value passed to PushData() would be something like 'a\n' rather than 'a', which would break the vowel test.

PushData(Letter) then pushes the cleaned character onto the correct stack.

File.close() closes the file once reading has finished.

If the file cannot be opened, control moves to the except FileNotFoundError: block, and the program outputs a suitable message instead of stopping with an error.

Key Takeaways

• Read sequential text files one line at a time when each line holds one item.
• Clean line-based input before processing it.
• Use exception handling to make file operations safe.
• Keep routines focused: one routine reads data, another decides where to store it.

Common Mistakes

• Forgetting to remove the newline from each line.
• Reading the file but never calling PushData().
• Omitting exception handling, so the program crashes if the file is missing.
• Using the wrong filename or wrong file mode.

Things to Be Careful About

• The filename must match exactly: StackData.txt.
• strip() is important here because each line ends with a line break.
• If you use explicit open(), remember to close the file after reading.
• The question says the file stores 100 letters, but a loop that reads until the file ends is still appropriate and safe.

Background Concept

The main program is the control section that coordinates previously written routines. In this question, the main program does not implement stack operations directly. Instead, it:

• loads the stacks from the file
• asks the user which stack to pop from
• calls the appropriate pop function
• stores successful results
• stops only after 5 letters have been successfully returned

The phrase successfully returned is important. It means the count should only increase when a real letter is obtained, not when the function returns No data.

Understanding the Question

The order of actions is given very clearly:

1. call ReadData() first
2. prompt and input the user's choice
3. depending on that choice, call PopVowel() or PopConsonant() and store the returned value
4. repeat until 5 letters have been successfully returned and stored
5. if a stack is empty, output an appropriate message
6. after 5 successful letters, output them on one line

So this is a loop-control problem as much as it is a stack problem.

Approach

A good structure is:

• call ReadData() once at the start
• create a list to store returned letters
• use a while loop that continues until the list length is 5
• inside the loop, get the user's choice
• call the correct pop function
• if the return value is No data, print an empty-stack message and do not store it
• otherwise append the letter to the list
• after the loop, join the five letters into one string and print it

Step-by-Step Reasoning

ReadData() must happen before any popping, otherwise both stacks would still be empty.

ReturnedLetters = [] creates a place to store the successful results in order.

while len(ReturnedLetters) < 5: makes the loop continue until exactly 5 successful letters have been stored. This is better than repeating 5 times, because an empty-stack result must not count.

Choice = input('Enter vowel or consonant: ') gets the user's instruction.

If the choice is vowel, the program calls PopVowel(). The returned value is stored in Letter.

Then the program checks whether Letter == 'No data'.

• If yes, the vowel stack is empty, so a message is output.
• If no, a real letter was returned, so it is appended to ReturnedLetters.

The consonant branch works the same way with PopConsonant().

Finally, print(''.join(ReturnedLetters)) outputs the 5 collected letters on one line with no spaces, which matches the format shown in the question.

A slightly more defensive program could also handle invalid input, but the question does not require that, so a clean if/elif answer is sufficient.

Key Takeaways

• Count successful outcomes, not just loop iterations, when failure is possible.
• Keep stack logic inside the pop functions and use the main program only for control flow.
• Build a final string by collecting characters in order and joining them.

Common Mistakes

• Using a loop that repeats exactly 5 times even if some pops return No data.
• Forgetting to call ReadData() before the loop.
• Appending No data to the result list instead of rejecting it.
• Printing each letter separately instead of one combined line at the end.

Things to Be Careful About

• Compare with the exact string No data.
• Only append when a real letter is returned.
• The final output must be one line, so joining the list is a good Python approach.
• If you use else instead of elif, be sure you are not accidentally treating every non-vowel input as consonant unless that is your intended design.

Background Concept

To predict the output of a stack program, you must remember that stacks are last-in, first-out. The most recently pushed item is the first one popped.

Because ReadData() reads the file from top to bottom and pushes each letter onto its appropriate stack, the top of each stack will contain the last matching letter found in the file.

Understanding the Question

This part is not asking for new code. It is asking you to run the finished program using these five choices:

• vowel
• consonant
• consonant
• vowel
• vowel

So we must work out exactly which letters those five pop operations return after the file has been loaded.

Approach

Split the file contents into two conceptual stacks:

• all vowels in the order they are read
• all consonants in the order they are read

Then reverse your thinking for popping, because the last item pushed is on top.

Take the five choices one by one and record each returned character.

Step-by-Step Reasoning

From StackData.txt, the last few vowels read are:

• ... i, u, e, o, u

So after all pushes, the top of the vowel stack is the final u, then below it o, then below that e.

The last few consonants read are:

• ... g, j, k, n, c, s, x

So the top of the consonant stack is x, then below it s, then below that c.

Now apply the required inputs in order.

1. vowel → pop from vowel stack → returns u
2. consonant → pop from consonant stack → returns x
3. consonant → pop from consonant stack again → returns s
4. vowel → next vowel pop → returns o
5. vowel → next vowel pop → returns e

So the five returned letters are:

• u
• x
• s
• o
• e

Joined together on one line, the output is uxsoe.

No empty-stack message appears in this test because both stacks still contain plenty of data.

Key Takeaways

• For stack tracing, always find the last matching items read from the file.
• A mixed input sequence can alternate between two separate stacks.
• The final displayed string is the successful pop results in the order they were returned.

Common Mistakes

• Reading from the start of the file instead of from the top of the stack when predicting pops.
• Mixing vowel and consonant order together instead of treating them as separate stacks.
• Forgetting that the result is output as one combined line, not as separate letters.

Things to Be Careful About

• Use the final loaded stack contents, not the original file order, when deciding pop results.
• After one pop, the next item from that same stack becomes the new top.
• The exact output shown depends on the prompt text in your program, but the key returned string here is uxsoe.