设计符合上述要求的代码

由于这个问题比较复杂，代码实现需要考虑多个因素，包括作业的处理时间、工厂的机器数量、作业的优先级等等。因此，我提供一个简单的框架，您可以根据具体问题的要求进行修改和完善。

首先，我们需要定义一个作业类Job，包括作业编号、工厂编号、处理时间等属性：

class Job:
    def __init__(self, job_id, factory_id, processing_time):
        self.job_id = job_id
        self.factory_id = factory_id
        self.processing_time = processing_time

接着，我们定义一个工厂类Factory，包括工厂编号、机器数量等属性：

class Factory:
    def __init__(self, factory_id, num_of_machines):
        self.factory_id = factory_id
        self.num_of_machines = num_of_machines
        self.available_machines = list(range(num_of_machines))
        self.current_time = 0

在Factory类中，我们维护了工厂的当前时间和可用机器的列表，初始时所有机器都是可用的。

然后，我们定义一个Scheduler类，用于实现作业的调度和排序。在Scheduler类中，我们定义了一个作业列表jobs和一个工厂列表factories，以及一些辅助函数：

class Scheduler:
    def __init__(self, jobs, factories):
        self.jobs = jobs
        self.factories = factories

    def get_next_job(self):
        """
        获取下一个要处理的作业
        """
        next_job = None
        min_start_time = float('inf')
        for job in self.jobs:
            if job.factory_id in self.factories and job.processing_time > 0:
                factory = self.factories[job.factory_id]
                if factory.current_time >= job.start_time:
                    if job.start_time < min_start_time:
                        next_job = job
                        min_start_time = job.start_time
        return next_job

    def schedule(self):
        """
        对作业进行调度
        """
        sorted_jobs = sorted(self.jobs, key=lambda x: (x.start_time, x.job_id))
        for job in sorted_jobs:
            if job.processing_time == 0:
                continue
            factory = self.factories[job.factory_id]
            machine_idx = factory.available_machines.pop(0)
            start_time = max(job.start_time, factory.current_time)
            end_time = start_time + job.processing_time
            factory.current_time = end_time
            job.start_time = end_time
            job.end_time = end_time
            job.machine_id = machine_idx
            factory.available_machines.append(machine_idx)

在Scheduler类中，我们首先定义了一个辅助函数get_next_job()，用于获取下一个要处理的作业。具体来说，它遍历所有未完成的作业，并找到下一个可以处理的作业，即在工厂可用机器中且处理时间大于0的作业中，开始时间最早的作业。

然后，在schedule()函数中，我们对作业进行排序，并按照规则进行分配和调度。具体来说，我们遍历所有作业，对于每个作业，我们找到一个可用的机器，计算出作业的开始和结束时间，并更新工厂的当前时间和机器的可用状态。

最后，我们可以使用以下代码进行测试：

jobs = [
    Job(1, 1, 2),
    Job(2, 1, 3),
    Job(3, 2, 4),
    Job(4, 2, 1),
    Job(5, 3, 3),
    Job(6, 3, 2)
]

factories = {
    1: Factory(1, 2),
    2: Factory(2, 1),
    3: Factory(3, 2)
}

for job in jobs:
    job.start_time = 0

scheduler = Scheduler(jobs, factories)

for i in range(10):
    job = scheduler.get_next_job()
    if job is not None:
        factory = factories[job.factory_id]
        machine_idx = factory.available_machines[0]
        job.start_time = max(job.start_time, factory.current_time)
        job.machine_id = machine_idx
        factory.current_time = job.start_time + job.processing_time
        job.end_time = factory.current_time
        factory.available_machines.pop(0)
        factory.available_machines.append(machine_idx)
    scheduler.schedule()

for job in jobs:
    print("Job %d: factory %d, machine %d, start time %d, end time %d" %
          (job.job_id, job.factory_id, job.machine_id, job.start_time, job.end_time))

这个测试代码中，我们创建了6个作业和3个工厂，并将所有作业的开始时间初始化为0。然后，我们通过调用get_next_job()函数和schedule()函数，对作业进行分配和调度。最后，打印出每个作业的信息，包括所属工厂、分配的机器、开始时间和结束时间。

需要注意的是，这个测试代码只是一个简单的示例，实际应用中需要根据具体问题的要求进行修改和完善。