Computer Science 9618/23 — May/June 2025

Background Concept

A module is a separate section of a program that performs one clear task. In Cambridge pseudocode, modules are usually written as procedures or functions. Using modules is part of decomposition: breaking a large problem into smaller, manageable parts.

This is useful because a large program is easier to design, build and check when each part has a specific purpose. For example, one module might input booking details, another might calculate cost, and another might print a confirmation.

Common advantages of modules include:

• easier testing because each module can be checked on its own
• easier debugging because faults are isolated to one section
• easier maintenance because changes are made in one place
• reusability because the same module can be called from different places
• clearer structure and readability

Understanding the Question

The question says the programmer chooses to use modules in the sports centre program and asks for two reasons for that decision. This is not asking for definitions of procedure and function. It is asking why modular design is a good idea.

So the task is to name two valid benefits of modular programming. Any two correct reasons would usually gain the marks.

Approach

Think of what modules help with during software development:

1. building the program
2. checking the program
3. changing the program later
4. avoiding repeated code

Choose two strong, distinct reasons. The safest answers are usually testing/debugging and maintenance/reuse.

Step-by-Step Reasoning

A good answer needs two separate benefits.

First reason: each module can be tested independently. That means if there is a problem in one part, the programmer can run and inspect just that part instead of searching through the whole program.

Second reason: modules can be reused and maintained more easily. If the same task is needed in more than one place, the programmer writes it once and calls it when needed. If a change is required later, only that module needs editing.

These are both standard, accepted reasons for using procedures or functions.

Key Takeaways

• Modules are used to break a large problem into smaller parts.
• Modular programs are easier to test, debug, maintain and reuse.
• When asked for reasons, give distinct benefits rather than repeating the same idea in different words.

Common Mistakes

• Giving a definition instead of a reason, such as "a function returns a value". That is true, but it does not explain why modules are useful here.
• Repeating the same point twice, such as "easier to test" and "easier to debug" without making it clear they are different benefits.
• Talking about local variables or global variables here instead of modules. That belongs to later parts.

Things to Be Careful About

• The question asks specifically about modules, so keep the answer focused on modular design.
• Make sure the two reasons are separate enough to count as two marking points.
• Use concise statements; this is a short recall question, not a long explanation.

Background Concept

A variable stores data in a program. One important idea is scope, which means where in the program that variable can be accessed.

• A local variable is declared inside a procedure or function and can only be used there.
• A global variable is declared outside the modules and can be used by many or all parts of the program.

So the main difference is visibility across the program.

Understanding the Question

The question asks for one difference between local and global variables. Only one clear distinction is needed.

The simplest and strongest difference is scope: where each variable can be accessed.

Approach

Use the most fundamental contrast:

• local = only inside one module
• global = available across the whole program

This is better than giving a vague statement like "local variables are safer" because the question asks for a difference, not a benefit.

Step-by-Step Reasoning

A local variable belongs to the procedure or function where it is declared. Other modules cannot directly use it.

A global variable is declared in a wider scope, so different modules can access it.

That gives a complete one-mark answer.

Key Takeaways

• Scope means where a variable is available.
• Local variables have limited scope.
• Global variables have program-wide scope.

Common Mistakes

• Saying "local variables are inside the program" and "global variables are outside the program". That wording is inaccurate.
• Giving a benefit instead of a difference, for example "local variables are easier to debug".
• Confusing scope with data type.

Things to Be Careful About

• Use the word access or scope clearly.
• Do not overcomplicate the answer; one precise sentence is enough.
• Make sure the contrast is direct: local versus global.

Background Concept

Local variables are variables declared inside a single procedure or function. They are created for use within that module only and are not directly available elsewhere.

Because their scope is limited, they help control how data is used in a program. This often makes a program safer and easier to manage.

Typical benefits of local variables include:

• preventing other modules from changing them accidentally
• reducing unwanted side effects
• allowing the same variable names to be reused in different modules
• only using memory when the module is active

Understanding the Question

This part asks for two benefits of using local variables, not just a difference between local and global variables.

So you should explain why local variables are a good design choice.

Approach

Choose two distinct benefits. Strong answers usually focus on:

1. safety and control of data
2. efficient use of memory

These are clear, separate points and are widely accepted.

Step-by-Step Reasoning

First benefit: a local variable can only be accessed in its own module. That means another module cannot accidentally alter its value. This reduces errors caused by one part of the program interfering with another.

