import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Study task form")
root.columnconfigure(0, weight=1)
frame = ttk.Frame(root, padding=16)
frame.grid(row=0, column=0, sticky="nsew")
frame.columnconfigure(1, weight=1)
subject = tk.StringVar(root)
task = tk.StringVar(root)
ttk.Label(frame, text="Subject:").grid(row=0, column=0, sticky="w", padx=(0, 12), pady=6)
ttk.Entry(frame, textvariable=subject).grid(row=0, column=1, sticky="ew", pady=6)
ttk.Label(frame, text="Task:").grid(row=1, column=0, sticky="w", padx=(0, 12), pady=6)
ttk.Entry(frame, textvariable=task).grid(row=1, column=1, sticky="ew", pady=6)
ttk.Button(frame, text="Close", command=root.destroy).grid(row=2, column=1, sticky="e", pady=10)
root.mainloop()

The geometry rules make the form adapt without manually moving every control. This prototype displays entries but does not claim to save them.

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

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Keep the widget reference")
status = ttk.Label(root, text="Ready")
status.grid(row=0, column=0, padx=16, pady=12)

def finish():
    status.configure(text="Task complete")

ttk.Button(root, text="Complete", command=finish).grid(row=1, column=0, pady=12)
root.mainloop()

Separating construction from placement retains the object. The callback is registered now and invoked later, so the message does not change during setup.

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

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("A helpful greeting")
name = tk.StringVar(root)
message = tk.StringVar(root, value="Enter a first name.")

def greet(event=None):
    cleaned = name.get().strip()
    if not cleaned:
        message.set("Please enter a non-blank name.")
        return
    message.set(f"Hello, {cleaned}. What will you build today?")

frame = ttk.Frame(root, padding=16)
frame.pack(fill="both", expand=True)
entry = ttk.Entry(frame, textvariable=name)
entry.pack(pady=8)
entry.bind("<Return>", greet)
ttk.Button(frame, text="Greet", command=greet).pack(pady=8)
ttk.Label(frame, textvariable=message).pack(pady=8)
entry.focus_set()
root.mainloop()

The handler reads and checks the value before rendering. Pressing Enter is another route to the same rule, not a second implementation to keep in sync.

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

import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Responsive scheduled work")
message = tk.StringVar(root, value="Ready")
pending = None

def finish():
    global pending
    pending = None
    message.set("Finished the scheduled step")

def schedule():
    global pending
    if pending is not None:
        root.after_cancel(pending)
    message.set("Scheduled; the window is still responsive")
    pending = root.after(1500, finish)

def cancel():
    global pending
    if pending is not None:
        root.after_cancel(pending)
        pending = None
    message.set("Cancelled")

def close():
    if pending is not None:
        root.after_cancel(pending)
    root.destroy()

ttk.Label(root, textvariable=message).pack(padx=16, pady=12)
ttk.Button(root, text="Schedule / reschedule", command=schedule).pack(pady=12)
ttk.Button(root, text="Cancel", command=cancel).pack(pady=8)
root.protocol("WM_DELETE_WINDOW", close)
root.mainloop()

The job handle describes pending work. It is distinct from the callback function and from the app’s task IDs. Late dispatch is possible, so this is not a precision timer.

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

import pygame

pygame.init()
try:
    screen = pygame.display.set_mode((640, 480))
    pygame.display.set_caption("Move the rectangle")
    clock = pygame.time.Clock()
    x, y = 300.0, 220.0
    speed = 240.0
    running = True
    while running:
        dt = min(clock.tick(60) / 1000.0, 0.05)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False
        if not running:
            break
        keys = pygame.key.get_pressed()
        direction = int(keys[pygame.K_RIGHT]) - int(keys[pygame.K_LEFT])
        x = max(0.0, min(600.0, x + direction * speed * dt))
        screen.fill((18, 28, 38))
        pygame.draw.rect(screen, (36, 152, 143), (round(x), round(y), 40, 40))
        pygame.display.flip()
finally:
    pygame.quit()

The clamp uses screen width minus player width. The bounded dt reduces jumps but can make simulation run slowly after a stall; it is not an exact wall-clock guarantee.

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

import pygame

pygame.init()
try:
    screen = pygame.display.set_mode((640, 480))
    pygame.display.set_caption("Move the rectangle")
    clock = pygame.time.Clock()
    x, y = 300.0, 220.0
    speed = 240.0
    colour_choice = False
    running = True
    while running:
        dt = min(clock.tick(60) / 1000.0, 0.05)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    running = False
                elif event.key == pygame.K_SPACE:
                    colour_choice = not colour_choice
        if not running:
            break
        keys = pygame.key.get_pressed()
        direction = int(keys[pygame.K_RIGHT]) - int(keys[pygame.K_LEFT])
        x = max(0.0, min(600.0, x + direction * speed * dt))
        screen.fill((18, 28, 38))
        colour = (236, 112, 162) if colour_choice else (36, 152, 143)
        pygame.draw.rect(screen, colour, (round(x), round(y), 40, 40))
        pygame.display.flip()
finally:
    pygame.quit()

A KEYDOWN occurrence controls the transition. This simple example assumes ordinary key-repeat settings; deliberately enabling repeat would require an explicit repeated-event policy.

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

import pygame

