Single Responsibility Principle in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a class that follows the Single Responsibility Principle by having only one reason to change.

LLD

class UserProfile:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def [1](self):
        # Save user data to database
        pass

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

Asave_to_database

Bsend_email

Ccalculate_age

Dgenerate_report

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing methods that handle unrelated tasks like sending emails or generating reports.

The method save_to_database fits the class responsibility of managing user profile data. Other options like sending email or generating reports are separate responsibilities.

2fill in blank

medium

Complete the code to separate responsibilities by creating a new class for sending notifications.

LLD

class NotificationService:
    def [1](self, message, user):
        # Send notification to user
        pass

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

Aupdate_profile

Bsave_user

Csend_notification

Dlog_error

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names that imply saving or updating user data in the notification class.

The method send_notification clearly belongs to a notification service, separating it from user data management.

3fill in blank

hard

Fix the error in the class design to ensure each class has a single responsibility.

LLD

class UserManager:
    def save_user(self, user):
        # Save user data
        pass

    def [1](self, user, message):
        # Send welcome email
        pass

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

Aupdate_user

Bsend_welcome_email

Cdelete_user

Dlog_activity

Attempts:

3 left

💡 Hint

Common Mistakes

Keeping email sending methods inside the user management class.

Sending emails should be handled by a separate class, so this method should be moved out. The method name send_welcome_email shows the responsibility that should be separated.

4fill in blank

hard

Fill both blanks to split responsibilities between user data management and logging activities.

LLD

class UserManager:
    def [1](self, user):
        # Save user data
        pass

class Logger:
    def [2](self, message):
        # Log activity
        pass

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

Asave_user

Bsend_email

Clog_activity

Ddelete_user

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing logging methods inside user management class.

save_user belongs to user data management, while log_activity belongs to logging. This separation follows the Single Responsibility Principle.

5fill in blank

hard

Fill all three blanks to correctly apply the Single Responsibility Principle by separating user profile, notification, and logging responsibilities.

LLD

class UserProfile:
    def [1](self, user):
        # Update user profile
        pass

class NotificationService:
    def [2](self, user, message):
        # Send notification
        pass

class Logger:
    def [3](self, message):
        # Log system events
        pass

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

Aupdate_profile

Bsend_notification

Clog_event

Ddelete_user

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names that do not match the class responsibility.

Each method name matches the class responsibility: updating profiles, sending notifications, and logging events. This clear separation follows the Single Responsibility Principle.

Practice

1. What does the Single Responsibility Principle (SRP) mean in simple terms?

easy

A. A class should handle multiple tasks to reduce the number of classes.

B. Each class or module should have only one job or responsibility.

C. All functions should be written in a single class for simplicity.

D. Classes should share responsibilities to improve collaboration.

Solution

1. Step 1: Understand the principle's core idea

   The Single Responsibility Principle states that a class or module should have one and only one reason to change, meaning it should do one job.

2. Step 2: Match the explanation to the options

   Each class or module should have only one job or responsibility. clearly states that each class or module should have only one job, which matches the principle.

3. Final Answer:

   Each class or module should have only one job or responsibility. -> Option B

4. Quick Check:

   Single Responsibility Principle = One job per class [OK]

Hint: One class, one job keeps code clean and simple [OK]

Common Mistakes:

• Thinking one class should do many tasks
• Believing all code should be in one place
• Confusing SRP with code reuse

2. Which of the following class names best follows the Single Responsibility Principle?

easy

A. UserAuthenticator

B. DataProcessorAndReportGenerator

C. UserManagerAndLogger

D. FileHandlerAndNetworkSender

Solution

1. Step 1: Analyze class names for single responsibility

   Classes with multiple responsibilities in their names violate SRP. UserManagerAndLogger, DataProcessorAndReportGenerator, and FileHandlerAndNetworkSender suggest multiple jobs.

2. Step 2: Identify the class with one clear responsibility

   UserAuthenticator clearly focuses on one task: authenticating users, which aligns with SRP.