Second benefit: local variables usually exist only while that module is running. Once the module finishes, that storage is no longer needed. This means memory is used more efficiently than keeping many values available globally all the time.

Other valid benefits may exist, but these two are direct and easy to mark.

Key Takeaways

• Local variables improve control because their scope is limited.
• They help avoid unintended changes from other modules.
• They can improve memory efficiency because they are only needed temporarily.

Common Mistakes

• Repeating the same idea twice, such as "safer" and "more secure", without explaining the difference.
• Giving benefits of modules instead of benefits of local variables.
• Saying simply "they are easier" without stating what is easier and why.

Things to Be Careful About

• Make sure each benefit is distinct.
• Link the benefit directly to the fact that the variable is local.
• Keep the answer focused on variables, not on procedures or functions in general.

Background Concept

A stack is an Abstract Data Type that works on the LIFO principle: Last In, First Out. The most recently added item is the first one removed. In an array-based stack, items are stored in consecutive memory locations, and a pointer such as TopOfStack stores the location of the current top item.

The bottom item is the one that has been in the stack the longest. In a full or partly full stack stored from lower addresses upwards, that oldest item is found at the lowest occupied memory location. A PUSH operation adds a new item above the current top and moves TopOfStack up by one location.

Understanding the Question

The diagram shows a stack stored in memory locations 400 to 409. The values currently stored are at 400, 401, 402 and 403, and TopOfStack points to 403.

You are asked for two things:

1. which memory location holds the value that has been on the stack the longest
2. how many consecutive PUSH operations are needed before TopOfStack becomes 409

So this is really a question about reading the current stack layout and understanding how the top pointer moves.

Approach

First, identify the oldest item by looking for the bottom occupied location of the stack.

Then, for the number of pushes, count how many higher locations are still available above the current top location 403 until you reach 409. Each push moves the pointer up by exactly one location.

Step-by-Step Reasoning

The occupied locations are:

• 400 contains B
• 401 contains D
• 402 contains X
• 403 contains P

Because a stack is LIFO, the value that has been on the stack the longest is the one at the bottom, not the one at the top. The bottom occupied location is 400, so that is the first answer.

Now consider the pushes.

Currently TopOfStack = 403.

Each push would move it to:

• 404 after 1 push
• 405 after 2 pushes
• 406 after 3 pushes
• 407 after 4 pushes
• 408 after 5 pushes
• 409 after 6 pushes

So 6 consecutive pushes are needed.

Key Takeaways

• In a stack, the oldest item is at the bottom.
• TopOfStack points to the most recently added current item.
• In an array implementation, one push usually moves the top pointer by one position.
• Counting free spaces above the current top tells you how many more pushes are possible before reaching a given location.

Common Mistakes

• Choosing 403 as the oldest item because it is pointed to by TopOfStack. That is wrong because 403 is the newest current item, not the oldest.
• Counting memory locations incorrectly and giving 5 instead of 6. You must count 404, 405, 406, 407, 408 and 409.
• Forgetting that 409 itself is included in the count because the question asks when TopOfStack will contain 409.

Things to Be Careful About

• Distinguish between the bottom of the stack and the top of the stack.
• Read the memory addresses carefully: they increase upwards in this diagram.
• Do not count occupied locations already below the current top; only count the available positions above 403 up to 409.

Background Concept

A stack uses the LIFO rule: Last In, First Out. The two main operations are:

• PUSH: add a new item to the top of the stack, then move TopOfStack up
• POP: remove the current top item, then move TopOfStack down

When a stack is implemented using an array, the items occupy consecutive positions. The TopOfStack pointer tells you where the current top item is stored. To answer questions like this, the safest method is to trace each operation one by one in order.

Understanding the Question

You are given the current stack contents:

• 400: D
• 401: R
• 402: S
• 403: B
• 404: K
• 405: F
• 406: C
• 407: A
• TopOfStack = 407

Then the following operations are carried out:

• PUSH 'T'
• POP
• POP
• PUSH 'Z'
• PUSH 'X'
• POP
• PUSH 'Y'

The question wants the final stack state after all these have happened, not the intermediate states.

Approach

Start from the given stack and process each instruction in sequence. After each PUSH, add the new value above the old top and move the pointer up. After each POP, remove the current top item and move the pointer down.

This is a classic dry-run question: accuracy comes from doing one operation at a time and not trying to jump straight to the result.

Step-by-Step Reasoning

Initial state:

• 400 D
• 401 R
• 402 S
• 403 B
• 404 K
• 405 F
• 406 C
• 407 A
• TopOfStack = 407

