Collision avoidance in swarms in Drone Programming - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of simple collision avoidance logic

Consider a swarm of drones where each drone checks the distance to its neighbors and adjusts its velocity to avoid collisions. What is the output of the following code snippet simulating one drone's velocity adjustment?

Drone Programming

neighbors = [(2, 3), (5, 5), (1, 1)]
current_position = (3, 3)
velocity = [1, 1]

for nx, ny in neighbors:
    dx = current_position[0] - nx
    dy = current_position[1] - ny
    dist_sq = dx*dx + dy*dy
    if dist_sq < 5:
        velocity[0] += dx
        velocity[1] += dy

print(tuple(velocity))

A (3, 3)

B (1, 1)

C (0, 0)

D (2, 1)

💡 Hint

Check which neighbors are within the distance threshold and how velocity changes.

The drone checks neighbors within distance squared less than 5. Only neighbor at (2,3) is close enough (dist_sq=(3-2)^2 + (3-3)^2 = 1 < 5). Neighbors at (5,5) and (1,1) have dist_sq=20 >=5. Velocity is adjusted by adding dx=1, dy=0 to [1,1], resulting in (2,1).

🧠 Conceptual

intermediate

Key principle behind collision avoidance in swarms

What is the main principle that allows drones in a swarm to avoid collisions while moving together?

A Each drone moves randomly without considering others

B Each drone maintains a minimum distance from neighbors by adjusting velocity

C Drones stop moving when they detect others nearby

D Drones follow a fixed path ignoring neighbors

💡 Hint

Think about how drones keep safe space around themselves.

Collision avoidance relies on drones sensing neighbors and adjusting their velocity to keep a safe distance, preventing crashes while moving cohesively.

🔧 Debug

advanced

Identify the error causing collision in swarm simulation

The following code is intended to prevent collisions by adjusting drone velocities. However, collisions still occur. What is the bug?

Drone Programming

def avoid_collision(position, neighbors):
    velocity = [0, 0]
    for nx, ny in neighbors:
        dx = position[0] - nx
        dy = position[1] - ny
        dist_sq = dx*dx + dy*dy
        if dist_sq < 4:
            velocity[0] -= dx
            velocity[1] -= dy
    return velocity

# Drone at (3,3) with neighbors
print(avoid_collision((3,3), [(2,3), (4,4), (3,5)]))

A The velocity update should add dx and dy instead of subtracting

B The distance threshold is too large causing false positives

C The distance calculation uses wrong signs causing incorrect velocity adjustment

D The function does not normalize the velocity vector

💡 Hint

Check how dx and dy are calculated and used to update velocity.

The code calculates dx and dy as position minus neighbor, but then subtracts dx and dy from velocity, which reverses the intended avoidance direction. This causes drones to move toward neighbors instead of away, causing collisions.

📝 Syntax

advanced

Syntax error in collision avoidance velocity update

Which option contains the correct syntax for updating a drone's velocity to avoid neighbors within a threshold?

Drone Programming

neighbors = [(1,2), (3,4)]
position = (2,2)
velocity = [0,0]
for nx, ny in neighbors:
    dx = position[0] - nx
    dy = position[1] - ny
    dist_sq = dx*dx + dy*dy
    if dist_sq < 5
        velocity[0] += dx
        velocity[1] += dy
print(velocity)

A Add colon after if condition: if dist_sq < 5:

B Replace parentheses with brackets in if condition: if [dist_sq < 5]:

C Change if to while: while dist_sq < 5:

D Remove indentation before velocity updates

💡 Hint

Check the syntax of the if statement.

Python requires a colon at the end of an if statement. Missing colon causes SyntaxError. Other options cause syntax or logic errors.

🚀 Application

expert

Calculate number of drones avoiding collision in a swarm

Given a swarm of 5 drones at positions [(0,0), (1,1), (3,3), (5,5), (1,0)], each drone avoids neighbors closer than distance 2 by adjusting velocity. How many drones will adjust their velocity in one update cycle?

A 3

B 4

C 2

D 5

💡 Hint

Check pairs of drones closer than distance 2 and count how many have at least one neighbor that close.

Drones at (0,0), (1,1), and (1,0) have neighbors within distance 2, so they adjust velocity. Drones at (3,3) and (5,5) are too far from others to adjust. So 3 drones adjust velocity.

Practice

1. What is the main purpose of collision avoidance in drone swarms?

easy

A. To improve camera quality

B. To increase drone speed

C. To reduce battery usage

D. To keep drones from crashing into each other

Solution

1. Step 1: Understand collision avoidance goal

   Collision avoidance is designed to prevent drones from hitting each other.

