Prototype pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the Prototype interface method for cloning.

LLD

interface Prototype {
    Prototype [1]();
}

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

AnewInstance

Bclone

Ccopy

Dduplicate

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names like copy or duplicate which are not standard in Prototype pattern.

Forgetting to return the Prototype type.

The standard method name for creating a copy in the Prototype pattern is clone().

2fill in blank

medium

Complete the code to implement the clone method in a concrete prototype class.

LLD

class ConcretePrototype implements Prototype {
    private int id;
    ConcretePrototype(int id) {
        this.id = id;
    }
    public Prototype [1]() {
        return new ConcretePrototype(this.id);
    }
}

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

Acopy

Bduplicate

Cclone

DnewInstance

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different method name than declared in the interface.

Not returning a new instance.

The clone() method returns a new instance copying the current object's state.

3fill in blank

hard

Fix the error in the clone method to correctly copy the object state.

LLD

public Prototype clone() {
    return new ConcretePrototype([1]);
}

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

Anew id

Bid

Cprototype.id

Dthis.id

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined variables like prototype.id or new id.

Omitting 'this' causing ambiguity.

The clone method must use this.id to copy the current object's id.

4fill in blank

hard

Fill both blanks to create a prototype registry and clone an object from it.

LLD

class PrototypeRegistry {
    private Map<String, Prototype> prototypes = new HashMap<>();
    public void addPrototype(String key, Prototype prototype) {
        prototypes.put([1], [2]);
    }
    public Prototype getClone(String key) {
        return prototypes.get(key).clone();
    }
}

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

Akey

Bprototype

Cvalue

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping key and prototype in the put method.

Using undefined variables.

Use key as the map key and prototype as the value to store the prototype object.

5fill in blank

hard

Fill all three blanks to clone a prototype and modify its state.

LLD

Prototype original = registry.getClone([1]);
ConcretePrototype copy = (ConcretePrototype) original;
copy.[2] = [3];

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

A"item1"

Bid

C42

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect key strings.

Trying to call clone again instead of modifying the field.

Assigning a string to an integer field.

Clone the prototype with key "item1", then set its id to 42.

Practice

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

easy

A. To manage object creation through a factory

B. To enforce a single instance of a class

C. To separate interface from implementation

D. To create new objects by copying existing ones

Solution

1. Step 1: Understand the Prototype pattern concept

   The Prototype pattern focuses on creating new objects by cloning existing ones instead of building from scratch.

2. Step 2: Compare with other design patterns

   Singleton enforces one instance, Factory manages creation but not cloning, and Adapter separates interface from implementation.

3. Final Answer:

   To create new objects by copying existing ones -> Option D

4. Quick Check:

   Prototype pattern = cloning objects [OK]

Hint: Prototype means copy existing object, not create new from zero [OK]

Common Mistakes:

• Confusing Prototype with Singleton pattern
• Thinking Prototype creates objects from scratch
• Mixing Prototype with Factory pattern

2. Which of the following is the correct way to declare a clone method in a prototype interface?

easy

A. public void clone();

B. public Object clone();

C. public Object copy();

D. public void copy();

Solution

1. Step 1: Identify the clone method signature

   The clone method should return a new object copy, so it must return an Object type.

2. Step 2: Check method return type and name

   Only public Object clone(); correctly returns a cloned object. Void return types or different method names are incorrect.

3. Final Answer:

   public Object clone(); -> Option B

4. Quick Check:

   Clone method returns Object [OK]

Hint: Clone returns a new object, so return type must not be void [OK]

Common Mistakes:

• Using void return type for clone method
• Naming method copy instead of clone
• Not returning the cloned object

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

class Shape {
  int x, y;
  Shape(int x, int y) { this.x = x; this.y = y; }
  Shape clone() { return new Shape(x, y); }
}

Shape original = new Shape(5, 10);
Shape copy = original.clone();
System.out.println(copy.x + "," + copy.y);

medium

A. 5,10

B. 0,0

C. null,null

D. Compilation error

Solution

1. Step 1: Understand the clone method behavior

   The clone method creates a new Shape object with the same x and y values as the original.

2. Step 2: Trace the output of print statement

   Since original has x=5 and y=10, the cloned copy will also have these values, so output is "5,10".

3. Final Answer:

   5,10 -> Option A

4. Quick Check:

   Clone copies values correctly [OK]

Hint: Clone copies fields, so output matches original's values [OK]

Common Mistakes:

• Assuming clone returns null
• Expecting default values 0,0 instead of copied values
• Thinking clone causes compile error

4. Identify the error in this prototype clone method implementation:

class Document {
  String content;
  Document(String content) { this.content = content; }
  Document clone() {
    Document copy = this;
    return copy;
  }
}

medium

A. clone method returns the same object reference instead of a new copy

B. clone method should return void

C. clone method should not be inside the class

D. clone method should throw an exception

Solution

1. Step 1: Analyze the clone method implementation

   The method assigns this to copy, so it returns the same object reference, not a new object.

2. Step 2: Understand prototype cloning requirement

   Prototype pattern requires returning a new object copy, not the original reference.

3. Final Answer:

   clone method returns the same object reference instead of a new copy -> Option A

4. Quick Check:

   Clone must return new object, not this [OK]

Hint: Clone must create new object, not return this [OK]

Common Mistakes:

• Returning this instead of new object
• Changing return type to void
• Thinking clone must throw exception

5. You need to design a system where creating a complex object from scratch is expensive. Which approach best uses the Prototype pattern to improve performance?

hard

A. Use a Factory pattern to create new objects with different parameters

B. Create a new object from scratch every time to ensure uniqueness

C. Create a prototype object once and clone it whenever a new object is needed

D. Use a Singleton to share the same object instance everywhere

Solution

1. Step 1: Identify the problem of expensive object creation

   Creating complex objects from scratch is costly in time or resources.

2. Step 2: Apply Prototype pattern for efficient object creation

   By creating one prototype object and cloning it, we avoid repeated expensive construction.

3. Step 3: Compare other options

   Singleton shares one instance, not copies; Factory creates new objects but may be costly; creating from scratch every time is inefficient.

4. Final Answer:

   Create a prototype object once and clone it whenever a new object is needed -> Option C

5. Quick Check:

   Prototype pattern = clone prototype to save cost [OK]

Hint: Clone prototype once, reuse clones to save creation cost [OK]

Common Mistakes:

• Using Singleton instead of cloning
• Creating new objects from scratch every time
• Confusing Factory with Prototype