Distributed task allocation in Drone Programming - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is distributed task allocation in drone programming?

Distributed task allocation is a method where multiple drones share and assign tasks among themselves without a central controller, improving efficiency and fault tolerance.

beginner

Name one advantage of distributed task allocation over centralized task allocation.

Distributed task allocation reduces the risk of a single point of failure and allows drones to adapt dynamically to changes in the environment or drone availability.

intermediate

In distributed task allocation, what is a common way drones communicate to share tasks?

Drones often communicate using wireless networks to broadcast their status and task availability, enabling peer-to-peer negotiation for task assignments.

intermediate

Explain the role of a bidding mechanism in distributed task allocation.

A bidding mechanism allows drones to propose how suitable they are for a task based on criteria like distance or battery life, helping the group decide who should perform the task.

beginner

What challenge does distributed task allocation help solve in drone fleets?

It helps solve the challenge of coordinating many drones efficiently without relying on a single controller, which can be slow or fail under heavy load.

What is a key benefit of distributed task allocation in drones?

A No single point of failure

B Requires a central controller

C Slower task completion

D Less communication needed

Distributed task allocation avoids a single point of failure by letting drones share tasks among themselves.

Which method do drones use to decide who performs a task in distributed allocation?

A Random selection

B Bidding based on suitability

C Central server assignment

D First come, first served

Drones often use bidding mechanisms to decide task assignments based on suitability.

Distributed task allocation improves drone fleets by:

A Increasing dependency on one drone

B Reducing communication between drones

C Allowing dynamic task sharing

D Eliminating the need for wireless communication

It allows drones to dynamically share and assign tasks among themselves.

What is a common communication method for drones in distributed task allocation?

A Wired connections

B Physical signals

C No communication needed

D Wireless peer-to-peer networks

Drones use wireless peer-to-peer communication to share task information.

Which problem does distributed task allocation NOT solve?

A Battery life limitations

B Centralized bottlenecks

C Single point of failure

D Dynamic task changes

Battery life is a hardware limitation; distributed task allocation helps with coordination but not directly with battery constraints.

Describe how distributed task allocation works in a drone fleet and why it is useful.

Think about how drones talk and decide who does what without a boss.

Explain the role of bidding in distributed task allocation and how it helps drones decide task assignments.

Imagine drones 'competing' to do a job based on who is best suited.

Practice

1. What is the main goal of distributed task allocation in drone programming?

easy

A. To share work fairly among drones without a central controller

B. To make one drone do all the tasks quickly

C. To randomly assign tasks without any order

D. To stop drones from communicating with each other

Solution

1. Step 1: Understand distributed task allocation

   It means dividing tasks so all drones get work fairly.

2. Step 2: Identify the goal in drone programming

   The goal is to avoid a single controller and let drones share tasks efficiently.

3. Final Answer:

   To share work fairly among drones without a central controller -> Option A

4. Quick Check:

   Distributed task allocation = fair work sharing [OK]

Hint: Remember: share tasks fairly, no single boss drone [OK]

Common Mistakes:

• Thinking one drone does all tasks
• Assuming tasks are assigned randomly
• Believing drones don't communicate

2. Which of the following is the correct way to assign tasks to drones in a round-robin style using Python?

easy

A. task_index * len(drones)

B. len(drones) % task_index

C. task_index + len(drones)

D. task_index % len(drones)

Solution

1. Step 1: Understand round-robin assignment

   Round-robin cycles through drones by using modulo with drone count.

2. Step 2: Apply modulo operator correctly

   Using task_index % len(drones) cycles task indices over drone list indices.

3. Final Answer:

   task_index % len(drones) -> Option D

4. Quick Check:

   Modulo with drone count cycles tasks [OK]

Hint: Use modulo (%) with drone count to cycle tasks [OK]

Common Mistakes:

• Reversing modulo operands
• Adding or multiplying instead of modulo
• Using modulo with wrong variable

3. What will be the output of this code snippet?

tasks = ['scan', 'deliver', 'map', 'charge']
drones = ['droneA', 'droneB']
assignments = {}
for i, task in enumerate(tasks):
    drone = drones[i % len(drones)]
    assignments.setdefault(drone, []).append(task)
