Create Job_scheduling.py

Job_scheduling.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+
+"""
+Author : Mohit Kumar
+Job Sequencing Problem implemented in python
+"""
+from collections import namedtuple
+from typing import List
+
+
+class Scheduling:
+    def __init__(self, jobs: List[int]) -> None:
+        """
+        Assign jobs as instance of class Scheduling
+        """
+        self.jobs = jobs
+
+    def schedule(self, total_jobs: int, deadline: List[int]) -> List[int]:
+        """
+        Parameteres  : total_jobs  and list of deadline of jobs
+        Returns : List of jobs_id which are profitable  and can be done before
+                  deadline
+        >>> a = Scheduling([(0, 13, 10),(1, 2, 20),(2, 33, 30),(3, 16, 40)])
+        >>> a.schedule( 3, [3, 4, 5])
+        [(1, 2, 20), (2, 33, 30)]
+        >>> a = Scheduling([(0, 13, 10),(1, 2, 20),(2, 33, 30),(3, 16, 40)])
+        >>> a.schedule( 4, [13, 2, 33, 16])
+        [(1, 2, 20), (2, 33, 30), (3, 16, 40)]
+        """
+        self.j = [self.jobs[1]]
+        self.x = 2
+        while self.x < total_jobs:
+            self.k = self.j.copy()
+            self.k.append(self.jobs[self.x])
+            self.x += 1
+            if self.feasible(self.k, deadline):
+                self.j = self.k.copy()
+
+        return self.j
+
+    def feasible(self, profit_jobs: List[int], deadline: List[int]) -> bool:
+        """
+        Parameters : list of current profitable jobs within deadline
+                     list of deadline of jobs
+        Returns : true if k[-1] job is profitable to us else false
+        >>> a = Scheduling([(0, 13, 10),(1, 2, 20),(2, 33, 30),(3, 16, 40)])
+        >>> a.feasible( [0], [2, 13, 16, 33] )
+        True
+        >>> a = Scheduling([(0, 13, 10),(1, 2, 20),(2, 33, 30),(3, 16, 40)])
+        >>> a.feasible([0], [2, 13, 16, 33] )
+        True
+        """
+
+        self.tmp = profit_jobs
+        self.is_feasible = True
+
+        i = 0
+        j = 1
+        k = 0
+
+        while i < len(self.tmp):
+            while j < len(self.tmp):
+                self.index1 = self.jobs.index(self.tmp[i])
+                self.index2 = self.jobs.index(self.tmp[j])
+                j += 1
+                if deadline[self.index1] > deadline[self.index2]:
+                    (self.tmp[i], self.tmp[j]) = (
+                        self.tmp[j],
+                        self.tmp[i],
+                    )
+            i += 1
+
+        while k < len(self.tmp):
+            self.job = self.tmp[k]
+            if self.job in self.jobs:
+                self.jobindex = self.jobs.index(self.job)
+            else:
+                self.jobindex = 0
+            self.dlineval = deadline[self.jobindex]
+            self.ftest = k + 1
+            k += 1
+            if self.dlineval < self.ftest:
+                self.is_feasible = False
+                break
+        return self.is_feasible
+
+
+def main():
+    job = namedtuple("job", "job_id deadline profit")
+    jobs = [
+        job(0, 0, 0),
+        job(1, 2, 46),
+        job(2, 4, 52),
+        job(3, 3, 30),
+        job(4, 3, 36),
+        job(5, 2, 56),
+        job(6, 1, 40),
+    ]
+    # midresult stores jobs in sorting order of deadline
+    midresult = []
+    for i in range(len(jobs)):
+        current_job = []
+        current_job.extend((jobs[i].deadline, jobs[i].profit, jobs[i].job_id))
+        midresult.append(current_job)
+    midresult.sort(key=lambda k: (k[0], -k[1]))
+    (deadline, profit, jobs) = map(list, zip(*midresult))
+
+    scheduling_jobs = Scheduling(jobs)
+    scheduled_jobs = scheduling_jobs.schedule(len(jobs), deadline)
+    print(f"\n Jobs {scheduled_jobs}")
+
+    finalprofit = []
+    finaldl = []
+
+    for i, item in enumerate(scheduled_jobs):
+        jobsindex = jobs.index(item)
+        finalprofit.append(profit[jobsindex])
+        finaldl.append(deadline[jobsindex])
+
+    print(f"\n Profit {finalprofit}")
+    print(f"\n Deadline {finaldl}")
+
+
+if __name__ == "__main__":
+    main()