Booking conflict resolution in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if two bookings overlap.

LLD

def is_conflict(booking1, booking2):
    return booking1.end_time [1] booking2.start_time

Drag options to blanks, or click blank then click option'

A<=

B>

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<=' causes missing conflicts when bookings overlap.

Two bookings conflict if the end time of the first booking is after the start time of the second booking.

2fill in blank

medium

Complete the code to add a booking only if no conflicts exist.

LLD

def add_booking(bookings, new_booking):
    for b in bookings:
        if is_conflict(b, new_booking):
            return False
    bookings.append([1])
    return True

Drag options to blanks, or click blank then click option'

Anew_booking

Bb

Cbookings

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Appending an existing booking instead of the new one.

We append the new booking to the list only if no conflicts are found.

3fill in blank

hard

Fix the error in the conflict check to correctly detect overlapping bookings.

LLD

def is_conflict(booking1, booking2):
    return booking1.start_time [1] booking2.end_time and booking1.end_time [2] booking2.start_time

Drag options to blanks, or click blank then click option'

A<

B>

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= or >= causes incorrect overlap detection.

Two bookings overlap if booking1 starts before booking2 ends and booking1 ends after booking2 starts.

4fill in blank

hard

Fill both blanks to create a function that returns all conflicting bookings for a new booking.

LLD

def find_conflicts(bookings, new_booking):
    conflicts = []
    for b in bookings:
        if b.start_time [1] new_booking.end_time and b.end_time [2] new_booking.start_time:
            conflicts.append(b)
    return conflicts

Drag options to blanks, or click blank then click option'

A<

B>

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= or >= causes missing some conflicts.

We check if existing booking starts before new booking ends and ends after new booking starts to find conflicts.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps booking IDs to their durations for bookings longer than 1 hour.

LLD

durations = {b.id: (b.end_time - b.start_time).total_seconds() / 3600 for b in bookings if (b.end_time - b.start_time) [1] [2] and b.id [3] None}

Drag options to blanks, or click blank then click option'

A>

B1

C!=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' for duration check.

Checking ID equality instead of inequality.

We filter bookings longer than 1 hour and ensure booking ID is not None.

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