Booking conflict resolution in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary cause of booking conflicts in a shared resource system?

Consider a system where multiple users can book the same resource (e.g., a meeting room). What is the main reason booking conflicts occur?

A The resource is physically unavailable due to maintenance.

B Users forget to confirm their bookings after selecting a time slot.

C The system does not allow cancellations or modifications of bookings.

D Multiple users attempt to book overlapping time slots for the same resource simultaneously.

💡 Hint

Think about what happens when two people try to reserve the same room at the same time.

Booking conflicts happen mainly when two or more users try to reserve the same resource for overlapping times. This causes the system to have to decide which booking to accept.

❓ Architecture

intermediate

Which component is essential to prevent booking conflicts in a distributed booking system?

In a distributed booking system, which component helps ensure that two users cannot book the same resource at the same time?

A A load balancer to distribute booking requests evenly.

B A caching layer to store booking data temporarily.

C A centralized locking mechanism that locks the resource during booking.

D A notification service to alert users of booking status.

💡 Hint

Think about how to make sure only one booking can happen at a time for the same resource.

A centralized locking mechanism ensures that when one user is booking a resource, others cannot book it simultaneously, preventing conflicts.

❓ scaling

advanced

How to scale a booking system to handle thousands of simultaneous booking requests without conflicts?

You need to design a booking system that supports thousands of users booking resources at the same time. Which approach best helps to scale while preventing booking conflicts?

A Cache all bookings on the client side to reduce server load.

B Partition resources by time slots and use distributed locks per partition to allow parallel bookings.

C Allow bookings without locks and resolve conflicts manually later.

D Use a single global lock for all bookings to ensure consistency.

💡 Hint

Think about dividing the problem to handle many requests at once without blocking all bookings.

Partitioning resources by time slots and using distributed locks per partition allows multiple bookings to proceed in parallel without conflicts, improving scalability.

❓ tradeoff

advanced

What is a tradeoff when using optimistic concurrency control for booking conflict resolution?

Optimistic concurrency control lets users book without locking but checks for conflicts before finalizing. What is a key tradeoff of this approach?

A Users may experience booking failures and need to retry, causing possible frustration.

B It guarantees zero booking conflicts with no retries needed.

C It requires a centralized lock, reducing system availability.

D It prevents any concurrent booking attempts from happening.

💡 Hint

Think about what happens if two users book the same slot without locking first.

Optimistic concurrency control allows conflicts to happen but detects them before finalizing. This means users might have to retry their booking if a conflict is found.

❓ estimation

expert

Estimate the maximum booking requests per second a system can handle with a single resource and a locking mechanism that takes 50ms per booking.

Assuming each booking request requires a lock on the resource that takes 50 milliseconds to process, what is the maximum number of booking requests per second the system can handle for that single resource?

A 20 requests per second

B 50 requests per second

C 200 requests per second

D 500 requests per second

💡 Hint

Calculate how many 50ms intervals fit into one second.

One second has 1000 milliseconds. Each booking takes 50 milliseconds, so 1000 / 50 = 20 bookings per second.

Practice

1. What is the primary goal of booking conflict resolution in a system?

easy

A. To ignore booking times and accept all requests

B. To allow multiple bookings at the same time for efficiency

C. To delete all previous bookings automatically

D. To prevent overlapping reservations for the same resource

Solution

1. Step 1: Understand booking conflict concept

   Booking conflict resolution ensures no two bookings overlap for the same resource.

2. Step 2: Identify the goal of conflict resolution

   The goal is to prevent double-booking by checking time overlaps and rejecting or adjusting conflicting bookings.

3. Final Answer:

   To prevent overlapping reservations for the same resource -> Option D

4. Quick Check:

   Conflict resolution = prevent overlaps [OK]

Hint: Conflict resolution means no double bookings allowed [OK]

Common Mistakes:

• Thinking multiple bookings at same time are allowed
• Assuming conflict resolution deletes bookings
• Ignoring time overlaps in bookings

