Composite pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the base component interface in the Composite pattern.

LLD

interface Component {
    void [1]();
}

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

AaddChild

Boperation

CremoveChild

DgetChild

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing methods specific to composite like addChild instead of the common operation method.

The base component interface declares the common operation method that both leaf and composite classes implement.

2fill in blank

medium

Complete the code to add a child component in the Composite class.

LLD

class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void [1](Component component) {
        children.add(component);
    }

    public void operation() {
        for (Component child : children) {
            child.operation();
        }
    }
}

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

Aoperation

BremoveChild

CgetChild

DaddChild

Attempts:

3 left

💡 Hint

Common Mistakes

Using removeChild or getChild instead of addChild for adding components.

The Composite class manages child components by adding them with the addChild method.

3fill in blank

hard

Fix the error in the Leaf class operation method to correctly implement the Composite pattern.

LLD

class Leaf implements Component {
    public void [1]() {
        System.out.println("Leaf operation");
    }
}

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

AremoveChild

BaddChild

Coperation

DgetChild

Attempts:

3 left

💡 Hint

Common Mistakes

Using composite-specific methods like addChild in Leaf.

The Leaf class implements the operation method from the Component interface to perform its specific action.

4fill in blank

hard

Fill both blanks to define the Composite class constructor and initialize the children list.

LLD

class Composite implements Component {
    private List<Component> children;

    public Composite() {
        children = new [1]<>();
    }

    public void addChild(Component component) {
        children.[2](component);
    }
}

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

AArrayList

BLinkedList

Cadd

Dremove

Attempts:

3 left

💡 Hint

Common Mistakes

Using remove instead of add to add children.

Using LinkedList instead of ArrayList (both work but ArrayList is more common).

The Composite class initializes its children list with ArrayList and adds components using the add method.

5fill in blank

hard

Fill all three blanks to implement a recursive operation method in Composite that calls operation on all children.

LLD

class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void operation() {
        for ([1] : children) {
            [2].[3]();
        }
    }
}

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

AComponent child

Bchild

Coperation

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect loop variable type or name.

Forgetting to call the operation method on the child.

The for-each loop iterates over each child component, calling its operation method recursively.

Practice

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

easy

A. To create a single instance of a class

B. To separate interface from implementation

C. To provide a way to access elements of a collection sequentially

D. To treat individual objects and compositions of objects uniformly

Solution

1. Step 1: Understand the Composite pattern goal

   The Composite pattern allows treating individual objects and groups of objects the same way.

2. Step 2: Compare with other design patterns

   Other options describe different patterns: Singleton (A), Iterator (D), Bridge (B).

3. Final Answer:

   To treat individual objects and compositions of objects uniformly -> Option D

4. Quick Check:

   Composite pattern = treat objects uniformly [OK]

Hint: Composite = treat single and group objects the same [OK]

Common Mistakes:

• Confusing Composite with Singleton pattern
• Thinking Composite only manages single objects
• Mixing Composite with Iterator or Bridge patterns

2. Which of the following is the correct way to declare a composite interface method in a class diagram for the Composite pattern?

easy

A. int calculateSum(int a, int b);

B. void add(Component component);

C. String toString();

D. boolean equals(Object obj);

Solution

1. Step 1: Identify typical Composite interface methods

   Composite pattern usually includes methods like add(), remove(), and getChild() to manage children.

2. Step 2: Match method signature to Composite pattern

   Only void add(Component component); fits the pattern's purpose of managing child components.

3. Final Answer:

   void add(Component component); -> Option B

4. Quick Check:

   Composite interface method = add(Component) [OK]

Hint: Composite interface manages children with add/remove methods [OK]

Common Mistakes:

• Choosing unrelated method signatures
• Confusing standard Object methods with Composite methods
• Ignoring the need to manage child components

3. Given the following code snippet in a Composite pattern implementation, what will be the output?

class Component:
  def operation(self):
    pass

class Leaf(Component):
  def operation(self):
    return "Leaf"

class Composite(Component):
  def __init__(self):
    self.children = []
  def add(self, component):
    self.children.append(component)
  def operation(self):
    results = []
    for child in self.children:
      results.append(child.operation())
    return "Composite(" + ", ".join(results) + ")"

leaf1 = Leaf()
leaf2 = Leaf()
composite = Composite()
composite.add(leaf1)
composite.add(leaf2)
print(composite.operation())

medium

A. Composite(Leaf, Leaf)

B. Leaf, Leaf

C. Composite()

D. Leaf

Solution

1. Step 1: Understand Leaf operation output

   Each Leaf's operation returns the string "Leaf".

2. Step 2: Understand Composite operation output

   Composite calls operation on each child and joins results with commas inside "Composite(...)".

3. Final Answer:

   Composite(Leaf, Leaf) -> Option A

4. Quick Check:

   Composite operation = Composite(Leaf, Leaf) [OK]

Hint: Composite operation joins child operations in parentheses [OK]

Common Mistakes:

• Expecting just 'Leaf' output
• Ignoring the Composite wrapper in output
• Confusing list join syntax

4. In the following Composite pattern code, what is the main error?

class Component:
  def operation(self):
    pass

class Leaf(Component):
  def operation(self):
    return "Leaf"

class Composite(Component):
  def __init__(self):
    self.children = []
  def add(self, component):
    self.children.append(component)
  def operation(self):
    results = []
    for child in self.children:
      child.operation()
    return "Composite(" + ", ".join(results) + ")"

medium

A. The add method does not check component type

B. The Composite class does not initialize children list

C. The operation method does not collect child results

D. The Leaf class does not inherit from Component

Solution

1. Step 1: Analyze operation method in Composite

   The loop calls child.operation() but does not append results to the list.

2. Step 2: Identify missing result collection

   Without appending, results remains empty, causing incorrect output.

3. Final Answer:

   The operation method does not collect child results -> Option C

4. Quick Check:

   Missing append in loop = operation method error [OK]

Hint: Check if child results are collected in operation method [OK]

Common Mistakes:

• Ignoring missing append to results list
• Thinking add method type check is mandatory
• Assuming inheritance error without evidence

5. You are designing a UI framework using the Composite pattern. You want to add a feature to calculate the total number of visible elements in a nested component tree. Which approach best fits the Composite pattern principles?

hard

A. Add a countVisible() method to the Component interface, implemented by Leaf and Composite classes

B. Use a global counter variable updated externally during rendering

C. Only count visible elements in Leaf nodes, ignoring Composite nodes

D. Traverse the tree manually outside the classes to count visible elements

Solution

1. Step 1: Apply Composite pattern principle of uniformity

   Adding countVisible() to Component interface lets all nodes handle counting uniformly.

2. Step 2: Implement counting in Leaf and Composite

   Leaf returns 1 if visible, 0 otherwise; Composite sums counts from children.

3. Final Answer:

   Add a countVisible() method to the Component interface, implemented by Leaf and Composite classes -> Option A

4. Quick Check:

   Uniform method in Component = best Composite design [OK]

Hint: Add counting method to Component interface for uniformity [OK]

Common Mistakes:

• Using external counters breaking encapsulation
• Counting only leaves ignoring composites
• Manual traversal outside object methods