When to use which creational pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to choose the creational pattern that provides a single instance.

LLD

class DatabaseConnection:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return [1]

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

Acls._instance

Bself

CDatabaseConnection

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Returning self instead of the stored instance

Returning None causing errors

The Singleton pattern ensures only one instance exists. Returning cls._instance provides that single instance.

2fill in blank

medium

Complete the code to use the Factory Method pattern to create objects without specifying the exact class.

LLD

class AnimalFactory:
    def create_animal(self, animal_type):
        if animal_type == 'dog':
            return Dog()
        elif animal_type == 'cat':
            return [1]()

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

AAnimal

BDog

CCat

DPet

Attempts:

3 left

💡 Hint

Common Mistakes

Returning Dog instead of Cat

Returning a base class instead of specific class

The Factory Method creates objects based on input. To create a cat, return Cat().

3fill in blank

hard

Fix the error in the Builder pattern code to correctly build a product step by step.

LLD

class CarBuilder:
    def __init__(self):
        self.car = Car()

    def add_wheels(self):
        self.car.wheels = 4

    def add_engine(self):
        self.car.engine = 'V8'

    def get_car(self):
        return [1]

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

Aself

Bcar

CCar()

Dself.car

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a new Car instead of the built one

Returning undefined variable

The method should return the built car object stored in self.car.

4fill in blank

hard

Fill both blanks to complete the Abstract Factory pattern that creates families of related objects.

LLD

class GUIFactory:
    def create_button(self):
        return [1]()

    def create_checkbox(self):
        return [2]()

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

AWindowsButton

BLinuxButton

CWindowsCheckbox

DLinuxCheckbox

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing Windows and Linux classes

Using unrelated classes

Abstract Factory creates related objects. For Windows GUI, create WindowsButton and WindowsCheckbox.

5fill in blank

hard

Fill all three blanks to complete the Prototype pattern code that clones objects.

LLD

class Document:
    def __init__(self, content):
        self.content = content

    def clone(self):
        return Document([1])

original = Document('Report')
copy = original.clone()
copy.content = [2]
print(original.content, copy.content)  # [3]

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

Aself.content

B'Summary'

CReport Summary

Dcontent

Attempts:

3 left

💡 Hint

Common Mistakes

Passing undefined variable to clone

Changing original content instead of copy

The clone method copies the content from self.content. Then we change the copy's content to 'Summary'. The print shows original and copy contents.

Practice

1. Which creational pattern is best when you need only one instance of a class throughout the application?

easy

A. Singleton pattern

B. Factory pattern

C. Builder pattern

D. Prototype pattern

Solution

1. Step 1: Understand the requirement for a single instance

   The question asks for a pattern that ensures only one instance of a class exists.

2. Step 2: Match the pattern to the requirement

   Singleton pattern restricts instantiation to one object and provides a global access point.

3. Final Answer:

   Singleton pattern -> Option A

4. Quick Check:

   Single instance = Singleton [OK]

Hint: Single instance? Think Singleton pattern [OK]

Common Mistakes:

• Confusing Factory with Singleton
• Using Builder for single instance
• Thinking Prototype creates single instance

2. Which creational pattern allows creating different types of objects without specifying their concrete classes directly?

easy

A. Singleton pattern

B. Factory pattern

C. Builder pattern

D. Adapter pattern

Solution

1. Step 1: Identify the pattern for flexible object creation

   The question wants a pattern that creates objects without exposing the creation logic.

2. Step 2: Match the pattern to the description

   Factory pattern provides an interface to create objects but lets subclasses decide which class to instantiate.

3. Final Answer:

   Factory pattern -> Option B

4. Quick Check:

   Flexible object creation = Factory [OK]

Hint: Flexible creation? Use Factory pattern [OK]

Common Mistakes:

• Choosing Singleton for flexible creation
• Confusing Builder with Factory
• Selecting Adapter which is not creational

3. Consider this code snippet using the Builder pattern:

class CarBuilder {
  constructor() {
    this.car = new Car();
  }
  setColor(color) {
    this.car.color = color;
    return this;
  }
  setWheels(wheels) {
    this.car.wheels = wheels;
    return this;
  }
  build() {
    return this.car;
  }
}

const car = new CarBuilder().setColor('red').setWheels(4).build();
console.log(car.color, car.wheels);

What will be the output?

medium

A. red 4

B. undefined undefined

C. red undefined

D. Error: Car is not defined

Solution

1. Step 1: Check if Car class is defined

   The code uses new Car() but Car class is not defined anywhere, causing a runtime error.

2. Step 2: Understand the consequence of missing class

   Since Car is undefined, the code throws a ReferenceError before any properties are set.

3. Final Answer:

   Error: Car is not defined -> Option D

4. Quick Check:

   Missing class definition = ReferenceError [OK]

Hint: Check if all classes are defined before use [OK]

Common Mistakes:

• Assuming output is 'red 4' without Car class
• Ignoring missing class error
• Confusing Builder pattern with Factory output

4. You have a Singleton class implemented as below:

class Logger {
  constructor() {
    if (Logger.instance) {
      return Logger.instance;
    }
    this.logs = [];
    Logger.instance = this;
  }
  log(message) {
    this.logs.push(message);
  }
}

What is the main issue with this implementation?

medium

A. It creates a new instance every time

B. It does not store logs properly

C. It does not prevent multiple instances

D. It lacks a method to retrieve logs

Solution

1. Step 1: Analyze Singleton enforcement

   The constructor returns existing instance if present, but the implementation does not fully prevent multiple instances.

2. Step 2: Identify the issue in JavaScript context

   In JavaScript, this pattern works but can be bypassed by other means; better to use static method to get instance.

3. Final Answer:

   It does not prevent multiple instances -> Option C

4. Quick Check:

   Singleton enforcement flaw = It does not prevent multiple instances [OK]

Hint: Singleton needs controlled instance creation [OK]

Common Mistakes:

• Thinking logs are not stored
• Assuming new instance is always created
• Ignoring missing retrieval method

5. You are designing a system to create complex meal orders with many optional parts (drink, main dish, dessert). Which creational pattern is most suitable and why?

hard

A. Builder pattern, because it simplifies creating complex objects step-by-step

B. Singleton pattern, because only one meal order should exist

C. Factory pattern, because it creates different meal types without specifying details

D. Prototype pattern, because it clones existing meal orders

Solution

1. Step 1: Understand the complexity of the object

   Meal orders have many optional parts and require step-by-step construction.

2. Step 2: Match pattern to complex object creation

   Builder pattern is designed to build complex objects step-by-step, allowing optional parts to be added flexibly.

3. Final Answer:

   Builder pattern, because it simplifies creating complex objects step-by-step -> Option A

4. Quick Check:

   Complex object with options = Builder [OK]

Hint: Complex object? Use Builder pattern [OK]

Common Mistakes:

• Choosing Singleton for multiple orders
• Confusing Factory with Builder for complex objects
• Using Prototype without cloning need