When to use which creational pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Choosing the right creational pattern for object creation

You need to create multiple instances of a complex object with many optional parameters. Which creational pattern is best suited?

A Prototype pattern to clone existing objects

B Singleton pattern to ensure only one instance is created

C Factory Method pattern to create objects based on a common interface

D Builder pattern to construct the object step-by-step with optional parameters

💡 Hint

Think about a pattern that helps build complex objects with many optional parts.

The Builder pattern is ideal for creating complex objects step-by-step, especially when many optional parameters exist. Singleton restricts to one instance, Factory Method focuses on object creation via subclasses, and Prototype clones existing objects.

🧠 Conceptual

intermediate

Ensuring a single instance across the system

You want to ensure that only one instance of a configuration manager exists throughout your application. Which creational pattern should you use?

A Builder pattern to build configuration step-by-step

B Singleton pattern to restrict instantiation to one object

C Factory Method pattern to create configuration objects

D Prototype pattern to clone the configuration manager

💡 Hint

Think about a pattern that restricts the number of instances to one.

The Singleton pattern ensures only one instance of a class exists and provides a global point of access to it. Prototype clones objects, Factory Method creates objects via subclasses, and Builder constructs complex objects stepwise.

❓ Architecture

advanced

Designing a system with interchangeable product families

You are designing a system that needs to create families of related objects without specifying their concrete classes. Which creational pattern fits best?

A Abstract Factory pattern to create related objects without specifying classes

B Builder pattern to construct objects step-by-step

C Prototype pattern to clone existing objects

D Singleton pattern to ensure one instance of each product

💡 Hint

Consider a pattern that creates families of related objects together.

The Abstract Factory pattern provides an interface to create families of related or dependent objects without specifying their concrete classes. Builder focuses on stepwise construction, Singleton restricts instances, and Prototype clones objects.

❓ tradeoff

advanced

Tradeoffs between Prototype and Factory Method

Which statement best describes a key tradeoff between using Prototype and Factory Method patterns?

A Factory Method clones objects which is faster; Prototype creates new objects via subclassing.

B Prototype restricts to one instance; Factory Method builds complex objects stepwise.

C Prototype requires cloning existing objects which can be faster but needs an initial instance; Factory Method creates new objects via subclassing but may be slower.

D Factory Method ensures only one instance; Prototype creates families of related objects.

💡 Hint

Think about cloning versus subclass-based creation.

Prototype clones existing objects which can be efficient but requires an initial object to clone. Factory Method creates new objects by subclassing and overriding creation methods, which can be more flexible but sometimes slower.

❓ scaling

expert

Scaling object creation in a distributed system

You have a distributed system where multiple services need to create instances of a complex object efficiently and consistently. Which creational pattern or combination is best to ensure scalability and consistency?

A Use Prototype pattern to clone objects locally and Abstract Factory to ensure consistent families across services

B Use Singleton pattern on each service to ensure one instance per service and Builder pattern to construct objects

C Use Factory Method pattern with centralized registry to create objects and Builder pattern for complex construction

D Use Builder pattern only, letting each service build objects independently without coordination

💡 Hint

Consider cloning for efficiency and abstract factories for consistency across services.

Prototype allows efficient cloning locally, reducing creation overhead. Abstract Factory ensures consistent creation of related object families across distributed services. Singleton per service limits instances locally but not globally. Factory Method with centralized registry can become a bottleneck. Builder alone lacks coordination for consistency.

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