Job Scheduling with Deadlines in DSA Python - Build from Scratch

Job Scheduling with Deadlines

📖 Scenario: You are managing a small workshop where several jobs need to be completed. Each job has a deadline and a profit if finished on time. You want to schedule jobs to maximize your total profit without missing deadlines.

🎯 Goal: Build a simple program that schedules jobs based on their deadlines and profits to maximize total profit.

📋 What You'll Learn

Create a list of jobs with exact given details

Add a variable to track the maximum deadline

Implement a simple scheduling logic to select jobs

Print the scheduled jobs and total profit

💡 Why This Matters

🌍 Real World

Job scheduling is used in factories, computer task management, and project planning to maximize efficiency and profit.

💼 Career

Understanding job scheduling helps in roles like operations management, software engineering, and data analysis where task prioritization is key.

1

Create the list of jobs

Create a list called jobs with these exact tuples representing jobs: (1, 4, 20), (2, 1, 10), (3, 1, 40), (4, 1, 30). Each tuple is (job_id, deadline, profit).

DSA Python

# Create the list of jobs with given tuples
# Your code here

Hint

Use a list of tuples exactly as shown. Each tuple has three numbers: job id, deadline, and profit.

2

Find the maximum deadline

Create a variable called max_deadline that stores the highest deadline value from the jobs list.

DSA Python

jobs = [(1, 4, 20), (2, 1, 10), (3, 1, 40), (4, 1, 30)]
# Find the maximum deadline from jobs
# Your code here

Hint

Use the max() function with a generator expression to get the highest deadline.

3

Schedule jobs to maximize profit

Sort the jobs list by profit in descending order. Create a list called result of size max_deadline filled with None. Then, for each job in sorted order, try to schedule it in the latest available slot before its deadline by checking result from job[1] - 1 down to 0. If a slot is free (None), assign the job's id to that slot.

DSA Python

jobs = [(1, 4, 20), (2, 1, 10), (3, 1, 40), (4, 1, 30)]
max_deadline = max(job[1] for job in jobs)
# Sort jobs by profit descending and schedule them
# Your code here

Hint

Sort jobs by profit. Use a list to track scheduled slots. Assign jobs to the latest free slot before their deadline.

4

Print scheduled jobs and total profit

Print the scheduled jobs in order by printing the result list. Then calculate the total profit by summing profits of scheduled jobs and print it as Total Profit: <value>.

DSA Python

jobs = [(1, 4, 20), (2, 1, 10), (3, 1, 40), (4, 1, 30)]
max_deadline = max(job[1] for job in jobs)
jobs.sort(key=lambda x: x[2], reverse=True)
result = [None] * max_deadline
for job in jobs:
    for slot in range(job[1] - 1, -1, -1):
        if result[slot] is None:
            result[slot] = job[0]
            break
# Print the scheduled jobs and total profit
# Your code here

Hint

Print the list of scheduled job IDs. Then sum profits of these jobs and print the total.

Practice

1. What is the main goal of the Job Scheduling with Deadlines problem?

easy

A. Schedule jobs in the order they arrive without considering deadlines

B. Maximize the total profit by scheduling jobs before their deadlines

C. Minimize the number of jobs scheduled

D. Maximize the number of jobs scheduled regardless of profit

Solution

1. Step 1: Understand the problem goal

   The problem aims to schedule jobs so that each job finishes before its deadline.

2. Step 2: Identify the optimization criteria

   We want to maximize the total profit earned from scheduled jobs, not just the count.

3. Final Answer:

   Maximize the total profit by scheduling jobs before their deadlines -> Option B

4. Quick Check:

   Goal = Maximize profit [OK]

Hint: Focus on maximizing profit within deadlines [OK]

Common Mistakes:

• Thinking it's about scheduling all jobs regardless of profit
• Confusing deadline with job duration
• Assuming jobs can be scheduled after deadlines

2. Which of the following is the correct Python syntax to sort a list of jobs by their profit in descending order? Assume each job is a tuple (job_id, deadline, profit).

easy

A. jobs.sort(key=lambda x: x[2], reverse=True)

B. jobs.sort(key=lambda x: x[1], reverse=True)

C. jobs.sort(reverse=True, key=lambda x: x[0])

D. jobs.sort(key=lambda x: x[2])

Solution

1. Step 1: Identify the sorting key

   Profit is at index 2 in each job tuple, so key=lambda x: x[2] is correct.

2. Step 2: Sort in descending order

   Use reverse=True to sort profits from highest to lowest.

