Strategy pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the core benefit of the Strategy pattern

Which of the following best describes the main advantage of using the Strategy pattern in system design?

A It allows changing the algorithm's behavior at runtime without modifying the client code.

B It enforces a single fixed algorithm implementation throughout the system.

C It tightly couples the algorithm implementation with the client, improving performance.

D It eliminates the need for interfaces or abstract classes in the design.

💡 Hint

Think about flexibility and how behavior can be swapped easily.

The Strategy pattern enables selecting an algorithm's behavior at runtime by encapsulating algorithms in separate classes. This allows the client to switch strategies without changing its own code.

❓ Architecture

intermediate

Identifying components in a Strategy pattern architecture

In a typical Strategy pattern design, which component is responsible for selecting and using a specific strategy implementation?

A The Client code directly

B The Context class

C The Concrete Strategy classes

D The Strategy interface

💡 Hint

Consider which part holds a reference to the strategy and delegates work.

The Context class maintains a reference to a Strategy object and delegates the execution to it. It controls which strategy is used.

❓ scaling

advanced

Scaling Strategy pattern for multiple algorithms

You have a system using the Strategy pattern with 3 algorithms. The system needs to support 20 algorithms without changing the Context class. What is the best approach to scale this design?

A Implement each new algorithm as a new Concrete Strategy class and register them dynamically with the Context.

B Add all new algorithms as methods inside the Context class and use conditional statements to select them.

C Modify the Strategy interface to include all 20 algorithms as default methods.

D Create a single Concrete Strategy class that handles all algorithms internally with if-else logic.

💡 Hint

Think about how to keep the Context class unchanged and maintain open/closed principle.

Adding new algorithms as separate Concrete Strategy classes and registering them dynamically allows scaling without modifying the Context, adhering to open/closed principle.

❓ tradeoff

advanced

Tradeoffs when using the Strategy pattern

What is a common tradeoff when applying the Strategy pattern in a system design?

A Tight coupling between the Context and Concrete Strategies.

B Inability to add new algorithms without modifying existing code.

C Reduced flexibility in changing algorithms at runtime.

D Increased number of classes and objects, which can complicate the system structure.

💡 Hint

Consider the impact on codebase size and complexity.

The Strategy pattern increases the number of classes because each algorithm is a separate class, which can make the system more complex to manage.

❓ component

expert

Request flow in a Strategy pattern implementation

Consider a payment processing system using the Strategy pattern to support multiple payment methods (credit card, PayPal, crypto). Which sequence best describes the request flow when processing a payment?

A Client processes payment → Strategy selects Context → Context executes algorithm → Strategy returns result

B Strategy selects Context → Client processes payment → Context calls Strategy → Strategy executes algorithm

C Client selects payment method → Context sets corresponding Strategy → Context calls Strategy to process payment → Strategy executes algorithm

D Context processes payment → Client selects Strategy → Strategy executes algorithm → Context returns result

💡 Hint

Think about who chooses the strategy and who executes it.

The client chooses the payment method, the Context sets the appropriate Strategy, then delegates the payment processing to that Strategy.

Practice

1. What is the main purpose of the Strategy pattern in system design?

easy

A. To restrict object creation to a single instance

B. To allow selecting an algorithm's behavior at runtime without changing the client code

C. To define a fixed sequence of steps for an algorithm

D. To create a single global instance of a class

Solution

1. Step 1: Understand the Strategy pattern goal

   The Strategy pattern is designed to let you swap algorithms or behaviors dynamically without changing the client code.

2. Step 2: Compare options with pattern purpose

   To allow selecting an algorithm's behavior at runtime without changing the client code correctly states this purpose. Options A and B describe Singleton pattern, and C describes Template Method pattern.

3. Final Answer:

   To allow selecting an algorithm's behavior at runtime without changing the client code -> Option B

4. Quick Check:

   Strategy pattern = runtime algorithm selection [OK]

Hint: Strategy pattern = choose behavior at runtime [OK]

Common Mistakes:

• Confusing Strategy with Singleton pattern
• Thinking Strategy fixes algorithm steps
• Assuming Strategy creates single instances

2. Which of the following is the correct way to define a Strategy interface in a typical object-oriented language?

easy