Now apply the operations.

1. PUSH 'T'

   • New top becomes 408
   • 408 stores T

2. POP

   • Remove top item T
   • Top moves back to 407

3. POP

   • Remove top item A
   • Top moves back to 406

4. PUSH 'Z'

   • New top becomes 407
   • 407 stores Z

5. PUSH 'X'

   • New top becomes 408
   • 408 stores X

6. POP

   • Remove top item X
   • Top moves back to 407

7. PUSH 'Y'

   • New top becomes 408
   • 408 stores Y

So the final contents are:

• 400 D
• 401 R
• 402 S
• 403 B
• 404 K
• 405 F
• 406 C
• 407 Z
• 408 Y
• 409 empty
• TopOfStack = 408

Key Takeaways

• Always process stack operations in the exact order given.
• A PUSH adds a new top item; a POP removes the current top item.
• Tracking the top pointer is just as important as tracking the values.
• Dry-running step by step is the best method for ADT trace questions.

Common Mistakes

• Forgetting that the first POP removes T, not A, because T was just pushed.
• Removing too many values by treating POP as clearing more than one item.
• Leaving A in location 407 at the end. It was popped and later replaced by Z.
• Leaving X in 408 at the end. It was pushed and then immediately popped before Y was pushed.

Things to Be Careful About

• Do not reorder the operations.
• Update TopOfStack after every push or pop.
• If a value is popped, it is no longer part of the final stack state even if it was there earlier.
• The final diagram must show both the correct values and the pointer in the correct position.

Background Concept

In a linked list implemented using an array of records, each record usually contains two fields:

• a data field, which stores the actual item
• a pointer field, which stores the index of the next item in the logical list

This is important: the logical order of a linked list does not have to match the physical order of the array. The items can sit anywhere in the array, and the pointers link them together in the required order.

A pointer value of -1 means there is no next item, so that node is the end of the list.

Understanding the Question

You are given six array entries, each with an index and a planet name. The data values are not already in alphabetical order in the table.

You must complete the pointer field so that when the linked list is followed from the first item to the last, the planet names appear in alphabetical order.

So the task is not to move the data. The task is to leave the data where it is and make the pointers create the correct order.

Approach

First, list the planet names in alphabetical order. Then note the index of each of those names in the original table. Finally, make each record point to the index of the next name in that alphabetical sequence. The last item must point to -1.

Step-by-Step Reasoning

The data values and indices are:

• 0: Neptune
• 1: Jupiter
• 2: Saturn
• 3: Earth
• 4: Mercury
• 5: Uranus

Alphabetical order is:

1. Earth
2. Jupiter
3. Mercury
4. Neptune
5. Saturn
6. Uranus

Now replace each name with its array index:

• Earth = 3
• Jupiter = 1
• Mercury = 4
• Neptune = 0
• Saturn = 2
• Uranus = 5

So the linked order of indices is:

3 → 1 → 4 → 0 → 2 → 5 → -1

Now fill the pointer field for each row:

• index 3 points to 1
• index 1 points to 4
• index 4 points to 0
• index 0 points to 2
• index 2 points to 5
• index 5 points to -1

Written in row order of the table, the pointers are:

• 0: 2
• 1: 4
• 2: 5
• 3: 1
• 4: 0
• 5: -1

Key Takeaways

• In a linked list, logical order is controlled by pointers, not by physical row order.
• For an array-based linked list, the pointer stores the index of the next node.
• To build a linked list in a required order, first decide the logical sequence, then assign pointer values.
• -1 is commonly used to mark the end of the list.

Common Mistakes

• Rewriting the data items into alphabetical order in the table instead of changing only the pointers.
• Using the planet name itself as the pointer instead of the index.
• Forgetting that the final node must point to -1.
• Giving the pointers in alphabetical sequence order but putting them into the wrong table rows.

Things to Be Careful About

• Always distinguish between index position and stored data.
• Fill the pointer for every row, not just the first few nodes.
• Make sure each pointer refers to the next node's index, not the current node's own index.
• Check that a full traversal from the start reaches every item exactly once and ends with -1.

Background Concept

In a linked list, StartPointer stores the index of the first node in the list. It is the entry point used to begin traversal. Once the first index is known, the rest of the list is found by following the pointer field from one node to the next.

Understanding the Question

This part refers directly to the linked list created in the previous part. You have already arranged the items so that the list is in alphabetical order.