3. Final Answer:

   jobs.sort(key=lambda x: x[2], reverse=True) -> Option A

4. Quick Check:

   Sort by profit descending = jobs.sort(key=lambda x: x[2], reverse=True) [OK]

Hint: Sort by profit descending using key and reverse=True [OK]

Common Mistakes:

• Sorting by deadline instead of profit
• Forgetting reverse=True for descending order
• Using wrong tuple index for profit

3. What is the output of the following code snippet?

jobs = [(1, 4, 20), (2, 1, 10), (3, 1, 40), (4, 1, 30)]
jobs.sort(key=lambda x: x[2], reverse=True)
slots = [False] * 4
result = [None] * 4
for job in jobs:
    for j in range(min(4, job[1]) - 1, -1, -1):
        if not slots[j]:
            slots[j] = True
            result[j] = job[0]
            break
print(result)

medium

A. [3, None, None, 1]

B. [4, 3, 1, None]

C. [1, 4, 3, None]

D. [None, 3, 4, 1]

Solution

1. Step 1: Sort jobs by profit descending

   Sorted jobs: (3,1,40), (4,1,30), (1,4,20), (2,1,10)

2. Step 2: Schedule jobs in latest available slot before deadline

   Job 3: deadline 1, slot 0 free -> assign slot 0 = 3 Job 4: deadline 1, slot 0 taken, no earlier slot -> skip Job 1: deadline 4, slots 3 to 0 checked, slot 3 free -> assign slot 3 = 1 Job 2: deadline 1, slot 0 taken, no earlier slot -> skip

3. Final Answer:

   [3, None, None, 1] -> Option A

4. Quick Check:

   Result = [3, None, None, 1] [OK]

Hint: Assign jobs from highest profit to latest free slot before deadline [OK]

Common Mistakes:

• Assigning jobs to earliest slot instead of latest
• Not sorting jobs by profit first
• Confusing slot indices with deadlines

4. The following code attempts to schedule jobs with deadlines and maximize profit. What is the bug?

jobs = [(1, 2, 100), (2, 1, 19), (3, 2, 27), (4, 1, 25), (5, 3, 15)]
jobs.sort(key=lambda x: x[2])  # Sort by profit ascending
slots = [False] * 3
result = [None] * 3
for job in jobs:
    for j in range(min(3, job[1])):
        if not slots[j]:
            slots[j] = True
            result[j] = job[0]
            break
print(result)

medium

A. Result array is not initialized properly

B. Slots array size is too small

C. Inner loop should iterate backwards from deadline to 0

D. Jobs are sorted by profit ascending instead of descending

Solution

1. Step 1: Check sorting order

   Jobs are sorted by profit ascending, which schedules low profit jobs first.

2. Step 2: Understand scheduling impact

   Scheduling low profit jobs first reduces total profit; sorting must be descending.

3. Final Answer:

   Jobs are sorted by profit ascending instead of descending -> Option D

4. Quick Check:

   Sort order must be descending for max profit [OK]

Hint: Sort jobs by profit descending to maximize profit [OK]

Common Mistakes:

• Sorting by ascending profit
• Iterating slots forward instead of backward (less critical here)
• Ignoring slot size mismatch

5. Given jobs [(1, 2, 100), (2, 1, 19), (3, 2, 27), (4, 1, 25), (5, 3, 15)], what is the maximum total profit achievable by scheduling jobs before their deadlines? Assume each job takes 1 unit time and only one job can be scheduled at a time.

hard

A. 115

B. 152

C. 142

D. 127

Solution

1. Step 1: Sort jobs by profit descending

   Sorted jobs: (1,2,100), (3,2,27), (4,1,25), (2,1,19), (5,3,15)

2. Step 2: Schedule jobs in latest free slot before deadline

   Job 1: deadline 2, assign slot 2 (index 1) Job 3: deadline 2, assign slot 1 (index 0) Job 4: deadline 1, slot 0 taken, skip Job 2: deadline 1, slot 0 taken, skip Job 5: deadline 3, assign slot 3 (index 2)

3. Step 3: Calculate total profit

   Scheduled jobs: 1 (100), 3 (27), 5 (15) Total profit = 100 + 27 + 15 = 142

4. Final Answer:

   142 -> Option C

5. Quick Check:

   Total profit = 142 [OK]

Hint: Schedule highest profit jobs first in latest free slot [OK]

Common Mistakes:

• Scheduling jobs without sorting by profit
• Assigning jobs to earliest slot instead of latest
• Counting jobs beyond deadline slots