Emergency handling in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a basic emergency handler function.

LLD

def handle_emergency(event):
    if event == [1]:
        print("Alert: Fire detected!")

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

A"flood"

B"fire"

C"earthquake"

D"power_outage"

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect event strings like 'Fire' (case sensitive)

Using unrelated events like 'flood' or 'earthquake'

The emergency handler should detect a fire event, so the correct event string is "fire".

2fill in blank

medium

Complete the code to raise an alert when an emergency is detected.

LLD

def raise_alert(level):
    if level >= [1]:
        print("Emergency alert raised!")

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

A3

B5

C10

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Setting the threshold too high like 10, missing moderate emergencies

Setting the threshold too low like 1, causing false alerts

The alert should be raised for emergencies with level 3 or higher, so the threshold is 3.

3fill in blank

hard

Fix the error in the emergency response function to correctly handle unknown events.

LLD

def emergency_response(event):
    match event:
        case "fire":
            print("Activate sprinklers")
        case "flood":
            print("Evacuate area")
        case _:
            print([1])

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

A"Unknown emergency! Stay alert."

BUnknown emergency! Stay alert.

CUnknown emergency

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting quotes causing syntax errors

Using incomplete or incorrect messages

The print statement requires a string literal, so the message must be enclosed in quotes.

4fill in blank

hard

Fill both blanks to create a dictionary mapping emergency types to their response actions.

LLD

emergency_actions = {
    [1]: "Call fire department",
    [2]: "Shut off electricity"
}

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

A"fire"

B"flood"

C"power_outage"

D"earthquake"

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names instead of string keys

Mixing up emergency types and response actions

The dictionary keys should be emergency types as strings: "fire" and "power_outage".

5fill in blank

hard

Fill all three blanks to implement a function that logs emergency events with their severity and timestamp.

LLD

def log_emergency(event, severity):
    from datetime import datetime
    log_entry = {
        [1]: event,
        [2]: severity,
        [3]: datetime.now().isoformat()
    }
    print(log_entry)

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

A"event_type"

B"severity_level"

C"timestamp"

D"date"

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent or unclear key names

Using variable names instead of string keys

The dictionary keys should be descriptive strings: "event_type", "severity_level", and "timestamp".

Practice

1. What is the primary goal of an emergency handling system in system design?

easy

A. To detect problems quickly and protect people and property

B. To increase system performance under normal conditions

C. To reduce the cost of hardware components

D. To provide detailed analytics for marketing purposes

Solution

1. Step 1: Understand the purpose of emergency handling

   Emergency handling systems are designed to detect issues fast and act to prevent harm.

2. Step 2: Identify the main goal

   The main goal is to protect people and property by quick detection and response.

3. Final Answer:

   To detect problems quickly and protect people and property -> Option A

4. Quick Check:

   Emergency handling = fast detection and protection [OK]

Hint: Focus on safety and speed in emergencies [OK]

Common Mistakes:

• Confusing emergency handling with performance optimization
• Thinking it is about cost reduction
• Assuming it is for marketing analytics

2. Which component is NOT typically part of an emergency handling system?

easy

A. Safety action controller

B. Alerting system

C. Detection module

D. User interface for marketing

Solution

1. Step 1: List typical components

   Emergency handling systems usually have detection, alerting, safety actions, and logging.

2. Step 2: Identify the unrelated component

   User interface for marketing is unrelated to emergency handling functions.

3. Final Answer:

   User interface for marketing -> Option D

4. Quick Check:

   Marketing UI ≠ emergency handling component [OK]

Hint: Exclude marketing from emergency system parts [OK]

Common Mistakes:

• Including unrelated business components
• Confusing alerting with marketing notifications
• Ignoring safety action controllers

3. Consider this simplified emergency system flow:
if sensor.detect(): alert.send(); safety.activate(); log.record()
What happens if sensor.detect() returns false?

medium

A. Alert, safety, and log actions all execute

B. Only alert and safety actions execute

C. No actions execute

D. Only log action executes

Solution

1. Step 1: Analyze the if condition

   The actions alert.send(), safety.activate(), and log.record() run only if sensor.detect() is true.

2. Step 2: Determine behavior when sensor.detect() is false

   If sensor.detect() returns false, the code block inside if does not run, so no actions execute.

3. Final Answer:

   No actions execute -> Option C

4. Quick Check:

   False detection = no emergency actions [OK]

Hint: If condition false means skip all inside actions [OK]

Common Mistakes:

• Assuming log always runs regardless of detection
• Thinking alert or safety run without detection
• Confusing else behavior when none is given

4. In an emergency system, this code snippet causes a problem:
if sensor.detect():
alert.send()
safety.activate()
log.record()
What is the main issue?

medium

A. Missing indentation causes log.record() to run always

B. safety.activate() is outside the if block

C. alert.send() is not called properly

D. log.record() runs even if no detection

Solution

1. Step 1: Check code indentation

   log.record() is not indented under the if, so it runs always.

2. Step 2: Understand impact

   log.record() runs even when sensor.detect() is false, which is incorrect behavior.

3. Final Answer:

   Missing indentation causes log.record() to run always -> Option A

4. Quick Check:

   Indentation controls conditional execution [OK]

Hint: Indent all emergency actions inside detection check [OK]

Common Mistakes:

• Ignoring indentation importance
• Assuming all lines are inside if by default
• Confusing which lines run conditionally

5. You design an emergency system that must alert multiple teams and log events reliably. Which design approach best ensures alerts are sent even if one alert service fails?

hard

A. Send alerts sequentially and stop on first failure

B. Send alerts in parallel with retries and fallback logging

C. Send alerts only to the primary team to reduce complexity

D. Log events only after all alerts succeed

Solution

1. Step 1: Understand reliability needs

   To ensure alerts reach multiple teams, sending in parallel avoids blocking on one failure.

2. Step 2: Use retries and fallback logging

   Retries help recover from temporary failures; fallback logging records failures for later review.

3. Final Answer:

   Send alerts in parallel with retries and fallback logging -> Option B

4. Quick Check:

   Parallel + retries = reliable alerting [OK]

Hint: Use parallel alerts with retries for reliability [OK]

Common Mistakes:

• Stopping alerts on first failure
• Ignoring retries and fallback mechanisms
• Reducing alert recipients to simplify