A. class Strategy { void execute(); }

B. def Strategy(): pass

C. interface Strategy { void execute(); }

D. struct Strategy { void execute(); }

Solution

1. Step 1: Identify the correct syntax for interface definition

   In many object-oriented languages like Java or C#, interface keyword is used to define a Strategy interface with method signatures.

2. Step 2: Evaluate options

   interface Strategy { void execute(); } uses interface with method execute(), which is correct. class Strategy { void execute(); } defines a class, not an interface. def Strategy(): pass is Python syntax but incomplete. struct Strategy { void execute(); } uses struct which is not typical for interfaces.

3. Final Answer:

   interface Strategy { void execute(); } -> Option C

4. Quick Check:

   Strategy interface = interface with method [OK]

Hint: Strategy interface uses 'interface' keyword in OOP [OK]

Common Mistakes:

• Using class instead of interface for Strategy
• Confusing struct with interface
• Using incomplete or wrong language syntax

3. Given the following code snippet using the Strategy pattern, what will be the output?

class Context:
    def __init__(self, strategy):
        self.strategy = strategy
    def execute(self):
        return self.strategy.do_action()

class StrategyA:
    def do_action(self):
        return 'Action A'

class StrategyB:
    def do_action(self):
        return 'Action B'

context = Context(StrategyB())
print(context.execute())

medium

A. Action B

B. Action A

C. Error: StrategyB has no method do_action

D. None

Solution

1. Step 1: Trace object creation and method calls

   The Context is created with StrategyB() instance. Calling context.execute() calls StrategyB.do_action().

2. Step 2: Check StrategyB.do_action() return value

   StrategyB.do_action() returns the string 'Action B', so print(context.execute()) outputs 'Action B'.

3. Final Answer:

   Action B -> Option A

4. Quick Check:

   Context with StrategyB = 'Action B' output [OK]

Hint: Context calls strategy's method, output matches chosen strategy [OK]

Common Mistakes:

• Assuming default strategy is StrategyA
• Thinking method do_action is missing
• Confusing class and instance usage

4. Identify the error in the following Strategy pattern implementation:

class Context:
    def __init__(self, strategy):
        self.strategy = strategy
    def execute(self):
        return self.strategy.action()

class StrategyA:
    def do_action(self):
        return 'Action A'

context = Context(StrategyA())
print(context.execute())

medium

A. Context calls a method 'action' which does not exist in StrategyA

B. StrategyA class is missing the constructor

C. Context should not store strategy as an instance variable

D. No error, code runs correctly

Solution

1. Step 1: Compare method names between Context and StrategyA

   Context calls self.strategy.action(), but StrategyA defines do_action(), not action().

2. Step 2: Identify mismatch causing error

   This mismatch causes an AttributeError at runtime because action() is undefined in StrategyA.

3. Final Answer:

   Context calls a method 'action' which does not exist in StrategyA -> Option A

4. Quick Check:

   Method name mismatch = runtime error [OK]

Hint: Check method names match between context and strategy [OK]

Common Mistakes:

• Ignoring method name mismatch
• Assuming missing constructor causes error
• Thinking strategy should not be stored in context

5. You are designing a payment system that supports multiple payment methods (credit card, PayPal, cryptocurrency). How would applying the Strategy pattern improve your system design?

hard

A. It requires hardcoding all payment methods inside a single class

B. It forces all payment methods to share the same implementation details

C. It prevents runtime selection of payment methods

D. It allows adding new payment methods without changing existing code by defining each as a separate strategy

Solution

1. Step 1: Understand Strategy pattern benefits in payment methods

   Strategy pattern lets you define each payment method as a separate strategy class implementing a common interface.

2. Step 2: Analyze how this affects system design

   This design allows adding new payment methods easily without modifying existing code, and lets the system select payment method at runtime.

3. Final Answer:

   It allows adding new payment methods without changing existing code by defining each as a separate strategy -> Option D

4. Quick Check:

   Strategy pattern = easy extension and runtime choice [OK]

Hint: Strategy pattern enables easy addition and runtime choice [OK]

Common Mistakes:

• Thinking Strategy forces shared implementation
• Believing all methods must be hardcoded together
• Assuming runtime selection is not possible