2. Which of the following code snippets correctly checks if two time intervals (start1, end1) and (start2, end2) overlap?

easy

A. if start1 < end2 and start2 < end1: overlap

B. if start1 > end2 or start2 > end1: overlap

C. if end1 <= start2 or end2 <= start1: no overlap

D. if start1 == end2 or start2 == end1: overlap

Solution

1. Step 1: Understand time interval overlap condition

   Two intervals overlap if one starts before the other ends and vice versa.

2. Step 2: Match condition to code

   Condition start1 < end2 and start2 < end1 correctly detects overlap.

3. Final Answer:

   if start1 < end2 and start2 < end1: overlap -> Option A

4. Quick Check:

   Overlap check = start1 < end2 and start2 < end1 [OK]

Hint: Overlap if intervals cross each other in time [OK]

Common Mistakes:

• Using <= instead of < causing false negatives
• Confusing no overlap with overlap conditions
• Checking equality as overlap incorrectly

3. Given existing bookings: [(10, 12), (14, 16), (18, 20)], what will be the result of checking a new booking (12, 14) for conflict using the overlap condition start1 < end2 and start2 < end1?

medium

A. Conflict with (10, 12)

B. Conflict with (14, 16)

C. No conflict

D. Conflict with all existing bookings

Solution

1. Step 1: Check overlap with each existing booking

   Check (12,14) against (10,12): 12 < 12 is false, no overlap. Against (14,16): 12 < 16 true, 14 < 14 false, no overlap. Against (18,20): no overlap.

2. Step 2: Determine conflict result

   No overlaps found with any existing booking intervals.

3. Final Answer:

   No conflict -> Option C

4. Quick Check:

   New booking fits between existing without overlap [OK]

Hint: Check each existing booking for overlap carefully [OK]

Common Mistakes:

• Assuming touching intervals overlap
• Ignoring strict less than condition
• Confusing start and end times

4. Identify the bug in this booking conflict check code snippet:

def is_conflict(new_start, new_end, existing_bookings):
    for start, end in existing_bookings:
        if new_start <= end and new_end >= start:
            return True
    return False

medium

A. The condition incorrectly uses <= and >= causing false conflicts

B. The condition allows bookings that end exactly when another starts

C. The function does not return anything

D. The loop does not iterate over bookings

Solution

1. Step 1: Analyze the overlap condition

   Condition new_start <= end and new_end >= start includes cases where bookings just touch at edges, causing false conflicts.

2. Step 2: Correct condition for strict overlap

   Use new_start < end and new_end > start to detect true overlaps only.

3. Final Answer:

   The condition incorrectly uses <= and >= causing false conflicts -> Option A

4. Quick Check:

   Use strict inequalities for overlap [OK]

Hint: Use < and >, not <= or >= for overlap checks [OK]

Common Mistakes:

• Using inclusive operators causing false positives
• Forgetting to return a boolean
• Not iterating over all bookings

5. You are designing a booking system for meeting rooms. To handle conflict resolution at scale, which approach is best to ensure no overlapping bookings and high performance?

hard

A. Use a centralized lock on the entire booking database for each new booking

B. Check for conflicts by querying only relevant time slots and use optimistic concurrency control

C. Allow all bookings and resolve conflicts manually later

D. Store bookings without timestamps and rely on user honesty

Solution

1. Step 1: Understand scalability and conflict resolution needs

   Centralized locking (Use a centralized lock on the entire booking database for each new booking) causes bottlenecks; manual or no checks (Options C, D) cause errors.

2. Step 2: Choose efficient conflict detection method

   Querying only relevant time slots reduces load; optimistic concurrency control handles race conditions efficiently.

3. Final Answer:

   Check for conflicts by querying only relevant time slots and use optimistic concurrency control -> Option B

4. Quick Check:

   Efficient conflict check + concurrency control = scalable solution [OK]

Hint: Query relevant slots + optimistic control for scalable conflict resolution [OK]

Common Mistakes:

• Using global locks causing slowdowns
• Ignoring concurrency issues
• Not filtering bookings by time before checking