LLD interview expectations - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a class with a constructor in LLD.

LLD

class User {
  constructor([1]) {
    this.name = name;
  }
}

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

Aemail

Bname

Cage

Did

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter that does not match the property name.

The constructor parameter should be name to assign it to this.name.

2fill in blank

medium

Complete the code to add a method that returns the user's name.

LLD

class User {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.[1];
  }
}

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

Ausername

Bid

Cname

DuserName

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a property that does not exist or is misspelled.

The method should return the name property of the object.

3fill in blank

hard

Fix the error in the code to correctly implement a setter method for the user's age.

LLD

class User {
  constructor(name) {
    this.name = name;
    this.age = 0;
  }

  setAge([1]) {
    this.age = age;
  }
}

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

AageValue

Bvalue

CnewAge

Dage

Attempts:

3 left

💡 Hint

Common Mistakes

Using a parameter name different from the one assigned to the property.

The parameter name must be age to match the assignment this.age = age;.

4fill in blank

hard

Fill both blanks to create a method that returns a formatted string with the user's name and age.

LLD

class User {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  getInfo() {
    return `$[1] is $[2] years old.`;
  }
}

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

Athis.name

Bthis.age

Cname

Dage

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names without this inside class methods.

The template string should use this.name and this.age to access the object's properties.

5fill in blank

hard

Fill all three blanks to implement a method that updates the user's name and age only if the new values are valid.

LLD

class User {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  updateUser([1], [2]) {
    if (typeof [3] === 'string' && [2] > 0) {
      this.name = [1];
      this.age = [2];
    }
  }
}

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

AnewName

BnewAge

Dage

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent parameter names in the method and condition.

The method parameters should be newName and newAge. The type check uses newName to verify the string.

Practice

1. What is the main focus of a Low-Level Design (LLD) interview?

easy

A. Choosing cloud providers and infrastructure

B. Estimating system capacity and scaling

C. Designing detailed components and their interactions

D. Writing complex SQL queries

Solution

1. Step 1: Understand LLD interview scope

   LLD interviews focus on designing small parts of a system clearly and in detail.

2. Step 2: Compare options with LLD focus

   Estimating capacity and scaling, choosing cloud providers and infrastructure, and writing database queries relate to other areas, not the main focus of LLD interviews.

3. Final Answer:

   Designing detailed components and their interactions -> Option C

4. Quick Check:

   LLD = detailed component design [OK]

Hint: LLD = detailed design of small system parts [OK]

Common Mistakes:

• Confusing LLD with high-level system design
• Thinking LLD focuses on infrastructure
• Mixing LLD with database query writing

2. Which of the following is the correct way to represent a relationship in a class diagram during an LLD interview?

easy

A. Using arrows to show inheritance and lines for associations

B. Using SQL queries to define relationships

C. Using cloud icons to represent services

D. Using flowcharts to show data flow

Solution

1. Step 1: Identify class diagram conventions

   Class diagrams use arrows for inheritance and lines for associations between classes.

2. Step 2: Eliminate unrelated options

   SQL queries, cloud icons, and flowcharts are not used to represent class relationships in LLD diagrams.

3. Final Answer:

   Using arrows to show inheritance and lines for associations -> Option A

4. Quick Check:

   Class diagram = arrows + lines [OK]

Hint: Class diagrams use arrows and lines for relationships [OK]

Common Mistakes:

• Confusing class diagrams with flowcharts
• Using database or cloud symbols incorrectly
• Ignoring inheritance arrows

3. Consider this simplified class design snippet in an LLD interview:

class User {
  int id;
  String name;
  List<Order> orders;
}

class Order {
  int orderId;
  double amount;
}

What is the relationship between User and Order?

medium

A. Inheritance

B. Aggregation

C. Composition

D. No relationship

Solution

1. Step 1: Analyze the class fields

   User has a list of Orders, meaning User contains Orders but Orders can exist independently.

2. Step 2: Determine relationship type

   Since Orders can exist without User, this is aggregation, not composition or inheritance.

3. Final Answer:

   Aggregation -> Option B

4. Quick Check:

   User "has" Orders = Aggregation [OK]

Hint: List field means aggregation, not inheritance [OK]

Common Mistakes:

• Confusing aggregation with composition
• Thinking it's inheritance due to class names
• Ignoring independence of Order objects

4. You designed a class diagram but forgot to show the multiplicity on associations. What issue might this cause in an LLD interview?

medium

A. Ambiguity about how many objects relate to each other

B. Syntax error in the diagram

C. The system will not compile

D. No impact, multiplicity is optional

Solution

1. Step 1: Understand multiplicity role

   Multiplicity shows how many instances of one class relate to another, clarifying design details.

2. Step 2: Consequence of missing multiplicity

   Without it, the design is unclear about object counts, causing ambiguity.

3. Final Answer:

   Ambiguity about how many objects relate to each other -> Option A

4. Quick Check:

   Missing multiplicity = unclear relationships [OK]

Hint: Multiplicity clarifies object counts in relationships [OK]

Common Mistakes:

• Thinking diagram syntax breaks without multiplicity
• Assuming multiplicity is always optional
• Confusing multiplicity with inheritance

5. During an LLD interview, you are asked to design a simple library system with Books and Members. Which design choice best follows LLD interview expectations?

hard

A. Design a single class Library with all methods and no separation

B. Use complex inheritance hierarchies for Book types without explaining choices

C. Focus only on database schema without class diagrams

D. Create classes Book and Member with clear attributes and a borrowing relationship using aggregation

Solution

1. Step 1: Identify good LLD design practices

   LLD expects clear classes with attributes and simple relationships like aggregation.

2. Step 2: Evaluate options against LLD expectations

   Creating classes Book and Member with clear attributes and a borrowing relationship using aggregation matches best by defining classes and relationships clearly. A single class lacks separation, database schema skips class diagrams, and unexplained complex inheritance overcomplicates without clarity.

3. Final Answer:

   Create classes Book and Member with clear attributes and a borrowing relationship using aggregation -> Option D

4. Quick Check:

   Clear classes + simple relationships = LLD [OK]

Hint: Clear classes + simple relationships = good LLD design [OK]

Common Mistakes:

• Overcomplicating with inheritance
• Ignoring class separation
• Skipping diagrams and explanations