In this challenge, you will put your understanding of **kinematics** and **motion** to the test by simulating a train's journey between two stations. The train travels at a **constant velocity** between stations but also makes scheduled stops along the way. Your task is to create a Python function that models the train's position over time, accurately reflecting both the motion segments and the periods when the train is stopped. You will validate your model by checking the train's position at key time points during its journey.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_within_first_motion_segment(self):
        import user_code
        importlib.reload(user_code)
        # 8 minutes into first segment at 60 km/h
        result = user_code.train_position(8, [
            {"duration": 10, "velocity": 60},
            {"duration": 5, "velocity": 0},
            {"duration": 15, "velocity": 80}
        ])
        expected = 60 * 8
        _dynamic_test(
            self,
            result == expected,
            "Correct position for time within first motion segment.",
            f"Expected {expected}, got {result} for time within first segment."
        )

    def test_during_stop_segment(self):
        import user_code
        importlib.reload(user_code)
        # 12 minutes in: 10 min at 60 km/h, then 2 min into stop
        result = user_code.train_position(12, [
            {"duration": 10, "velocity": 60},
            {"duration": 5, "velocity": 0},
            {"duration": 15, "velocity": 80}
        ])
        expected = 60 * 10 + 0 * 2
        _dynamic_test(
            self,
            result == expected,
            "Correct position for time during stop segment.",
            f"Expected {expected}, got {result} for time during stop segment."
        )

    def test_within_later_motion_segment(self):
        import user_code
        importlib.reload(user_code)
        # 20 minutes in: 10 min at 60 km/h, 5 min stop, 5 min at 80 km/h
        result = user_code.train_position(20, [
            {"duration": 10, "velocity": 60},
            {"duration": 5, "velocity": 0},
            {"duration": 15, "velocity": 80}
        ])
        expected = 60 * 10 + 0 * 5 + 80 * 5
        _dynamic_test(
            self,
            result == expected,
            "Correct position for time within later motion segment.",
            f"Expected {expected}, got {result} for time within later segment."
        )

    def test_after_all_segments(self):
        import user_code
        importlib.reload(user_code)
        # 30 minutes in: after all segments
        result = user_code.train_position(30, [
            {"duration": 10, "velocity": 60},
            {"duration": 5, "velocity": 0},
            {"duration": 15, "velocity": 80}
        ])
        expected = 60 * 10 + 0 * 5 + 80 * 15
        _dynamic_test(
            self,
            result == expected,
            "Correct position for time after all segments.",
            f"Expected {expected}, got {result} for time after journey complete."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A hands-on Python course designed specifically for physics students, focusing on applying Python programming to solve real-world physics problems. Each section blends engaging theory with practical challenges, covering topics from kinematics to data analysis and visualization.

Explore the fundamentals of motion using Python, from basic displacement calculations to simulating projectile trajectories and analyzing real-world movement data.

Dive into the world of forces and energy, using Python to model Newton's laws, simulate collisions, and analyze energy transformations.

Master the use of Python for analyzing, interpreting, and visualizing experimental and simulated physics data.

Challenge: Simulate a Train Journey

Oplossing

Challenge: Simulate a Train Journey

Oplossing