Create app.py

app.py

@@ -0,0 +1,506 @@
+import random
+import gradio as gr
+
+# ---------- Helper functions ----------
+
+def generate_random_students(n_students: int):
+    """
+    Generate a random class with names 'Student 1', 'Student 2', ...
+    and random grades between 0 and 100.
+    """
+    students = []
+    for i in range(n_students):
+        name = f"Student {i + 1}"
+        grade = random.randint(0, 100)
+        students.append([name, grade])
+    return students
+
+
+def format_students(students):
+    """
+    Turn a list like [["Student 1", 78], ["Student 2", 92]]
+    into: [Student 1 (78), Student 2 (92)]
+    """
+    parts = [f"{name} ({grade:g})" for name, grade in students]
+    return "[" + ", ".join(parts) + "]"
+
+
+def is_sorted(students, ascending):
+    """
+    Check if the list is sorted by grade in the chosen order.
+    """
+    grades = [g for _, g in students]
+    if ascending:
+        return all(grades[i] <= grades[i + 1] for i in range(len(grades) - 1))
+    else:
+        return all(grades[i] >= grades[i + 1] for i in range(len(grades) - 1))
+
+
+def bubble_rule_should_swap(left_grade, right_grade, ascending):
+    """
+    Bubble Sort rule: when do we swap?
+    """
+    if ascending:
+        return left_grade > right_grade
+    else:
+        return left_grade < right_grade
+
+
+# ---------- Simulation functions ----------
+
+def start_simulation(n_students, order_choice):
+    """
+    Create a random class and set up the first comparison.
+    """
+    try:
+        n_students = int(n_students)
+    except ValueError:
+        n_students = 5  # default
+
+    if n_students < 2:
+        n_students = 2
+
+    students = generate_random_students(n_students)
+    n = len(students)
+    ascending = (order_choice == "Lowest to highest")
+
+    # Initial pass and position
+    i = 0  # pass index
+    j = 0  # position index
+
+    list_text = format_students(students)
+
+    left_name, left_grade = students[j]
+    right_name, right_grade = students[j + 1]
+    should_swap = bubble_rule_should_swap(left_grade, right_grade, ascending)
+
+    comparison_text = (
+        f"Pass {i + 1} – Compare {left_name} ({left_grade:g}) "
+        f"and {right_name} ({right_grade:g})\n"
+        f"Bubble Sort rule for this comparison: "
+        f"{'Swap' if should_swap else 'Do NOT swap'}"
+    )
+
+    status = (
+        "New random class generated.\n"
+        "Use the buttons below to decide each step."
+    )
+
+    # At start: no swaps yet, no accuracy info yet
+    swap_count = 0
+    correct_decisions = 0
+    total_decisions = 0
+    finished = False
+
+    return (
+        list_text,
+        comparison_text,
+        status,
+        students,
+        i,
+        j,
+        swap_count,
+        finished,
+        order_choice,
+        correct_decisions,
+        total_decisions,
+    )
+
+
+def step_simulation(
+    action,
+    students,
+    pass_index,
+    position_index,
+    swap_count,
+    finished,
+    order_choice,
+    correct_decisions,
+    total_decisions,
+):
+    """
+    One step after the teacher presses Swap / Don't swap.
+    """
+    if students is None:
+        return (
+            "Click 'Start Simulation' to generate a class.",
+            "",
+            "No active simulation.",
+            students,
+            pass_index,
+            position_index,
+            swap_count,
+            finished,
+            order_choice,
+            correct_decisions,
+            total_decisions,
+        )
+
+    if finished:
+        list_text = format_students(students)
+        status = "Simulation already finished. Start again with a new class."
+        return (
+            list_text,
+            "",
+            status,
+            students,
+            pass_index,
+            position_index,
+            swap_count,
+            finished,
+            order_choice,
+            correct_decisions,
+            total_decisions,
+        )
+
+    n = len(students)
+    ascending = (order_choice == "Lowest to highest")
+
+    i = pass_index
+    j = position_index
+
+    # Current pair before action
+    left_name, left_grade = students[j]
+    right_name, right_grade = students[j + 1]
+    rule_says_swap = bubble_rule_should_swap(left_grade, right_grade, ascending)
+
+    teacher_chose_swap = (action == "swap")
+
+    # Update accuracy counters
+    total_decisions += 1
+    if teacher_chose_swap == rule_says_swap:
+        correct_decisions += 1
+
+    # Apply teacher choice
+    if teacher_chose_swap:
+        students[j], students[j + 1] = students[j + 1], students[j]
+        swap_count += 1
+        teacher_action_text = "Teacher chose to SWAP these two students."
+    else:
+        teacher_action_text = "Teacher chose NOT to swap these two students."
+
+    # Move to next position
+    j += 1
+
+    status = teacher_action_text
+
+    # End of this pass?
+    if j >= n - 1 - i:
+        i += 1
+        j = 0
+        status += f"\nEnd of pass {i}. Moving to the next pass."
+
+    # All passes done?
+    if i >= n - 1:
+        finished = True
+        list_text = format_students(students)
+        correct_order = is_sorted(students, ascending)
+
+        # Accuracy
+        if total_decisions > 0:
+            accuracy = (correct_decisions / total_decisions) * 100
+        else:
+            accuracy = 0.0
+
+        comparison_text = ""
+        status += "\n\nSimulation finished. Final list locked."
+
+        if correct_order:
+            status += "\nThe final list IS correctly sorted according to the chosen order."
+        else:
+            status += "\nThe final list is NOT correctly sorted according to the chosen order."
+
+        status += f"\nTotal swaps you performed: {swap_count}"
+        status += f"\nYour decision accuracy: {accuracy:.1f}% "
+        status += f"({correct_decisions} out of {total_decisions} decisions matched the Bubble Sort rule.)"
+
+        return (
+            list_text,
+            comparison_text,
+            status,
+            students,
+            i,
+            j,
+            swap_count,
+            finished,
+            order_choice,
+            correct_decisions,
+            total_decisions,
+        )
+
+    # Not finished: compute next comparison
+    left_name, left_grade = students[j]
+    right_name, right_grade = students[j + 1]
+    should_swap = bubble_rule_should_swap(left_grade, right_grade, ascending)
+
+    list_text = format_students(students)
+    comparison_text = (
+        f"Pass {i + 1} – Compare {left_name} ({left_grade:g}) "
+        f"and {right_name} ({right_grade:g})\n"
+        f"Bubble Sort rule for this comparison: "
+        f"{'Swap' if should_swap else 'Do NOT swap'}"
+    )
+
+    return (
+        list_text,
+        comparison_text,
+        status,
+        students,
+        i,
+        j,
+        swap_count,
+        finished,
+        order_choice,
+        correct_decisions,
+        total_decisions,
+    )
+
+
+def finish_now(
+    students,
+    pass_index,
+    position_index,
+    swap_count,
+    finished,
+    order_choice,
+    correct_decisions,
+    total_decisions,
+):
+    """
+    Teacher clicks 'Finish now' before all passes complete.
+    """
+    if students is None:
+        return (
+            "Click 'Start Simulation' to generate a class.",
+            "",
+            "No active simulation.",
+            students,
+            pass_index,
+            position_index,
+            swap_count,
+            finished,
+            order_choice,
+            correct_decisions,
+            total_decisions,
+        )
+
+    ascending = (order_choice == "Lowest to highest")
+    list_text = format_students(students)
+    correct_order = is_sorted(students, ascending)
+
+    status = "Teacher finished the list early.\n"
+
+    if correct_order:
+        status += "The final list IS correctly sorted according to the chosen order."
+    else:
+        status += "The final list is NOT correctly sorted according to the chosen order."
+
+    if total_decisions > 0:
+        accuracy = (correct_decisions / total_decisions) * 100
+    else:
+        accuracy = 0.0
+
+    status += f"\nTotal swaps you performed: {swap_count}"
+    status += f"\nYour decision accuracy: {accuracy:.1f}% "
+    status += f"({correct_decisions} out of {total_decisions} decisions matched the Bubble Sort rule.)"
+
+    finished = True
+
+    return (
+        list_text,
+        "",
+        status,
+        students,
+        pass_index,
+        position_index,
+        swap_count,
+        finished,
+        order_choice,
+        correct_decisions,
+        total_decisions,
+    )
+
+
+# ---------- Gradio UI ----------
+
+with gr.Blocks(title="Marking Day – Interactive Bubble Sort") as demo:
+    gr.Markdown(
+        """
+        # Marking Day – Interactive Bubble Sort Grade Ranker
+
+        You are the teacher on marking day.
+
+        1. Choose how many students are in the class.
+        2. Choose the sort order.
+        3. Click **Start Simulation** to generate a random class.
+        4. For each comparison, choose whether to **Swap** or **Don't swap**.
+        5. Watch the list update after each choice.
+        6. Continue until Bubble Sort finishes, or click **Finish now**.
+
+        At the end, you will see:
+        - Whether the final list is correctly sorted.
+        - How many swaps you performed.
+        - How accurate your decisions were compared to the Bubble Sort rule.
+        """
+    )
+
+    n_students_input = gr.Slider(
+        minimum=2,
+        maximum=20,
+        value=5,
+        step=1,
+        label="Number of students in the class",
+    )
+
+    order_choice = gr.Radio(
+        choices=["Highest to lowest", "Lowest to highest"],
+        value="Highest to lowest",
+        label="Sort order",
+    )
+
+    start_button = gr.Button("Start Simulation", variant="primary")
+
+    list_display = gr.Markdown(label="Current list")
+    comparison_display = gr.Markdown(label="Current comparison")
+    status_display = gr.Markdown(label="Status")
+
+    # State variables
+    students_state = gr.State()
+    pass_state = gr.State(0)
+    position_state = gr.State(0)
+    swap_count_state = gr.State(0)
+    finished_state = gr.State(False)
+    order_state = gr.State("Highest to lowest")
+    correct_decisions_state = gr.State(0)
+    total_decisions_state = gr.State(0)
+
+    # Start simulation
+    start_button.click(
+        fn=start_simulation,
+        inputs=[n_students_input, order_choice],
+        outputs=[
+            list_display,
+            comparison_display,
+            status_display,
+            students_state,
+            pass_state,
+            position_state,
+            swap_count_state,
+            finished_state,
+            order_state,
+            correct_decisions_state,
+            total_decisions_state,
+        ],
+    )
+
+    with gr.Row():
+        swap_button = gr.Button("Swap students")
+        dont_swap_button = gr.Button("Don't swap")
+        finish_button = gr.Button("Finish now")
+
+    # Step with Swap
+    swap_button.click(
+        fn=lambda students, p, pos, swaps, fin, ord_choice, correct_dec, total_dec: step_simulation(
+            "swap",
+            students,
+            p,
+            pos,
+            swaps,
+            fin,
+            ord_choice,
+            correct_dec,
+            total_dec,
+        ),
+        inputs=[
+            students_state,
+            pass_state,
+            position_state,
+            swap_count_state,
+            finished_state,
+            order_state,
+            correct_decisions_state,
+            total_decisions_state,
+        ],
+        outputs=[
+            list_display,
+            comparison_display,
+            status_display,
+            students_state,
+            pass_state,
+            position_state,
+            swap_count_state,
+            finished_state,
+            order_state,
+            correct_decisions_state,
+            total_decisions_state,
+        ],
+    )
+
+    # Step with Don't swap
+    dont_swap_button.click(
+        fn=lambda students, p, pos, swaps, fin, ord_choice, correct_dec, total_dec: step_simulation(
+            "no_swap",
+            students,
+            p,
+            pos,
+            swaps,
+            fin,
+            ord_choice,
+            correct_dec,
+            total_dec,
+        ),
+        inputs=[
+            students_state,
+            pass_state,
+            position_state,
+            swap_count_state,
+            finished_state,
+            order_state,
+            correct_decisions_state,
+            total_decisions_state,
+        ],
+        outputs=[
+            list_display,
+            comparison_display,
+            status_display,
+            students_state,
+            pass_state,
+            position_state,
+            swap_count_state,
+            finished_state,
+            order_state,
+            correct_decisions_state,
+            total_decisions_state,
+        ],
+    )
+
+    # Finish early
+    finish_button.click(
+        fn=finish_now,
+        inputs=[
+            students_state,
+            pass_state,
+            position_state,
+            swap_count_state,
+            finished_state,
+            order_state,
+            correct_decisions_state,
+            total_decisions_state,
+        ],
+        outputs=[
+            list_display,
+            comparison_display,
+            status_display,
+            students_state,
+            pass_state,
+            position_state,
+            swap_count_state,
+            finished_state,
+            order_state,
+            correct_decisions_state,
+            total_decisions_state,
+        ],
+    )
+
+if __name__ == "__main__":
+    demo.launch()