String Manipulation

A string is an ordered sequence of characters. The characters can be letters, digits, symbols, or spaces — whatever you can type on a keyboard. Python lets you write a string between single or double quotes. Both produce exactly the same string; choose whichever quote does not appear inside your text.

The string "Cambridge" stored in the variable word has 9 characters. Each character has a fixed position (called an index), starting at 0. So C is at index 0, a at index 1, all the way to e at index 8.

# Source: moshikur.com | Cambridge A Level CS 9618
greeting = "Hello"
language = 'Python'
fullName = "Md. Moshikur Rahman"
emptyStr = ""             # a valid string with zero characters
mixed = "Room 204, Lab-3"

Once you internalise that, the code structure becomes the same every time: declare an empty newString = "", loop, append, output.

Each character in a Python string has a position called an index. The first character is at index 0, the second at 1, and so on. Python also accepts negative indexes that count backwards from the end: -1 is the last character, -2 the second-last.

# Source: moshikur.com | Cambridge A Level CS 9618
word = "Cambridge"
print(word[0])   # C  — first character
print(word[4])   # r
print(word[-1])  # e  — last character
print(word[-3])  # d  — third from the end

The fact that the end index is excluded looks strange at first, but it has a useful side-effect: the number of characters in the slice is always end - start. So word[2:5] always gives 3 characters, no matter what word is.

Pseudocode MID vs Python slicing — the off-by-one rule

The pseudocode function MID(string, x, y) returns y characters starting at position x, where x is counted from 1. Python slicing counts from 0. The conversion is straightforward but easy to get wrong under exam pressure.

MID(s, x, y) → s[x − 1 : x − 1 + y] — subtract 1 from the start, then add the length to find the end. So MID("ABCDEFGH", 2, 3) picks positions 2, 3, 4 in pseudocode (B, C, D) — in Python this is the slice s[1:4], which returns "BCD".

Examiners sometimes design Paper 4 questions that expect you to demonstrate understanding, not just knowledge of built-ins. When a question says "write a function that returns the number of characters in a string", you score full marks by showing the loop-and-count logic. Quietly using len() can lose method marks because the mark scheme rewards each line of the manual algorithm.

You count characters in a string the same way you count anything else in programming: set a counter to zero, walk through every item, and add one each time. With a string, walking through means a for loop over each character.

# Source: moshikur.com | Cambridge A Level CS 9618
word = "Cambridge"
count = 0
for ch in word:
    count = count + 1
print("Length:", count)  # Length: 9

You can also write the loop using an explicit index, which is closer to the Cambridge pseudocode style. Both are correct, but the index version is often easier to extend later when you need positions, not just counts.

# Source: moshikur.com | Cambridge A Level CS 9618
word = "Cambridge"
count = 0
i = 0
while i < len(word):   # if len() is allowed
    count = count + 1
    i = i + 1
print("Length:", count)

If the question forbids len() entirely, the simpler approach is to use the for ch in word loop above, which knows when to stop without needing the length in advance.

Cambridge mark schemes and pseudocode inserts use a fixed set of string functions — LEFT, RIGHT, MID, LENGTH, TO_UPPER, TO_LOWER. The exam will give you the pseudocode and tell you to write the program in Python. Knowing the one-to-one Python equivalent for each call is the difference between answering in two minutes and panicking through a translation.

Validation, file processing, OOP, and exception handling questions all eventually ask "does this string contain X?" or "where does X start in this string?" — usernames, file extensions, command parsers, postcode validators. Paper 4 expects you to write the search loop yourself, not rely on in or .find(). Once you understand the search pattern, every variation (count, replace, split) is built from the same structure.

Searching a string by hand has two shapes. The first is searching for a single character — one loop, one comparison. The second is searching for a substring — an outer loop over starting positions and an inner loop checking the match.

Finding the first position of a character

# Source: moshikur.com | Cambridge A Level CS 9618
text = "banana"
target = "n"
position = -1  # -1 means "not found yet"

for i in range(len(text)):
    if text[i] == target:
        position = i
        break  # stop at the first match

print("First position of", target, ":", position)  # 2

Finding a substring (manual sliding window)

# Source: moshikur.com | Cambridge A Level CS 9618
text = "CATALOGUE"
sub = "LOG"
n = len(text)
m = len(sub)
found = False
pos = -1

for i in range(n - m + 1):
    match = True
    for j in range(m):
        if text[i + j] != sub[j]:
            match = False
            break
    if match:
        found = True
        pos = i
        break

if found:
    print("Found at position", pos)  # 4
else:
    print("Not found")

Each iteration of the outer loop slides a window of size m one place to the right. The inner loop checks the m characters against the substring. The last valid starting position is n - m, so the outer loop is range(n - m + 1).