2. Step 2: Compare options with goal

   Only To keep drones from crashing into each other matches the goal of preventing crashes.

3. Final Answer:

   To keep drones from crashing into each other -> Option D

4. Quick Check:

   Collision avoidance = prevent crashes [OK]

Hint: Collision avoidance means no crashes between drones [OK]

Common Mistakes:

• Confusing collision avoidance with speed control
• Thinking it saves battery directly
• Assuming it improves camera quality

2. Which of the following code snippets correctly checks if two drones are too close (distance less than 5 units)?

easy

A. if distance == 5:

B. if distance > 5:

C. if distance < 5:

D. if distance <= 5:

Solution

1. Step 1: Understand the condition for 'too close'

   'Too close' means distance is less than 5 units.

2. Step 2: Match condition with code

   Only 'if distance < 5:' correctly checks if distance is less than 5.

3. Final Answer:

   if distance < 5: -> Option C

4. Quick Check:

   Less than 5 means too close [OK]

Hint: Use '<' to check if distance is less than threshold [OK]

Common Mistakes:

• Using '>' instead of '<'
• Using '==' which checks exact distance
• Using '<=' which includes equal distance

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

positions = [(0,0), (3,4), (10,10)]
threshold = 5
close_pairs = []
for i in range(len(positions)):
    for j in range(i+1, len(positions)):
        dx = positions[i][0] - positions[j][0]
        dy = positions[i][1] - positions[j][1]
        distance = (dx**2 + dy**2)**0.5
        if distance < threshold:
            close_pairs.append((i, j))
print(close_pairs)

medium

A. [(1, 2)]

B. []

C. [(0, 2)]

D. [(0, 1)]

Solution

1. Step 1: Calculate distances between pairs

   Distance between (0,0) and (3,4) is 5; between (0,0) and (10,10) is about 14.14; between (3,4) and (10,10) is about 9.22.

2. Step 2: Check which distances are less than threshold 5

   Only distance between (0,0) and (3,4) equals 5, but condition is distance < 5, so no pairs qualify except if distance is exactly 5 is excluded.

3. Step 3: Re-examine condition and output

   Since distance == 5 is not < 5, no pairs added. So output is empty list [].

4. Final Answer:

   [] -> Option B

5. Quick Check:

   Distance less than 5 pairs = [] [OK]

Hint: Calculate distances carefully and compare with threshold [OK]

Common Mistakes:

• Including pairs with distance equal to threshold
• Miscomputing distance formula
• Ignoring order of pairs

4. Identify the error in this collision avoidance code snippet:

for drone1 in swarm:
    for drone2 in swarm:
        if drone1 != drone2:
            dist = calculate_distance(drone1.position, drone2.position)
            if dist < safe_distance:
                drone1.move_away(drone2.position)

medium

A. It may cause multiple moves for one drone in one cycle

B. It compares the same drone with itself

C. It uses wrong distance calculation function

D. It does not check battery level before moving

Solution

1. Step 1: Analyze nested loops and conditions

   Each drone compares with every other drone, excluding itself.

2. Step 2: Consider move_away calls per cycle

   If multiple drones are too close, drone1 may call move_away multiple times in one loop, causing erratic movement.

3. Final Answer:

   It may cause multiple moves for one drone in one cycle -> Option A

4. Quick Check:

   Multiple moves per cycle = problem [OK]

Hint: Check if drone moves multiple times per loop [OK]

Common Mistakes:

• Thinking comparing drone with itself is allowed
• Assuming distance function is wrong without evidence
• Ignoring battery checks which are unrelated here

5. You want to improve collision avoidance in a large drone swarm by reducing unnecessary moves. Which approach is best?

hard

A. Only move drones when the closest neighbor is within a smaller threshold

B. Make every drone move away from all neighbors every cycle

C. Ignore collision avoidance for drones with full battery

D. Increase drone speed to quickly pass neighbors

Solution

1. Step 1: Understand problem of unnecessary moves

   Moving drones too often wastes energy and causes instability.

2. Step 2: Evaluate options for reducing moves

   Only move drones when the closest neighbor is within a smaller threshold reduces moves by only reacting to closest neighbors within a smaller safe distance, minimizing unnecessary moves.

3. Step 3: Reject other options

   Make every drone move away from all neighbors every cycle causes many moves; C ignores safety; D risks collisions by speeding up.

4. Final Answer:

   Only move drones when the closest neighbor is within a smaller threshold -> Option A

5. Quick Check:

   Reduce moves by tighter threshold [OK]

Hint: React only to closest neighbors within tight distance [OK]

Common Mistakes:

• Making drones move too often
• Ignoring safety for battery status
• Increasing speed without safety checks