Interpreter pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the interface method for interpreting expressions.

LLD

interface Expression {
    void [1]();
}

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

Aexecute

Binterpret

Cevaluate

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using generic method names like execute or run which are not standard in this pattern.

The standard method name in the Interpreter pattern is interpret, which defines how an expression is evaluated.

2fill in blank

medium

Complete the code to implement a terminal expression class that stores a value.

LLD

class NumberExpression implements Expression {
    private int number;
    public NumberExpression(int number) {
        this.number = number;
    }
    public void [1]() {
        System.out.println(number);
    }
}

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

Aexecute

Brun

Cevaluate

Dinterpret

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different method name than the interface, causing a compile error.

The interpret method is implemented to define how the terminal expression evaluates itself.

3fill in blank

hard

Fix the error in the non-terminal expression class by completing the method to interpret both sub-expressions.

LLD

class AddExpression implements Expression {
    private Expression left, right;
    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
    public void [1]() {
        left.interpret();
        right.interpret();
        System.out.println("Add operation done");
    }
}

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

Aevaluate

Bexecute

Cinterpret

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name that does not override the interface method, causing runtime errors.

The method must be named interpret to correctly implement the Expression interface and interpret both sub-expressions.

4fill in blank

hard

Fill both blanks to complete the context class that uses an expression to interpret input.

LLD

class Context {
    private Expression expression;
    public Context(Expression expression) {
        this.[1] = expression;
    }
    public void [2]() {
        expression.interpret();
    }
}

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

Aexpression

Bexpr

Cinterpret

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different field name that does not match the class field.

Using a method name other than interpret.

The field name is expression and the method to trigger interpretation is interpret.

5fill in blank

hard

Fill all three blanks to complete the client code that builds and interprets an expression tree.

LLD

Expression left = new NumberExpression([1]);
Expression right = new NumberExpression([2]);
Expression add = new AddExpression(left, right);
Context context = new Context([3]);
context.interpret();

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

A5

B3

Cadd

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the wrong expression to the context.

Using non-integer values for NumberExpression.

The numbers 5 and 3 are used to create terminal expressions. Then the add expression is passed to the context for interpretation.

Practice

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

easy

A. To manage user authentication and authorization

B. To define a grammar for a simple language and interpret sentences in that language

C. To store data persistently in a database

D. To create multiple threads for parallel processing

Solution

1. Step 1: Understand the role of the Interpreter pattern

   The Interpreter pattern defines a way to evaluate sentences in a language by representing grammar rules as classes.

2. Step 2: Match the purpose with options

   Only To define a grammar for a simple language and interpret sentences in that language correctly describes defining a grammar and interpreting sentences, which is the core of the Interpreter pattern.

3. Final Answer:

   To define a grammar for a simple language and interpret sentences in that language -> Option B

4. Quick Check:

   Interpreter pattern = Define grammar and interpret [OK]

Hint: Interpreter pattern = grammar + interpretation [OK]

Common Mistakes:

• Confusing Interpreter with concurrency patterns
• Thinking it manages data storage
• Mixing it up with security patterns

2. Which of the following is the correct way to define an interpret() method in an expression interface for the Interpreter pattern?

easy

A. def interpret(context): return self

B. def interpret(): return context

C. def interpret(self): return None

D. def interpret(self, context): pass

Solution

1. Step 1: Recall the method signature for interpret in Interpreter pattern

   The interpret method usually takes a context parameter and is defined as an instance method with self.

2. Step 2: Compare options with correct signature

   def interpret(self, context): pass correctly defines interpret(self, context) with a placeholder pass, matching the pattern's interface.

3. Final Answer:

   def interpret(self, context): pass -> Option D

4. Quick Check:

   interpret method = instance method with context parameter [OK]

Hint: interpret() needs self and context parameters [OK]

Common Mistakes:

• Omitting self parameter in method
• Not passing context argument
• Returning wrong values or missing parameters

3. Given the following Python-like pseudocode for an Interpreter pattern, what will be the output?

class TerminalExpression:
    def __init__(self, data):
        self.data = data
    def interpret(self, context):
        return self.data in context

class AndExpression:
    def __init__(self, expr1, expr2):
        self.expr1 = expr1
        self.expr2 = expr2
    def interpret(self, context):
        return self.expr1.interpret(context) and self.expr2.interpret(context)

expr1 = TerminalExpression('apple')
expr2 = TerminalExpression('banana')
and_expr = AndExpression(expr1, expr2)
print(and_expr.interpret(['apple', 'banana', 'cherry']))

medium

A. True

B. False

C. Error due to missing method

D. None

Solution

1. Step 1: Evaluate TerminalExpression interpret calls

   expr1.interpret checks if 'apple' is in the list ['apple', 'banana', 'cherry'] -> True. expr2.interpret checks if 'banana' is in the list -> True.

2. Step 2: Evaluate AndExpression interpret

   AndExpression returns True if both expr1 and expr2 interpret return True. Both are True, so result is True.

3. Final Answer:

   True -> Option A

4. Quick Check:

   Both terms in list -> True [OK]

Hint: AND expression true only if both sub-expressions true [OK]

Common Mistakes:

• Assuming 'in' checks keys instead of values
• Confusing AND with OR logic
• Forgetting to return boolean result

4. In the following code snippet implementing the Interpreter pattern, what is the error?

class OrExpression:
    def __init__(self, expr1, expr2):
        self.expr1 = expr1
        self.expr2 = expr2
    def interpret(self, context):
        return self.expr1.interpret(context) | self.expr2.interpret(context)

medium

A. Using bitwise OR operator instead of logical OR

B. Missing return statement in interpret method

C. Incorrect constructor parameters

D. interpret method missing context parameter

Solution

1. Step 1: Identify operator used in interpret method

   The code uses the bitwise OR operator '|' instead of the logical OR operator 'or' for boolean logic.

2. Step 2: Explain why this is an error

   Bitwise OR can cause unexpected results with booleans and is not the intended logical operation for combining expressions.

3. Final Answer:

   Using bitwise OR operator instead of logical OR -> Option A

4. Quick Check:

   Logical OR needs 'or', not '|' [OK]

Hint: Use 'or' for logical OR, not '|' [OK]

Common Mistakes:

• Confusing bitwise and logical operators
• Forgetting to return a value
• Incorrect method signatures

5. You want to design a system using the Interpreter pattern to evaluate complex search queries combining keywords with AND, OR, and NOT. Which design approach best supports scalability and easy extension?

hard

A. Store all queries as strings and parse them manually each time without classes

B. Use a single class with many if-else statements to handle all expression types

C. Create separate classes for TerminalExpression, AndExpression, OrExpression, and NotExpression implementing a common interface

D. Implement only TerminalExpression and handle AND/OR/NOT outside the interpreter

Solution

1. Step 1: Identify design principles for Interpreter pattern

   Using separate classes for each expression type following a common interface allows modularity and easy extension.

2. Step 2: Evaluate options for scalability and maintainability

   Create separate classes for TerminalExpression, AndExpression, OrExpression, and NotExpression implementing a common interface supports adding new expressions without changing existing code, unlike monolithic if-else or manual parsing.

3. Final Answer:

   Create separate classes for TerminalExpression, AndExpression, OrExpression, and NotExpression implementing a common interface -> Option C

4. Quick Check:

   Separate classes + common interface = scalable design [OK]

Hint: Use separate classes per expression type for easy extension [OK]

Common Mistakes:

• Using one class with complex conditionals
• Parsing strings manually every time
• Handling logic outside interpreter classes