Queue-based task processing in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main advantage of using a queue in task processing?

Imagine you have many tasks to complete one after another. Why would using a queue help in managing these tasks?

A It allows tasks to be processed in the order they arrive, ensuring fairness.

B It processes all tasks at the same time, speeding up completion.

C It randomly selects tasks to process, increasing unpredictability.

D It deletes tasks automatically after adding them to the queue.

💡 Hint

Think about how a line at a store works.

A queue processes tasks in the order they arrive (first-in, first-out), which keeps things fair and organized.

❓ Predict Output

intermediate

What is the output of this queue processing code?

Consider this Python code that simulates a simple queue processing tasks:

Agentic AI

from collections import deque
queue = deque()
queue.append('task1')
queue.append('task2')
processed = []
while queue:
    task = queue.popleft()
    processed.append(task + '_done')
print(processed)

A ['task2_done', 'task1_done']

B ['task1_done', 'task2_done']

C ['task1', 'task2']

D []

💡 Hint

Remember, popleft() removes items from the front of the queue.

The code processes tasks in the order they were added, appending '_done' to each.

❓ Model Choice

advanced

Which model architecture best suits queue-based task processing in AI agents?

You want an AI agent to handle tasks arriving in a queue and decide the next best task to process based on priority and dependencies. Which model architecture fits best?

A Recurrent Neural Network (RNN) to remember past tasks and predict next tasks.

B Convolutional Neural Network (CNN) to analyze image data of tasks.

C Transformer model with attention to weigh task priorities and dependencies.

D Simple linear regression to predict task completion time.

💡 Hint

Think about models that handle sequences and relationships well.

Transformers use attention mechanisms to focus on important parts of input, ideal for weighing task priorities and dependencies in a queue.

❓ Hyperparameter

advanced

Which hyperparameter adjustment improves queue task processing throughput?

You have an AI system processing tasks from a queue. You want to increase throughput without losing accuracy. Which hyperparameter change helps most?

A Reduce number of layers to simplify the model.

B Decrease learning rate to slow down training.

C Increase dropout rate to prevent overfitting.

D Increase batch size to process more tasks at once.

💡 Hint

Think about how processing multiple tasks together affects speed.

Increasing batch size allows processing more tasks simultaneously, improving throughput.

🔧 Debug

expert

Why does this queue processing code cause a runtime error?

Review this Python code snippet for processing tasks in a queue. It raises an error when run. What is the cause?

Agentic AI

tasks = ['task1', 'task2', 'task3']
queue = []
for task in tasks:
    queue.append(task)
while queue:
    current = queue.pop(0)
    if current == 'task1':
        queue.remove('task3')
    if current == 'task2':
        queue.remove('task3')
    print(f'Processed {current}')

A Removing 'task3' while iterating causes a ValueError if 'task3' is not in the queue.

B Using pop(0) on a list is not allowed and causes an AttributeError.

C The queue is empty before the loop starts, causing an IndexError.

D The print statement syntax is invalid and causes a SyntaxError.

💡 Hint

Consider what happens when you remove an item from a list that might not be there.

When 'task2' is processed, the code tries to remove 'task3'. If 'task3' was already removed, this causes a ValueError.

Practice

1. What is the main purpose of queue-based task processing in agentic AI?

easy

A. To process all tasks simultaneously

B. To keep tasks in order and process them one by one

C. To randomly select tasks for processing

D. To delete tasks without processing

Solution

1. Step 1: Understand queue behavior

   A queue stores tasks in the order they arrive, so the first task added is the first processed.

2. Step 2: Identify the purpose in task processing

   This order ensures tasks are handled one by one without confusion or overlap.

3. Final Answer:

   To keep tasks in order and process them one by one -> Option B

4. Quick Check:

   Queue = ordered, one-by-one processing [OK]

Hint: Remember: queues process tasks FIFO (first in, first out) [OK]

Common Mistakes:

• Thinking tasks run all at once
• Assuming tasks are processed randomly
• Believing tasks get deleted without processing

2. Which of the following is the correct way to add a task to a queue in Python?

easy

A. queue.append(task)

B. queue.pop(task)

C. queue.remove(task)

D. queue.insert(0, task)

Solution

1. Step 1: Recall queue addition method

   In Python, adding to the end of a list (queue) uses append().

2. Step 2: Check other options

   pop() removes items, remove() deletes by value, insert(0, task) adds to front, not end.

3. Final Answer:

   queue.append(task) -> Option A

4. Quick Check:

   Adding task = append() [OK]

Hint: Add tasks with append() to keep queue order [OK]

Common Mistakes:

• Using pop() which removes tasks
• Using remove() which deletes by value
• Inserting at front breaks queue order

3. Given the Python code below, what will be printed?

tasks = []
tasks.append('task1')
tasks.append('task2')
processed = tasks.pop(0)
print(processed)

medium

A. task2

B. None

C. task1

D. IndexError

Solution

1. Step 1: Understand queue operations in code

   Tasks are added with append, so tasks = ['task1', 'task2'].

2. Step 2: Analyze pop(0) effect

   pop(0) removes and returns the first item, 'task1'.

3. Final Answer:

   task1 -> Option C

4. Quick Check:

   pop(0) returns first task [OK]

Hint: pop(0) removes first item in list [OK]

Common Mistakes:

• Thinking pop(0) removes last item
• Expecting an error from pop(0)
• Confusing pop() with pop(-1)

4. What is wrong with this queue processing code?

tasks = []
tasks.append('task1')
tasks.append('task2')
processed = tasks.pop()
print(processed)

medium

A. It removes the last task instead of the first

B. It causes an IndexError

C. It adds tasks incorrectly

D. It prints None

Solution

1. Step 1: Understand pop() without index

   pop() without argument removes the last item in the list.

2. Step 2: Compare with queue behavior

   Queue should remove the first task (pop(0)), so this removes tasks in wrong order.

3. Final Answer:

   It removes the last task instead of the first -> Option A

4. Quick Check:

   pop() removes last, not first [OK]

Hint: pop() removes last; use pop(0) for queue front [OK]

Common Mistakes:

• Assuming pop() removes first item
• Expecting an error from pop()
• Confusing append() with pop()

5. You want to process tasks in order but also prioritize urgent tasks immediately. Which queue-based approach fits best?

hard

A. Use a single queue and always pop from the front

B. Randomly pick tasks from the queue to process

C. Use a stack to process tasks last-in, first-out

D. Use two queues: one for urgent tasks processed first, then normal tasks

Solution

1. Step 1: Understand the need for prioritization

   Urgent tasks must be processed before normal tasks, so a single queue is not enough.

2. Step 2: Choose a structure supporting priority

   Two queues let urgent tasks be handled first, then normal tasks, preserving order within each.

3. Final Answer:

   Use two queues: one for urgent tasks processed first, then normal tasks -> Option D

4. Quick Check:

   Two queues = priority handling [OK]

Hint: Separate urgent and normal tasks in two queues [OK]

Common Mistakes:

• Using one queue loses priority order
• Using stack reverses task order
• Random picking breaks order and priority