Automating the process of scheduling team training can save you time and ensure that as many athletes as possible are able to attend. Instead of manually checking everyone's availability, you can use Python to analyze the data and determine the optimal day for your session. In this challenge, you will write a function that examines a list of athlete availabilities and identifies which day of the week would allow for the highest attendance.


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

class TestTask(unittest.TestCase):
    def test_highest_attendance_day(self):
        import user_code
        importlib.reload(user_code)
        availabilities = [
            {"Monday": True, "Tuesday": False, "Wednesday": True, "Thursday": False, "Friday": True},
            {"Monday": False, "Tuesday": True, "Wednesday": True, "Thursday": False, "Friday": False},
            {"Monday": True, "Tuesday": True, "Wednesday": False, "Thursday": True, "Friday": False}
        ]
        result = user_code.find_optimal_training_day(availabilities)
        expected = ["Monday", "Tuesday", "Wednesday"]
        # Monday, Tuesday, and Wednesday each have 2 available
        _dynamic_test(
            self,
            result in expected,
            f"Returns a correct day with highest attendance: {result}",
            f"Expected one of {expected}, got {result}",
        )

    def test_none_available(self):
        import user_code
        importlib.reload(user_code)
        availabilities = [
            {"Monday": False, "Tuesday": False, "Wednesday": False, "Thursday": False, "Friday": False},
            {"Monday": False, "Tuesday": False, "Wednesday": False, "Thursday": False, "Friday": False}
        ]
        result = user_code.find_optimal_training_day(availabilities)
        _dynamic_test(
            self,
            result is None,
            "Returns None when no athletes are available on any day",
            f"Expected None, got {result}",
        )

    def test_tie_between_days(self):
        import user_code
        importlib.reload(user_code)
        availabilities = [
            {"Monday": True, "Tuesday": True},
            {"Monday": True, "Tuesday": True},
            {"Monday": False, "Tuesday": True}
        ]
        result = user_code.find_optimal_training_day(availabilities)
        expected = ["Tuesday"]
        # Tuesday has 3, Monday has 2
        _dynamic_test(
            self,
            result in expected,
            f"Returns correct day when there is a clear winner: {result}",
            f"Expected one of {expected}, got {result}",
        )

    def test_partial_days(self):
        import user_code
        importlib.reload(user_code)
        availabilities = [
            {"Monday": True, "Wednesday": False},
            {"Monday": False, "Wednesday": True},
            {"Wednesday": True}
        ]
        result = user_code.find_optimal_training_day(availabilities)
        expected = ["Wednesday"]
        # Wednesday has 2, Monday has 1
        _dynamic_test(
            self,
            result in expected,
            f"Handles subset of days correctly: {result}",
            f"Expected one of {expected}, got {result}",
        )

    def test_multiple_ties(self):
        import user_code
        importlib.reload(user_code)
        availabilities = [
            {"Monday": True, "Tuesday": True},
            {"Monday": True, "Tuesday": True},
        ]
        result = user_code.find_optimal_training_day(availabilities)
        expected = ["Monday", "Tuesday"]
        # Both have 2
        _dynamic_test(
            self,
            result in expected,
            f"Returns any day in case of a tie: {result}",
            f"Expected one of {expected}, got {result}",
        )

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 practical Python course designed specifically for coaches, trainers, and sports professionals. Learn how to leverage Python to analyze performance, track progress, and make data-driven decisions to enhance coaching outcomes.

Learn how to use Python to monitor, analyze, and visualize individual athlete progress and performance metrics.

Use Python to analyze and compare team-level data, uncover trends, and support strategic coaching decisions.

Explore how Python can automate repetitive coaching tasks, generate reports, and provide actionable insights.

Challenge: Optimal Training Day Finder

Solução