编写并调试一个模拟的进程调度程序，采用 “先 来先服务”调度算法对多个进程进行调度。 计算平均周转时间和平均带权周转时间。

好的，这个任务可以分为以下几个步骤：

1. 定义进程和进程控制块（PCB）的结构体，包括进程的ID、状态、到达时间、服务时间、开始执行时间、结束时间、周转时间和带权周转时间等属性。

2. 构建一个进程队列，将所有进程按照到达时间排序，并加入队列中。

3. 使用先来先服务算法，依次处理每个进程。如果当前时间小于等于该进程的到达时间，则直接将进程的开始时间设为到达时间，否则将进程的开始时间设为当前时间。

4. 经过一段时间后，该进程执行完毕，更新进程的结束时间、周转时间和带权周转时间，并将该进程从队列中删除。

5. 循环处理剩余的进程，直到所有进程都执行完毕。

6. 计算平均周转时间和平均带权周转时间，输出结果。

下面是一个简单的示例代码：

# 定义进程控制块（PCB）的结构体
class Process:
    def __init__(self, pid, arrive_time, service_time):
        self.pid = pid  # 进程ID
        self.arrive_time = arrive_time  # 到达时间
        self.service_time = service_time  # 服务时间
        self.start_time = 0  # 开始执行时间
        self.end_time = 0  # 结束时间
        self.turnaround_time = 0  # 周转时间
        self.weighted_turnaround_time = 0  # 带权周转时间

# 进程列表
processes = [
    Process(1, 0, 10),
    Process(2, 5, 6),
    Process(3, 13, 7),
    Process(4, 17, 3),
    Process(5, 19, 5)
]

# 按照到达时间排序
processes.sort(key=lambda x: x.arrive_time)

# 进程队列
queue = []

# 当前时间
current_time = 0

# 处理完毕的进程数
count = 0

# 处理每个进程
while count < len(processes):
    # 将到达时间小于等于当前时间的进程加入队列
    for process in processes:
        if process.arrive_time <= current_time and process not in queue:
            queue.append(process)

    # 如果队列为空，当前时间向后移动一秒钟
    if len(queue) == 0:
        current_time += 1
        continue

    # 处理队首进程
    process = queue[0]
    queue.remove(process)

    # 如果当前时间小于进程的到达时间，则将开始时间设为进程的到达时间
    if current_time < process.arrive_time:
        process.start_time = process.arrive_time
    else:
        process.start_time = current_time

    # 更新当前时间和进程的结束时间
    current_time = process.start_time + process.service_time
    process.end_time = current_time

    # 更新进程的周转时间和带权周转时间
    process.turnaround_time = process.end_time - process.arrive_time
    process.weighted_turnaround_time = process.turnaround_time / process.service_time

    # 统计已处理的进程数
    count += 1

# 计算平均周转时间和平均带权周转时间
total_turnaround_time = 0
total_weighted_turnaround_time = 0
for process in processes:
    total_turnaround_time += process.turnaround_time
    total_weighted_turnaround_time += process.weighted_turnaround_time

average_turnaround_time = total_turnaround_time / len(processes)
average_weighted_turnaround_time = total_weighted_turnaround_time / len(processes)

# 输出结果
print("平均周转时间：", average_turnaround_time)
print("平均带权周转时间：", average_weighted_turnaround_time)

这个程序是一个简单的模拟，实际的进程调度程序可能会更加复杂。