pygame.init()
try:
    screen = pygame.display.set_mode((640, 480))
    clock = pygame.time.Clock()
    font = pygame.font.Font(None, 28)

    class FallingStar(pygame.sprite.Sprite):
        def __init__(self, x, y):
            super().__init__()
            self.image = pygame.Surface((24, 24), pygame.SRCALPHA)
            pygame.draw.circle(self.image, (255, 217, 94), (12, 12), 12)
            self.rect = self.image.get_rect(topleft=(x, y))
            self.y = float(y)

        def update(self, dt):
            self.y += 140.0 * dt
            self.rect.y = round(self.y)
            if self.rect.top >= 480:
                self.kill()

    class Player(pygame.sprite.Sprite):
        def __init__(self):
            super().__init__()
            self.image = pygame.Surface((60, 24))
            self.image.fill((36, 152, 143))
            self.rect = self.image.get_rect(midbottom=(320, 450))
            self.x = float(self.rect.x)

        def update(self, dt, direction):
            self.x = max(0.0, min(580.0, self.x + direction * 300.0 * dt))
            self.rect.x = round(self.x)

    player = Player()
    stars = pygame.sprite.Group(FallingStar(100, 0), FallingStar(300, 40), FallingStar(500, 80))
    players = pygame.sprite.GroupSingle(player)
    score = 0
    running = True
    while running:
        dt = min(clock.tick(60) / 1000.0, 0.05)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False
        if not running:
            break
        keys = pygame.key.get_pressed()
        direction = int(keys[pygame.K_RIGHT]) - int(keys[pygame.K_LEFT])
        player.update(dt, direction)
        stars.update(dt)
        hits = pygame.sprite.spritecollide(player, stars, dokill=True)
        score += 10 * len(hits)
        screen.fill((18, 28, 38))
        stars.draw(screen)
        players.draw(screen)
        screen.blit(font.render(f"Score: {score}", True, (255, 255, 255)), (16, 16))
        pygame.display.flip()
finally:
    pygame.quit()

The limited prototype has one initial wave. It demonstrates groups and one-time collection without claiming restart or an endless spawning system.

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

import pygame

player = pygame.sprite.Sprite()
player.image = pygame.Surface((48, 24))
player.rect = pygame.Rect(100, 400, 48, 24)
print("Touching:", player.rect.colliderect(pygame.Rect(148, 400, 24, 24)))
print("Overlap:", player.rect.colliderect(pygame.Rect(147, 400, 24, 24)))
star = pygame.sprite.Sprite()
star.image = pygame.Surface((24, 24))
star.rect = pygame.Rect(147, 400, 24, 24)
stars = pygame.sprite.Group(star)
score = 10 * len(pygame.sprite.spritecollide(player, stars, dokill=True))
score += 10 * len(pygame.sprite.spritecollide(player, stars, dokill=True))
print("Score:", score)
print("Remaining:", len(stars))

A transparent image does not automatically change the collision shape. kill changes memberships; it does not prove the Python object has been destroyed.

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

from pathlib import Path
from tempfile import TemporaryDirectory
from model import StudyStore

with TemporaryDirectory() as folder:
    path = Path(folder) / "test.sqlite3"
    first = StudyStore(path)
    task_id = first.add("Computer Science", "Trace loops", "2026-10-15", 25)
    second = StudyStore(path)
    assert second.list()[0]["id"] == task_id
    second.set_done(task_id, True)
    assert second.list("open") == []
    assert len(second.list("completed")) == 1
    second.set_done(task_id, False)
    assert len(second.list("open")) == 1
print("Saved task and filters checked")

The temporary directory disappears after the exercise; this does not imply the actual app deletes its database. Stable IDs connect UI selection to records.

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

from model import FocusTimer

now = [100.0]
timer = FocusTimer(lambda: now[0])
timer.start(1)
now[0] = 130.0
assert timer.remaining() == 30
before = timer.deadline
try:
    timer.start(121)
except ValueError:
    assert timer.deadline == before
else:
    raise AssertionError("Bad duration was accepted")
now[0] = 160.0
assert timer.remaining() == 0
timer.start(2)
timer.cancel()
assert timer.remaining() == 0
print("Deadline, rejection and cancellation checked")

The test checks time as state without opening a GUI or waiting. Native responsiveness and cancellation on closing still need interface checks.

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

from game_model import Game, Falling

game = Game(seed=7)
game.start()
game.items.append(Falling(game.player_x, game.player_y, "star", 0))
game.step(0, 0)
assert game.score == 10 and game.items == []
game.toggle_pause()
before = (game.elapsed, game.player_x)
game.step(0.02, 1)
assert (game.elapsed, game.player_x) == before
game.start()
assert game.state == "playing"
assert game.score == 0 and game.lives == 3
assert game.items == [] and game.elapsed == 0
assert game.spawn_elapsed == 0 and game.invulnerable == 0
print("Collection, pause and fresh round checked")

Restart resets the whole round-owned model rather than only the displayed score. The model’s random generator is not automatically reseeded by start.

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

from game_model import Game, Falling

game = Game(seed=7)
game.start()
def rock():
    game.items.append(Falling(game.player_x, game.player_y, "rock", 0))

rock()
rock()
game.step(0, 0)
assert game.lives == 2 and game.items == []
for _ in range(17):
    game.step(0.05, 0)
rock()
game.step(0, 0)
assert game.lives == 1
game.invulnerable = 0
rock()
game.step(0, 0)
assert game.lives == 0 and game.state == "over"
print("Damage, protection and ending checked")

The direct final protection assignment is a controlled test setup, not a suggested player action. A test suite supports selected rules; a partner playtest checks clarity and fairness.

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