3. Final Answer:

   UserAuthenticator -> Option A

4. Quick Check:

   Class name with one job = UserAuthenticator [OK]

Hint: Class name shows one clear job means SRP followed [OK]

Common Mistakes:

• Choosing classes with multiple jobs in name
• Ignoring SRP and mixing responsibilities
• Assuming longer names are better

3. Given this Python class, what is the main SRP violation?

class OrderProcessor:
    def process_order(self, order):
        self.validate_order(order)
        self.save_order(order)
        self.send_confirmation_email(order)

    def validate_order(self, order):
        pass

    def save_order(self, order):
        pass

    def send_confirmation_email(self, order):
        pass

medium

A. The class handles order validation, saving, and email sending, mixing responsibilities.

B. The class does not validate the order properly.

C. The class should not have any methods.

D. The class only processes orders and follows SRP.

Solution

1. Step 1: Identify responsibilities in the class

   The class OrderProcessor validates orders, saves orders, and sends confirmation emails. These are three distinct jobs.

2. Step 2: Check SRP compliance

   SRP requires one responsibility per class. Mixing validation, saving, and emailing violates SRP.

3. Final Answer:

   The class handles order validation, saving, and email sending, mixing responsibilities. -> Option A

4. Quick Check:

   Multiple jobs in one class = SRP violation [OK]

Hint: One class, one job; multiple jobs mean SRP broken [OK]

Common Mistakes:

• Ignoring multiple responsibilities in one class
• Thinking multiple methods mean multiple classes
• Assuming SRP allows all related tasks in one class

4. You have a class that both calculates taxes and generates invoices. What is the best way to fix this SRP violation?

medium

A. Combine tax calculation and invoice generation into a single method.

B. Add more methods to handle discounts and payments in the same class.

C. Split the class into two: one for tax calculation and one for invoice generation.

D. Remove tax calculation and keep only invoice generation.

Solution

1. Step 1: Identify the problem with the current class

   The class does two jobs: calculating taxes and generating invoices, which breaks SRP.

2. Step 2: Apply SRP by separating responsibilities

   Splitting into two classes, each with one responsibility, fixes the violation and improves maintainability.

3. Final Answer:

   Split the class into two: one for tax calculation and one for invoice generation. -> Option C

4. Quick Check:

   Separate classes for separate jobs = SRP fix [OK]

Hint: Split mixed jobs into separate classes to follow SRP [OK]

Common Mistakes:

• Adding unrelated methods to the same class
• Combining jobs into one method
• Removing needed functionality instead of splitting

5. You are designing a system for a library. Which design best follows the Single Responsibility Principle?

hard

A. A single class 'LibrarySystem' that manages books, users, loans, and notifications.

B. A single class 'Library' that handles everything including maintenance and reporting.

C. One class 'LibraryManager' that handles books and users, and another class 'LoanAndNotificationManager' for loans and alerts.

D. Separate classes: 'BookManager' for books, 'UserManager' for users, 'LoanManager' for loans, and 'NotificationService' for alerts.

Solution

1. Step 1: Analyze each design for responsibility separation

   Designs with a single class handling books, users, loans, and notifications, or a single class handling everything, put many jobs into one class, violating SRP. Designs with one class for books and users, and another for loans and notifications, mix multiple jobs in each class.

2. Step 2: Identify the design with clear single responsibilities

   Separate classes: 'BookManager' for books, 'UserManager' for users, 'LoanManager' for loans, and 'NotificationService' for alerts. separates concerns into distinct classes, each with one responsibility, following SRP best.

3. Final Answer:

   Separate classes: 'BookManager' for books, 'UserManager' for users, 'LoanManager' for loans, and 'NotificationService' for alerts. -> Option D

4. Quick Check:

   Separate classes for separate jobs = SRP followed [OK]

Hint: One class per job in system design follows SRP best [OK]

Common Mistakes:

• Grouping unrelated responsibilities in one class
• Mixing multiple jobs in fewer classes
• Ignoring SRP for convenience