print(assignments)

medium

A. {'droneA': ['scan', 'map'], 'droneB': ['deliver', 'charge']}

B. {'droneA': ['scan', 'deliver'], 'droneB': ['map', 'charge']}

C. {'droneA': ['scan'], 'droneB': ['deliver', 'map', 'charge']}

D. {'droneA': ['charge'], 'droneB': ['scan', 'deliver', 'map']}

Solution

1. Step 1: Assign tasks using modulo

   Tasks are assigned to drones cycling through drones list by i % 2.

2. Step 2: Map tasks to drones

   Index 0: 'scan' -> droneA, 1: 'deliver' -> droneB, 2: 'map' -> droneA, 3: 'charge' -> droneB.

3. Final Answer:

   {'droneA': ['scan', 'map'], 'droneB': ['deliver', 'charge']} -> Option A

4. Quick Check:

   Modulo cycles tasks evenly [OK]

Hint: Match task index modulo drone count to assign tasks [OK]

Common Mistakes:

• Mixing task order in assignments
• Ignoring modulo cycling
• Appending tasks to wrong drone

4. Identify the error in this drone task allocation code:

drones = ['D1', 'D2', 'D3']
tasks = ['photo', 'survey', 'deliver']
assignments = {}
for i in range(len(tasks)):
    drone = drones[i // len(drones)]
    assignments.setdefault(drone, []).append(tasks[i])
print(assignments)

medium

A. assignments.setdefault is used incorrectly

B. Using range(len(tasks)) is incorrect for looping

C. Using integer division (//) instead of modulo (%) assigns all tasks to the first drone

D. The drones list should be empty

Solution

1. Step 1: Check drone index calculation

   Using i // len(drones) results in index 0 for i=0,1,2 (len(drones)=3), assigning all tasks to 'D1' instead of cycling round-robin.

2. Step 2: Identify correct operator

   Modulo (%) should be used to cycle through drone indices safely.

3. Final Answer:

   Using integer division (//) instead of modulo (%) assigns all tasks to the first drone -> Option C

4. Quick Check:

   Use modulo (%) to cycle indices [OK]

Hint: Use % not // to cycle through drone indices [OK]

Common Mistakes:

• Confusing // with %
• Thinking range(len(tasks)) is wrong
• Misusing setdefault method

5. You have 3 drones and 7 tasks. You want to assign tasks so each drone gets tasks in a round-robin way but skip any task named 'wait'. Which code snippet correctly implements this?

hard

A. assignments = {}
for i, task in enumerate(tasks):
if task == 'wait':
continue
drone = drones[len(drones) % i]
assignments.setdefault(drone, []).append(task)

B. assignments = {}
for i, task in enumerate(tasks):
drone = drones[i % len(drones)]
if task != 'wait':
assignments.setdefault(drone, []).append(task)

C. assignments = {}
for task in tasks:
if task == 'wait':
continue
drone = drones[tasks.index(task) % len(drones)]
assignments.setdefault(drone, []).append(task)

D. assignments = {}
for i in range(len(tasks)):
if tasks[i] == 'wait':
continue
drone = drones[i // len(drones)]
assignments.setdefault(drone, []).append(tasks[i])

Solution

1. Step 1: Filter out 'wait' tasks correctly

   Check task != 'wait' before assigning to drones.

2. Step 2: Assign tasks using modulo for round-robin

   Use i % len(drones) to cycle drones correctly.

3. Step 3: Avoid using index() inside loop to prevent errors with duplicates

   Using tasks.index(task) can cause wrong drone assignment if tasks repeat.

4. Final Answer:

   assignments = {} for i, task in enumerate(tasks): drone = drones[i % len(drones)] if task != 'wait': assignments.setdefault(drone, []).append(task) -> Option B

5. Quick Check:

   Filter first, then assign with modulo [OK]

Hint: Check task before assign; use modulo for drone cycling [OK]

Common Mistakes:

• Using integer division instead of modulo
• Using tasks.index() causing wrong assignments
• Not skipping 'wait' tasks properly