Now you must state the value of StartPointer, which means: which index contains the first item in that linked list?

Approach

Look at the alphabetical order you established and identify the very first item. Then take the index of that item. That index is the StartPointer.

Step-by-Step Reasoning

From part (b)(i), the alphabetical order is:

Earth → Jupiter → Mercury → Neptune → Saturn → Uranus

The first item is Earth.

In the table, Earth is stored at index 3.

Therefore:

StartPointer = 3

Key Takeaways

• StartPointer always holds the index of the first node in the logical list.
• To find it, identify the first item in the linked sequence, not the first row of the table.

Common Mistakes

• Giving 0 because it is the first array index. That is wrong because linked lists use logical order, not physical row order.
• Giving 1 because Jupiter comes early alphabetically, but Earth comes before Jupiter.
• Forgetting that this answer depends on the pointer sequence from part (b)(i).

Things to Be Careful About

• Do not confuse the first row in the array with the first node in the list.
• Use the index of the first item, not its data value.
• Check the alphabetical order carefully before deciding the start node.

Background Concept

A module that changes values and needs those changed values to still be available after the call should usually be written as a PROCEDURE with BYREF parameters. BYREF means the original variables are passed in such a way that any change made inside the procedure affects the variables outside the procedure as well.

This question also uses selection. Selection means the algorithm makes a decision using IF ... THEN ... ELSE ... ENDIF. Here the decision is based on whether two dates fall in the same month.

The final important idea is that date values can be processed by extracting parts from them, for example the month. Once the condition has been checked, the stored last visit date must be updated to today's date.

Understanding the Question

You are asked to write the module UpdateVisit(). The parent stem tells you exactly what the module must do:

• it receives two items: loyalty points and last visit date
• if the customer's last visit was in the same month as the current date, add 4 points
• otherwise add 1 point
• then replace the old last visit date with the current date
• the changed values must still exist after the module finishes

That last bullet is the key clue that the parameters must be passed BYREF.

Approach

The clean way to solve this is:

1. Write UpdateVisit as a PROCEDURE, not a function, because it is updating existing values.
2. Pass both parameters BYREF so the calling code sees the new points and new date.
3. Get the current date and store it in a local variable.
4. Compare the month from LastVisitDate with the month from CurrentDate.
5. Add either 4 or 1 to the loyalty points.
6. Set LastVisitDate to CurrentDate.

Step-by-Step Reasoning

The procedure header is:

• PROCEDURE because the module's job is to update values.
• BYREF LoyaltyPoints : INTEGER because the points value is changed.
• BYREF LastVisitDate : DATE because the stored date is also changed.

A local date variable is useful so the current date is obtained once and then reused:

• DECLARE CurrentDate : DATE
• CurrentDate ← TODAY

The decision is then made with an IF statement:

• if the month part of LastVisitDate matches the month part of CurrentDate, add 4
• otherwise add 1

That gives:

• IF MONTH(LastVisitDate) = MONTH(CurrentDate) THEN
• LoyaltyPoints ← LoyaltyPoints + 4
• ELSE
• LoyaltyPoints ← LoyaltyPoints + 1
• ENDIF

Finally, once the visit has been processed, the most recent visit date must become today's date:

• LastVisitDate ← CurrentDate

That last assignment is essential. Without it, the next visit would still be compared against an out-of-date last visit.

Key Takeaways

• Use a PROCEDURE with BYREF when a module must change variables permanently.
• Use selection to choose between two update rules.
• When a date-based rule is given, extract and compare the relevant part of the date.
• Always complete every stated task in the module description, including updating stored values.

Common Mistakes

• Using a FUNCTION instead of a PROCEDURE when no returned single result is required.
• Passing parameters BYVAL, which would stop the changed values being available after the call.
• Forgetting to update LastVisitDate to the current date.
• Adding the wrong number of points in one of the branches.
• Comparing the whole date instead of the month when the rule only depends on the month.

Things to Be Careful About

• The question says the changed values must be available after the call, so BYREF is important.
• Keep the parameter names and types consistent with the stem: INTEGER for points and DATE for the last visit date.
• Use proper CIE pseudocode syntax: ← for assignment, upper-case keywords, and ENDIF/ENDPROCEDURE.
• Make sure CurrentDate is declared before it is used.

Background Concept

A condition in pseudocode is a Boolean test that evaluates to either true or false. When a rule depends on the day of the week, the algorithm should not compare the numeric day of the month such as 05 or 12; it should compare the weekday value, such as Monday, Tuesday, and so on.

