DRY (Don't Repeat Yourself) in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to avoid repeating the same logic in multiple places.

LLD

def calculate_area(radius):
    return [1] * radius * radius

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

Api

B3.14

Cradius

Darea

Attempts:

3 left

💡 Hint

Common Mistakes

Using the number 3.14 directly instead of a constant.

Using a constant like pi avoids repeating the value everywhere.

2fill in blank

medium

Complete the code to reuse the function instead of repeating the calculation.

LLD

def get_discounted_price(price, discount):
    return price - (price * discount)

final_price = [1](100, 0.1)

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

Acalculate_price

Bprice_after_discount

Cget_discounted_price

Ddiscount_price

Attempts:

3 left

💡 Hint

Common Mistakes

Calling a function that does not exist or misspelling the function name.

Calling get_discounted_price reuses the logic and avoids repetition.

3fill in blank

hard

Fix the error in the code to avoid repeating the same query logic.

LLD

def fetch_users():
    query = "SELECT * FROM users WHERE active = 1"
    return [1](query)

def fetch_admins():
    query = "SELECT * FROM users WHERE active = 1 AND role = 'admin'"
    return execute_query(query)

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

Aquery_execute

Brun_query

Cfetch_data

Dexecute_query

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function name that is not defined or inconsistent.

Using the same function execute_query avoids repeating query execution logic.

4fill in blank

hard

Fill both blanks to create a reusable function and call it correctly.

LLD

def [1](data):
    processed = [x * 2 for x in data]
    return processed

result = [2]([1, 2, 3])

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

Aprocess_data

Bprocess

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for function definition and call.

Defining and calling the function process_data avoids repeating processing logic.

5fill in blank

hard

Fill all three blanks to create a reusable class method and use it properly.

LLD

class Calculator:
    def [1](self, a, b):
        return a + b

calc = Calculator()
result = calc.[2](5, 7)
print([3])

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

Aadd

Cresult

Dsum

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for method and call, or printing wrong variable.

Defining the method add, calling it, and printing the result avoids repeating addition logic.

Practice

1. What is the main goal of the DRY principle in system design?

easy

A. To avoid repeating code or design to keep systems simple

B. To write as much code as possible for clarity

C. To duplicate modules for faster development

D. To create multiple versions of the same component

Solution

1. Step 1: Understand the meaning of DRY

   DRY stands for "Don't Repeat Yourself," which means avoiding repeated code or design.

2. Step 2: Identify the goal of DRY

   The goal is to keep systems simple, maintainable, and reduce bugs by reusing components.

3. Final Answer:

   To avoid repeating code or design to keep systems simple -> Option A

4. Quick Check:

   DRY = Avoid repetition [OK]

Hint: DRY means write once, use many times [OK]

Common Mistakes:

• Thinking DRY means writing more code
• Believing duplication speeds development
• Confusing DRY with writing multiple versions

2. Which of the following is a correct way to follow DRY in system design?

easy

A. Creating reusable components or modules

B. Ignoring code reuse to save time

C. Writing separate code for each similar task

D. Copy-pasting the same code in multiple modules

Solution

1. Step 1: Identify DRY best practice

   DRY encourages reuse by creating components or modules that can be used multiple times.

2. Step 2: Evaluate options

   Copy-pasting or writing separate code repeats work, which breaks DRY. Ignoring reuse wastes effort.

3. Final Answer:

   Creating reusable components or modules -> Option A

4. Quick Check:

   Reuse = DRY [OK]

Hint: Reuse code with modules/components [OK]

Common Mistakes:

• Copy-pasting code instead of reusing
• Writing separate code for similar tasks
• Ignoring reuse to save time

3. Consider this pseudocode snippet following DRY:

function calculateTax(amount) {
  return amount * 0.1;
}

function calculateTotal(amount) {
  return amount + calculateTax(amount);
}

print(calculateTotal(100));

What is the output?

medium

A. 10

B. 100

C. 110

D. Syntax Error

Solution

1. Step 1: Calculate tax for amount 100

   Tax = 100 * 0.1 = 10

2. Step 2: Calculate total using tax

   Total = 100 + 10 = 110

3. Final Answer:

   110 -> Option C

4. Quick Check:

   100 + 10 = 110 [OK]

Hint: Add tax to amount using reusable function [OK]

Common Mistakes:

• Forgetting to add tax to amount
• Confusing tax amount with total
• Assuming syntax error without checking code

4. You see this code snippet violating DRY:

function sendEmailToUser1() {
  // send email logic
}

function sendEmailToUser2() {
  // send email logic
}

What is the best fix to follow DRY?

medium

A. Copy-paste send email logic in more functions

B. Create one function sendEmail(user) and reuse it

C. Keep both functions as is for clarity

D. Remove email sending completely

Solution

1. Step 1: Identify repeated code

   Both functions have the same email sending logic repeated.

2. Step 2: Refactor to reusable function

   Create one function with a parameter for user to reuse the logic.

3. Final Answer:

   Create one function sendEmail(user) and reuse it -> Option B

4. Quick Check:

   Refactor repeated code = DRY [OK]

Hint: Use parameters to reuse functions [OK]

Common Mistakes:

• Leaving duplicate functions unchanged
• Copy-pasting code more times
• Removing needed functionality

5. You design a system with multiple services needing user authentication. To follow DRY, which approach is best?

hard

A. Implement authentication logic separately in each service

B. Skip authentication to reduce complexity

C. Copy authentication code into each service for speed

D. Create a shared authentication service used by all services

Solution

1. Step 1: Identify repeated authentication logic

   Multiple services need the same authentication, so repeating code breaks DRY.

2. Step 2: Use a shared authentication service

   Centralizing authentication logic in one service allows reuse and easier maintenance.

3. Final Answer:

   Create a shared authentication service used by all services -> Option D

4. Quick Check:

   Shared service = DRY in system design [OK]

Hint: Centralize common logic in shared services [OK]

Common Mistakes:

• Duplicating authentication code in each service
• Skipping authentication for simplicity
• Copy-pasting code instead of sharing