Counting is the most common Paper 4 mini-task ("how many vowels", "how many spaces"). Replacing builds directly on it — you walk the same loop but, instead of incrementing a counter, you build a new string. Both are also the foundation for caesar cipher questions, text cleaning, and CSV parsing.

The build-up pattern for replacing characters: start with newText = "", walk the original with a for loop, append either the original character or a substitute, then output newText. Never try to modify the original string in place — strings are immutable.

Counting occurrences of a character

# Source: moshikur.com | Cambridge A Level CS 9618
text = "banana"
target = "a"
count = 0

for ch in text:
    if ch == target:
        count = count + 1

print("Count of", target, ":", count)  # 3

Replacing characters by building a new string

# Source: moshikur.com | Cambridge A Level CS 9618
text = "HELLO"
oldChar = "L"
newChar = "X"
newText = ""

for ch in text:
    if ch == oldChar:
        newText = newText + newChar
    else:
        newText = newText + ch

print(newText)  # HEXXO

Reversal appears in past Paper 4 questions both directly ("reverse this string") and as a sub-routine inside larger tasks (palindrome checks, number-to-binary output, queue printouts). The palindrome check is a small but rich combination of indexing, looping, and Boolean reasoning — exactly what the mark scheme rewards.

Reversing by reading backwards

# Source: moshikur.com | Cambridge A Level CS 9618
word = "PYTHON"
reversedWord = ""

for i in range(len(word) - 1, -1, -1):
    reversedWord = reversedWord + word[i]

print(reversedWord)  # NOHTYP

The range(len(word) - 1, -1, -1) generates the indexes 5, 4, 3, 2, 1, 0 for "PYTHON". The stop value is -1 because the loop must include index 0 — and range excludes its stop value.

Detecting a palindrome (pair-comparison)

# Source: moshikur.com | Cambridge A Level CS 9618
def isPalindrome(s):
    n = len(s)
    isPal = True
    i = 0
    while i < n // 2 and isPal:
        if s[i] != s[n - 1 - i]:
            isPal = False
        i = i + 1
    return isPal

print(isPalindrome("MADAM"))    # True
print(isPalindrome("PYTHON"))   # False
print(isPalindrome("RACECAR"))  # True

This function is on the page because of a real, recent Paper 4 question. In October/November 2025 Paper 42, Question 2(a), candidates were asked to generate 20 unique random integers between 0 and 100. The official Python mark scheme answered with random.sample(range(0, 101), 20). The same function works on strings — and that is what makes it useful here: when you need to pick unique characters from a string (a one-time password, a random initial, a sampled list with no repeats), this is the cleanest answer.

The function random.sample(population, k) returns a list of k unique items chosen from the population. The population can be any sequence — a list, a range, or a string. Because Python strings are sequences of characters, you can pass a string in directly and get back a list of distinct characters.

# Source: moshikur.com | Cambridge A Level CS 9618
import random

# 1. The exact mark-scheme line from 9618/42 O/N 2025 Q2(a)
TheArray = random.sample(range(0, 101), 20)
print(TheArray)
# example: [37, 4, 88, 12, 99, ...] — 20 unique integers, 0–100

# 2. The same idea, applied to a string of characters
letters = "ABCDEFGHIJKLMNOP"
picks = random.sample(letters, 5)
print(picks)
# example: ['F', 'A', 'L', 'B', 'J'] — 5 unique characters

# 3. Join the list back into a string (common follow-up step)
password = "".join(random.sample("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", 8))
print(password)
# example: "K7F3LBQ9"

Individual techniques are useful, but Paper 4 marks reward you for assembling them into one complete, working program. This task combines indexing, searching, counting, and output formatting. Treat it like a real exam — write your code first, then check against the model solution.

Question (Paper 4 style) — 12 marks

A school stores a single line of registration data for each student as a string of the format:

SXXXX-G-NAME

where:

• SXXXX is a 5-character student ID starting with the letter S followed by 4 digits
• G is a single grade character ('A', 'B' or 'C')
• NAME is the student's name (at least 1 character)
• The two hyphens - always appear in fixed positions

Examples of valid records: S0204-A-MOSHIKUR, S1099-B-NAYEEM.

Write a Python program that:

• Asks the user to enter a registration record.
• Validates that the record begins with "S" followed by 4 digits, that the 7th character is one of "A", "B", "C", and that hyphens appear at Python indexes 5 and 7. [6]
• If the record is valid, outputs the student ID, grade, and name on separate lines. [3]
• If the record is invalid, outputs a clear error message identifying which part failed. [3]

Total marks: 12 (AO3)

Mark scheme (model)

Total: 12. Accept equivalent algorithms — e.g. building a digit-check using "0123456789" membership instead of comparison, or using .startswith if not explicitly forbidden.

Fifteen exam-style string tasks. Each shows only the question — click Hint for the thought process, or Help for the worked Python solution. Try each one yourself before revealing.