This is another use of selection. The test goes inside an IF statement, and if the condition is true, the extra action happens.

Understanding the Question

This part says the module is being amended so that loyalty points are increased further if the customer visits on the same day of the week as their last visit.

The important phrase is "same day of the week". That means:

• look at the current visit date
• look at the previous visit date
• compare their weekday values

Because this part is only worth 1 mark, the key requirement is the condition itself.

Approach

Use a date function that returns the weekday for each date, then compare the two results with = inside an IF statement.

The logic is:

• weekday of current visit
• weekday of previous visit
• if they match, the extra increase rule applies

Step-by-Step Reasoning

The existing procedure already has access to:

• CurrentDate
• LastVisitDate

So the simplest test is:

• DAY_OF_WEEK(CurrentDate) gives the weekday for today
• DAY_OF_WEEK(LastVisitDate) gives the weekday for the previous visit
• if the two are equal, the new condition is true

That produces:

IF DAY_OF_WEEK(CurrentDate) = DAY_OF_WEEK(LastVisitDate) THEN
   // further increase loyalty points
ENDIF

Since the question does not specify the extra number of points to add, the essential credited part is the correct condition comparing the two weekdays.

Key Takeaways

• "Same day of the week" means compare weekday values, not day numbers.
• A one-mark pseudocode condition is usually testing whether you can form the correct Boolean expression.
• Reuse existing variables when the module already contains the dates you need.

Common Mistakes

• Comparing DAY(CurrentDate) with DAY(LastVisitDate) instead of weekday values.
• Comparing the month instead of the weekday.
• Using the current customer ID or the text string when the condition should be based on dates.
• Adding an arbitrary bonus amount even though this part only asks for the condition.

Things to Be Careful About

• Keep the condition in valid pseudocode form with IF ... THEN.
• Use the same date variables already used in the module.
• Do not confuse CurrentDate with LastVisitDate.
• If you include an action inside the IF, make sure it is only the extra increase and not a repeat of the earlier month-based update.

Background Concept

A FUNCTION is used when a module must return a single value. Here, MondayCheck() must return an integer loyalty-points value, so a function is the correct choice.

This question also depends on string processing. The data returned by FindCustomer() is a single text line in the form:

<CustomerID>,<LoyaltyPointsString>,<LastVisitDateString>

That means the algorithm must take one large string and isolate the middle item. In Paper 2, this is commonly done with string functions such as MID() and LENGTH().

Finally, once the middle field has been extracted, it is still a string, so it must be converted into an integer using STR_TO_NUM() before arithmetic can be performed on it.

Understanding the Question

You are told that FindCustomer() is already written and returns the full line for the current customer. Your job is to write MondayCheck() so that it:

• accepts a customer ID as a string parameter
• calls FindCustomer() using that ID
• extracts the loyalty points from the returned line
• increases the points by 10 if the visit day is Monday
• returns the final points value as an integer

A key clue is the file format. The customer ID is always six digits, and the last visit date string is always eight characters. That fixed structure makes it possible to calculate exactly where the points substring begins and how long it is.

Approach

The most direct method is:

1. Make MondayCheck() a FUNCTION ... RETURNS INTEGER.
2. Call FindCustomer(CustomerID) and store the returned line.
3. Extract the middle field containing the loyalty points.
4. Convert that field from string to integer.
5. Check whether today's weekday is Monday.
6. If it is, add 10.
7. Return the resulting integer.

Because the question says to assume FindCustomer() returns a valid string, no error handling is needed here.

Step-by-Step Reasoning

The function header should be:

• FUNCTION MondayCheck(CustomerID : STRING) RETURNS INTEGER

It needs local variables:

• CustomerData to hold the returned full line
• LoyaltyPointsString to hold the extracted middle field
• LoyaltyPoints as the numeric version
• CurrentDate if you want to store today's date before checking the weekday

So the declarations are:

• DECLARE CustomerData, LoyaltyPointsString : STRING
• DECLARE LoyaltyPoints : INTEGER
• DECLARE CurrentDate : DATE

Next, call the existing module:

• CustomerData ← FindCustomer(CustomerID)

Suppose the returned line is 100123,132,05032025.

Character positions are:

• characters 1 to 6: customer ID
• character 7: first comma
• characters from 8 onward: loyalty points, then comma, then date

The final date section is always 8 characters, and there is also a comma before it. So the end of the line always contains 9 characters that are not part of the points field.

