Dynamic Stack Using Resizable Array in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the stack array.

DSA Typescript

private stack: number[] = new Array[1];

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

A(10)

B(0)

C(1)

D(5)

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing with a fixed size like 10 causes wasted space.

Using parentheses incorrectly or missing them.

The stack array is initialized with size 0 to start empty and resize dynamically.

2fill in blank

medium

Complete the code to check if the stack is empty.

DSA Typescript

isEmpty(): boolean {
  return this.top [1] 0;
}

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

A>

B<=

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' or '>' which give wrong empty condition.

Using '<=' which includes negative values that don't apply here.

The stack is empty when top equals 0, meaning no elements are present.

3fill in blank

hard

Fix the error in the push method to resize the array when full.

DSA Typescript

push(value: number): void {
  if (this.top === this.stack.length) {
    const newStack = new Array(this.stack.length * 2 [1] 1);
    for (let i = 0; i < this.stack.length; i++) {
      newStack[i] = this.stack[i];
    }
    this.stack = newStack;
  }
  this.stack[this.top] = value;
  this.top++;
}

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

A*

B-

C/

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '*' or '/' which changes the size incorrectly.

Using '-' which can cause negative size.

We add 1 to handle the case when length is zero to avoid zero size array.

4fill in blank

hard

Fill both blanks to complete the pop method safely.

DSA Typescript

pop(): number | undefined {
  if (this.isEmpty()) {
    return [1];
  }
  this.top--;
  const value = this.stack[[2]];
  return value;
}

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

Aundefined

Bthis.top

Cthis.top - 1

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Returning null instead of undefined.

Accessing stack at top - 1 after decrementing top.

Return undefined if empty, and access the element at current top index before decrement.

5fill in blank

hard

Fill all three blanks to implement the peek method correctly.

DSA Typescript

peek(): number | undefined {
  if (this.isEmpty()) {
    return [1];
  }
  return this.stack[[2] [3] 1];
}

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

Aundefined

Bthis.top

C-

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '-' causing wrong index.

Returning null instead of undefined.

Return undefined if empty, then return element at top - 1 index without removing it.

Practice

1. What is the main advantage of using a dynamic stack implemented with a resizable array compared to a fixed-size array stack?

easy

A. It can grow or shrink in size as needed during runtime.

B. It uses less memory than a linked list stack.

C. It always has a fixed maximum size.

D. It does not require resizing or copying elements.

Solution

1. Step 1: Understand fixed vs dynamic size

   A fixed-size array stack has a set size and cannot grow beyond it, limiting capacity.

2. Step 2: Understand dynamic resizing

   A dynamic stack with resizable array can increase or decrease its size during runtime to fit more or fewer elements.

3. Final Answer:

   It can grow or shrink in size as needed during runtime. -> Option A

4. Quick Check:

   Dynamic resizing = flexible size [OK]

Hint: Dynamic arrays resize automatically when full or empty [OK]

Common Mistakes:

• Thinking dynamic stack has fixed max size
• Confusing memory use with linked list
• Assuming no resizing needed

2. Which of the following TypeScript code snippets correctly doubles the size of the internal array when the stack is full?

easy

A. this.array = [...this.array, ...new Array(this.array.length)];

B. this.array.push(...new Array(this.array.length));

C. this.array.length = this.array.length * 2;

