Strategy pattern in LLD - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Strategy pattern in software design?

The Strategy pattern is a design approach that lets you choose an algorithm's behavior at runtime. It defines a family of algorithms, encapsulates each one, and makes them interchangeable without changing the code that uses them.

beginner

How does the Strategy pattern help in system design?

It helps by separating the algorithm from the client using it. This makes the system flexible and easier to extend or modify without changing existing code, reducing bugs and improving maintainability.

intermediate

In the Strategy pattern, what roles do the Context and Strategy play?

The Context is the object that uses a Strategy to perform a task. The Strategy is an interface or abstract class that defines the algorithm. Concrete Strategies implement this interface with different behaviors.

beginner

Give a real-life example of the Strategy pattern.

Think of a navigation app that can choose different routes: fastest, shortest, or scenic. Each route calculation is a Strategy. The app (Context) picks the Strategy based on user choice without changing its core logic.

intermediate

What is a key advantage of using the Strategy pattern over conditional statements?

It avoids complex conditional logic by encapsulating each algorithm separately. This makes the code cleaner, easier to read, and simpler to add new algorithms without modifying existing code.

What does the Strategy pattern primarily allow you to do?

A Enforce a single instance of a class

B Create multiple instances of a class

C Change an algorithm's behavior at runtime

D Hide the internal details of an object

The Strategy pattern lets you select and change algorithms dynamically during program execution.

In the Strategy pattern, what is the role of the Context?

A Defines the algorithm interface

B Uses a Strategy to perform a task

C Manages object creation

D Implements a specific algorithm

The Context holds a reference to a Strategy and uses it to execute the algorithm.

Which of the following is NOT a benefit of the Strategy pattern?

A Improves code flexibility

B Reduces conditional statements

C Makes adding new algorithms easier

D Enforces a fixed algorithm at compile time

The Strategy pattern allows changing algorithms at runtime, not fixing them at compile time.

How does the Strategy pattern relate to the Open/Closed Principle?

A It supports it by allowing new strategies without changing existing code

B It violates it by modifying existing code

C It ignores it completely

D It enforces code duplication

The pattern supports the Open/Closed Principle by enabling new algorithms without altering existing code.

Which design pattern is often confused with Strategy but focuses on object creation?

A Factory pattern

B Observer pattern

C Decorator pattern

D Singleton pattern

The Factory pattern deals with creating objects, while Strategy deals with interchangeable algorithms.

Explain the Strategy pattern and how it improves software design.

Think about how you can swap behaviors without changing the main code.

Describe a real-world scenario where the Strategy pattern can be applied and why it is useful there.

Consider situations where you choose different ways to do the same task.

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