Total line length is:

• 6 for ID
• 1 comma
• points field length
• 1 comma
• 8 for date

So the points field length is LENGTH(CustomerData) - 16.

That gives:

• LoyaltyPointsString ← MID(CustomerData, 8, LENGTH(CustomerData) - 16)

Now convert it to an integer:

• LoyaltyPoints ← STR_TO_NUM(LoyaltyPointsString)

Next handle the Monday bonus. The condition depends on the current visit day, so obtain today's date and test its weekday:

• CurrentDate ← TODAY
• IF DAY_OF_WEEK(CurrentDate) = "Monday" THEN
• LoyaltyPoints ← LoyaltyPoints + 10
• ENDIF

Finally return the integer:

• RETURN LoyaltyPoints

That completes the function.

Key Takeaways

• Use a function when a single value must be returned.
• A fixed-format text record can often be parsed with position-based string functions.
• Numeric text must be converted before arithmetic is performed.
• Break the task into stages: get data, extract field, convert, test condition, return result.

Common Mistakes

• Writing MondayCheck() as a procedure instead of a function.
• Forgetting to call FindCustomer() even though the question says it must be used.
• Returning the string version of the points instead of an integer.
• Extracting the wrong substring because the commas or fixed lengths are miscounted.
• Checking whether LastVisitDateString is a Monday when the rule is about the current visit day.

Things to Be Careful About

• CustomerID is a string parameter, not an integer.
• The points field does not have a fixed number of digits, so the substring length must be calculated.
• MID(CustomerData, 8, LENGTH(CustomerData) - 16) works because the ID is always 6 digits and the date is always 8 characters.
• Use STR_TO_NUM() before trying to add 10.
• End the function with RETURN LoyaltyPoints and ENDFUNCTION.

Background Concept

A fixed-format string is one where each part always appears in the same position. The date string here uses DDMMYYYY, which means:

• characters 1 to 2 are the day
• characters 3 to 4 are the month
• characters 5 to 8 are the year

When data is stored as text but later needs to be used as a proper typed value, the algorithm usually has two stages:

1. split the string into its component parts
2. convert those parts into the required data type

String functions such as LEFT, MID and RIGHT are designed for exactly this kind of task.

Understanding the Question

The question gives you LastVisitDateString, which already contains a valid date such as 03092024. You must complete the pseudocode so that this string is converted into a DATE value stored in LastVisitDate.

The declarations are already given, so the missing part is the algorithm itself.

Approach

Because the format is fixed, the simplest approach is:

1. take the first 2 characters for the day
2. take the next 2 characters for the month
3. take the last 4 characters for the year
4. convert each substring to an integer
5. build the DATE value from those three integers

Step-by-Step Reasoning

Take the example 03092024.

Day:

• LEFT(LastVisitDateString, 2) gives 03
• STR_TO_NUM(...) converts it to integer 3
• store that in DayInt

So:

• DayInt ← STR_TO_NUM(LEFT(LastVisitDateString, 2))

Month:

• characters 3 and 4 are 09
• MID(LastVisitDateString, 3, 2) extracts those two characters
• STR_TO_NUM(...) converts them to integer 9

So:

• MonthInt ← STR_TO_NUM(MID(LastVisitDateString, 3, 2))

Year:

• RIGHT(LastVisitDateString, 4) gives 2024
• STR_TO_NUM(...) converts it to integer 2024

So:

• YearInt ← STR_TO_NUM(RIGHT(LastVisitDateString, 4))

Once the three numeric parts have been extracted, combine them into a date value:

• LastVisitDate ← DATE(DayInt, MonthInt, YearInt)

That creates the required DATE-typed variable.

Key Takeaways

• Use substring functions when the input format is fixed.
• Convert numeric text to integers before using it as structured date data.
• Read the format carefully: DDMMYYYY tells you the exact positions and lengths.

Common Mistakes

• Using the wrong start position for the month, such as starting at character 2 instead of 3.
• Taking only 2 digits for the year instead of 4.
• Forgetting STR_TO_NUM(), leaving the values as strings.
• Mixing up day and month because of reading the format too quickly.

Things to Be Careful About

• MID(LastVisitDateString, 3, 2) is correct because indexing starts at the first character of the string and the month begins at the third character.
• RIGHT(LastVisitDateString, 4) must be 4 because the year is four digits.
• Do not redeclare the variables; the declarations are already provided in the question.
• Keep the final result as a DATE, not as another formatted string.