D. const newArray = new Array(this.array.length * 2); for(let i=0; i

Solution

1. Step 1: Understand resizing by copying

   To resize, create a new larger array and copy existing elements into it.

2. Step 2: Check each option

   A uses spread but adds empty elements, not doubling size properly; B creates new array, copies elements, then replaces original array; C only changes length property but does not copy elements; D pushes empty elements, not resizing properly.

3. Final Answer:

   const newArray = new Array(this.array.length * 2); for(let i=0; i -> Option D

4. Quick Check:

   Copy elements to new larger array = B [OK]

Hint: Resize by copying elements to new bigger array [OK]

Common Mistakes:

• Only changing length without copying
• Using push to resize array
• Adding empty elements without copying

3. Consider this TypeScript code for a dynamic stack push operation:

push(value: number) {
  if (this.size === this.array.length) {
    const newArray = new Array(this.array.length * 2);
    for (let i = 0; i < this.array.length; i++) {
      newArray[i] = this.array[i];
    }
    this.array = newArray;
  }
  this.array[this.size] = value;
  this.size++;
}

If the initial array length is 2 and we push 3 elements: 10, 20, 30, what is the internal array state after these pushes?

medium

A. [10, 20, 30, undefined]

B. [10, 20, undefined, undefined]

C. [10, 20, 30, 0]

D. [10, 20, 30]

Solution

1. Step 1: Trace initial array and pushes

   Initial array length is 2, so after pushing 10 and 20, array is full.

2. Step 2: On pushing 30, array resizes to length 4 and copies elements 10, 20.

   Then 30 is added at index 2, size becomes 3.

3. Final Answer:

   [10, 20, 30, undefined] -> Option A

4. Quick Check:

   Resize doubles length, elements copied, new slot added [OK]

Hint: Resize doubles array, new elements added at next index [OK]

Common Mistakes:

• Forgetting to resize before adding third element
• Assuming array length stays 2
• Confusing undefined with 0

4. Given this pop method for a dynamic stack:

pop(): number | undefined {
  if (this.size === 0) return undefined;
  this.size--;
  const value = this.array[this.size];
  this.array[this.size] = undefined;
  if (this.size > 0 && this.size === Math.floor(this.array.length / 4)) {
    const newArray = new Array(Math.floor(this.array.length / 2));
    for (let i = 0; i < this.size; i++) {
      newArray[i] = this.array[i];
    }
    this.array = newArray;
  }
  return value;
}

What is the bug in this code?

medium

A. It does not check for empty stack before popping.

B. It sets popped element to undefined before copying, losing data.

C. It shrinks the array too early, causing frequent resizing.

D. It does not update the size after popping.

Solution

1. Step 1: Analyze order of operations

   The code sets this.array[this.size] = undefined before copying elements to newArray.

2. Step 2: Understand effect on copying

   When copying, the popped element is already undefined, so data is lost if resizing happens now.

3. Final Answer:

   It sets popped element to undefined before copying, losing data. -> Option B

4. Quick Check:

   Clear after copying to avoid data loss [OK]

Hint: Clear popped slot after resizing to keep data safe [OK]

Common Mistakes:

• Ignoring order of clearing and copying
• Shrinking array too often is not the main bug here
• Missing empty stack check is false here

5. You want to implement a dynamic stack using a resizable array that shrinks its size when the number of elements falls below one-quarter of the array length. Which approach below correctly avoids frequent resizing when pushing and popping many elements?

hard

A. Resize array to double size on push when full, and halve size on pop when size is exactly one-quarter of array length.

B. Resize array to double size on push when full, and halve size on pop when size is less than or equal to one-quarter of array length.

C. Resize array to double size on push when full, and halve size on pop only when size is less than one-quarter of array length and array length is greater than initial capacity.

D. Resize array to double size on push when full, and halve size on pop whenever size decreases.

Solution

1. Step 1: Understand resizing conditions

   Doubling on push when full is standard. Halving on pop should avoid frequent resizing.

2. Step 2: Avoid frequent resizing by checking size and minimum capacity

   Only halve when size is less than one-quarter and array length is above initial capacity to prevent shrinking too small.

3. Final Answer:

   Resize array to double size on push when full, and halve size on pop only when size is less than one-quarter of array length and array length is greater than initial capacity. -> Option C

4. Quick Check:

   Resize carefully to avoid thrashing [OK]

Hint: Shrink only if size < 1/4 and array bigger than initial [OK]

Common Mistakes:

• Shrinking too early causing many resizes
• Shrinking when size equals one-quarter causing thrashing
• Shrinking below initial capacity