word = input("Word: ")
index = int(input("Integer index: "))
if -len(word) <= index < len(word):
    print("Character:", repr(word[index]))
else:
    print("No character at that index")

The check protects the indexing operation. It validates position, not the integer conversion: this version assumes suitable integer text. repr makes a space or empty-looking character easier to inspect.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

original = input("Club code: ")
cleaned = original.strip().upper()
prefix = cleaned[:3]
print("Original:", repr(original))
print("Cleaned:", repr(cleaned))
print("Prefix:", repr(prefix))

The original name remains associated with the input text. The returned strings are stored separately. A short slice returns available characters; it does not guarantee a code meets a length or format rule.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

scores = [8, 5, 12]
scores[1] = 9
print("Replaced:", scores)
scores.append(7)
print("Appended:", scores)
removed = scores.pop()
print("Removed:", removed)
print("Remaining:", scores)

The list keeps its identity while its contents change. append changes the list and returns None; pop changes the list and returns the removed item. Do not assign scores = scores.append(7).

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

working = [8, 5, 12]
backup = working.copy()
working[0] = 99
print("Working:", working)
print("Backup:", backup)

Reassigning an item of the new outer list does not replace an item of the backup. This is suitable for these immutable integer items. A nested-list case requires separate attention to inner objects.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

position = (4, 7)
x, y = position
single = (4,)
grouped = (4)
print("x:", x, "y:", y)
print("One-item type:", type(single))
print("Grouped type:", type(grouped))

Tuple item associations cannot be replaced. Unpacking assigns existing items to names and must match the number of targets in this example. Parentheses do not independently create a tuple.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

coding = set(["Maya", "Kai", "Maya"])
robotics = set(["Kai", "Noor"])
print("Either club:", sorted(coding | robotics))
print("Both clubs:", sorted(coding & robotics))
print("Coding only:", sorted(coding - robotics))

Set membership is distinct and case-sensitive. Difference is directional. The alphabetical output comes from sorted(), rather than any promised iteration order of the sets.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

record = {"name": "Maya", "score": 0}
if "score" in record:
    print("Stored score:", record["score"])
else:
    print("Score missing")

Existence and value are separate questions. The guarded direct access is safe for a present key and preserves zero as valid data. This does not independently establish that the stored value has a permitted type or range.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

inventory = {"motor": 3}
for item, amount in [("motor", 2), ("sensor", 1)]:
    inventory[item] = inventory.get(item, 0) + amount
for item, count in inventory.items():
    print(item, count)

Each loop tuple is unpacked into item and amount. The dictionary stores one current value for each key. Adding an existing key replaces its value rather than creating a second identical key.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

rows = [[8, 5], [12, 4, 3], []]
grand_total = 0
for row_number, row in enumerate(rows, start=1):
    row_total = 0
    for value in row:
        row_total += value
    grand_total += row_total
    print("Row", row_number, "total:", row_total)
print("Grand total:", grand_total)

The row accumulator is reset once per row so it does not include earlier teams. The grand accumulator is maintained across rows. enumerate gives display row numbers; it does not change the actual list indexes.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

numbers = [2, 5, 8, 4]
loop_result = []
for number in numbers:
    if number >= 5:
        loop_result.append(number * 2)
compact_result = [number * 2 for number in numbers if number >= 5]
print("Loop:", loop_result)
print("Comprehension:", compact_result)
rows = [[0] * 3 for _ in range(2)]
rows[0][1] = 9
print("Rows:", rows)

The final if filters visits; the leading expression transforms included values. Constructing a new row inside the comprehension avoids the shared-inner-list problem of [[0] * 3] * 2. _ is an ordinary name used by convention when its value is not needed.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

# Session quiz: authored question bank must be non-empty and consistent.
questions = [
    {"prompt": "Which Python type stores text?",
     "options": ["int", "str", "bool"], "answer": "2"},
    {"prompt": "What is the first non-negative list index?",
     "options": ["0", "1", "-1"], "answer": "1"},
    {"prompt": "Which collection keeps distinct members?",
     "options": ["list", "tuple", "set"], "answer": "3"}
]
scoreboard = []

print("Python collections quiz")
while True:
    name = input("Player first name, or quit to finish: ").strip()
    if name == "quit":
        break
    if not name:
        print("Enter a non-empty name")
        continue

    score = 0
    for question in questions:
        print()
        print(question["prompt"])
        for number, option in enumerate(question["options"], start=1):
            print(f"{number}. {option}")
        valid_choices = [str(number) for number in range(1, len(question["options"]) + 1)]
        response = input("Option number: ").strip()
        while response not in valid_choices:
            print("Choose one of the displayed option numbers")
            response = input("Option number: ").strip()
        if response == question["answer"]:
            score += 1
            print("Correct")
        else:
            print(f"Not correct. Answer code: {question['answer']}")

    percentage = score / len(questions) * 100
    print(f"{name}: {score}/{len(questions)} ({percentage:.1f}%)")
    scoreboard.append((score, name))

print()
print("Session scoreboard: score descending, then name descending for ties")
if scoreboard:
    ranked = sorted(scoreboard, reverse=True)
    for position, result in enumerate(ranked, start=1):
        score, name = result
        print(f"Display position {position}: {name} - {score}/{len(questions)}")
else:
    print("No completed players")

Each dictionary stores one question’s prompt, options and correct answer code. Invalid answers do not reach the scoring check. The result tuple captures a finished score and name; reverse tuple sorting orders scores first and names second. Positions are display positions, not competitive tie ranks.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

# Session quiz: authored question bank must be non-empty and consistent.
questions = [
    {"prompt": "Which Python type stores text?",
     "options": ["int", "str", "bool"], "answer": "2"},
    {"prompt": "What is the first non-negative list index?",
     "options": ["0", "1", "-1"], "answer": "1"},
    {"prompt": "Which collection keeps distinct members?",
     "options": ["list", "tuple", "set"], "answer": "3"}
]
scoreboard = []

print("Python collections quiz")
while True:
    name = input("Player first name, or quit to finish: ").strip()
    if name == "quit":
        break
    if not name:
        print("Enter a non-empty name")
        continue

    score = 0
    for question in questions:
        print()
        print(question["prompt"])
        for number, option in enumerate(question["options"], start=1):
            print(f"{number}. {option}")
        valid_choices = [str(number) for number in range(1, len(question["options"]) + 1)]
        response = input("Option number: ").strip()
        while response not in valid_choices:
            print("Choose one of the displayed option numbers")
            response = input("Option number: ").strip()
        if response == question["answer"]:
            score += 1
            print("Correct")
        else:
            print(f"Not correct. Answer code: {question['answer']}")

    percentage = score / len(questions) * 100
    print(f"{name}: {score}/{len(questions)} ({percentage:.1f}%)")
    scoreboard.append((score, name))

print()
print("Session scoreboard: score descending, then name descending for ties")
if scoreboard:
    ranked = sorted(scoreboard, reverse=True)
    for position, result in enumerate(ranked, start=1):
        score, name = result
        print(f"Display position {position}: {name} - {score}/{len(questions)}")
else:
    print("No completed players")

Sorting provides a reproducible display policy, not a fairness judgement between equal scores. Names are display labels and not guaranteed unique identities. The program has no file persistence and assumes a non-empty, correctly authored question bank.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.