Static vs dynamic arrays in Data Structures Theory - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding memory allocation in static arrays

Which statement best describes how memory is allocated for a static array?

A Memory is shared between multiple static arrays to save space.

B Memory is allocated only when elements are accessed for the first time.

C Memory is allocated once at compile time and cannot be resized during runtime.

D Memory is allocated dynamically and can grow or shrink as elements are added or removed.

💡 Hint

Think about when the size of a static array is fixed and how that affects memory.

Static arrays have a fixed size determined at compile time, so their memory allocation is fixed and cannot change during program execution.

📋 Factual

intermediate

Dynamic array resizing behavior

What typically happens when a dynamic array reaches its current capacity and a new element is added?

A The array allocates a larger block of memory, copies existing elements, and then adds the new element.

B The array deletes some existing elements to make space for the new one.

C The array throws an error and stops accepting new elements.

D The array automatically converts into a static array.

💡 Hint

Consider how dynamic arrays manage to grow beyond their initial size.

Dynamic arrays allocate a bigger memory block, copy existing elements to it, and then add the new element to allow growth.

🔍 Analysis

advanced

Comparing access speed of static and dynamic arrays

Which of the following best explains the difference in element access speed between static and dynamic arrays?

A Static arrays are slower because they need to resize frequently, unlike dynamic arrays.

B Static arrays have faster access because their memory is contiguous and fixed, while dynamic arrays may have slower access due to possible fragmentation.

C Both have the same access speed because they store elements in linked nodes.

D Dynamic arrays have faster access because they use pointers, while static arrays require searching through elements.

💡 Hint

Think about how memory layout affects speed of accessing elements.

Static arrays store elements in a fixed, contiguous block of memory, allowing very fast access. Dynamic arrays also use contiguous memory but may occasionally reallocate, though access speed is generally similar. Fragmentation can affect dynamic arrays if not managed well.

❓ Comparison

advanced

Memory efficiency between static and dynamic arrays

Which statement correctly compares memory efficiency of static and dynamic arrays?

A Static arrays are more memory efficient because they allocate exactly the needed space upfront, while dynamic arrays may allocate extra unused space to allow growth.

B Static arrays waste memory because they allocate extra space for future growth, unlike dynamic arrays.

C Dynamic arrays are more memory efficient because they never allocate extra space beyond current elements.

D Both static and dynamic arrays always allocate the same amount of memory regardless of usage.

💡 Hint

Consider how each array type handles unused space.

Static arrays allocate fixed memory exactly for their size, so no extra space is wasted. Dynamic arrays often allocate more space than needed to reduce the frequency of resizing, which can lead to some unused memory.

❓ Reasoning

expert

Choosing array type for a real-time system

You are designing a real-time embedded system where predictable timing is critical. Which array type is more suitable and why?

A Static arrays, because they automatically resize to fit the data, avoiding manual memory management.

B Dynamic arrays, because they can grow as needed, preventing wasted memory and improving flexibility.

C Dynamic arrays, because they use linked lists internally, which are faster for real-time access.

D Static arrays, because their fixed size and memory allocation ensure predictable access and no delays from resizing.

💡 Hint

Think about what matters most in real-time systems: timing predictability or flexibility.

Real-time systems require predictable timing. Static arrays have fixed size and memory, so access times are consistent and no delays occur from resizing, making them ideal for such systems.

Practice

1. Which of the following best describes a static array?

easy

A. An array that automatically resizes when elements are added

B. An array with a fixed size that cannot be changed after creation

C. An array that stores elements in linked nodes

D. An array that only stores strings

Solution

1. Step 1: Understand static array size property

   Static arrays have a fixed size set when created and cannot grow or shrink.

2. Step 2: Compare with other options

   Dynamic arrays resize automatically, linked nodes describe linked lists, and storing only strings is unrelated.

3. Final Answer:

   An array with a fixed size that cannot be changed after creation -> Option B

4. Quick Check:

   Static array = fixed size [OK]

Hint: Static arrays have fixed size, no resizing [OK]

Common Mistakes:

• Confusing static arrays with dynamic arrays
• Thinking static arrays can resize
• Mixing arrays with linked lists

2. Which syntax correctly declares a dynamic array in a typical programming language?

easy

A. int arr = 10;

B. int arr[10];

C. array arr = {1, 2, 3};

D. List<int> arr = new List<int>();

Solution

1. Step 1: Identify dynamic array syntax

   Dynamic arrays often use list or vector types that can resize, like List<int> in many languages.

2. Step 2: Check other options

   int arr[10]; declares a static array of fixed size 10, C is an array initialization but may be static, D is just an integer variable.

3. Final Answer:

   List<int> arr = new List<int>(); -> Option D

4. Quick Check:

   Dynamic array uses List or similar [OK]

Hint: Dynamic arrays use list or vector syntax [OK]

Common Mistakes:

• Using fixed size array syntax for dynamic arrays
• Confusing variable declaration with array declaration
• Assuming initialization equals dynamic resizing

3. Consider this pseudocode for a dynamic array:

arr = []
for i in range(5):
    arr.append(i)
print(len(arr))

What is the output?

medium

A. 0

B. 4

C. 5

D. Error

Solution

1. Step 1: Understand the loop and append operation

   The loop runs 5 times (i = 0 to 4), appending each i to the dynamic array.

2. Step 2: Calculate final length of array

   After 5 appends, the array length is 5.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Appending 5 items results in length 5 [OK]

Hint: Count loop iterations for append count [OK]

Common Mistakes:

• Counting from 1 instead of 0
• Assuming length is last index
• Thinking append fails without pre-sizing

4. What is the main issue with this code snippet using a static array?

arr = new int[3]
arr[0] = 10
arr[1] = 20
arr[2] = 30
arr[3] = 40

medium

A. Index out of bounds error at arr[3]

B. Array size is dynamic, so no error

C. Array elements are not initialized

D. No issue, code runs fine

Solution

1. Step 1: Check array size and index usage

   The array size is 3, so valid indices are 0, 1, 2 only.

2. Step 2: Identify error at arr[3]

   Accessing arr[3] exceeds the array bounds, causing an error.

3. Final Answer:

   Index out of bounds error at arr[3] -> Option A

4. Quick Check:

   Static array index must be within size [OK]

Hint: Static arrays have fixed max index size-1 [OK]

Common Mistakes:

• Assuming arr[3] is valid index
• Thinking arrays auto-expand
• Ignoring zero-based indexing

5. You need to store an unknown number of user inputs that can grow over time. Which array type is best and why?

hard

A. Dynamic array, because it can resize automatically

B. Static array, because it uses less memory

C. Static array, because it has faster access

D. Dynamic array, because it uses linked nodes

Solution

1. Step 1: Analyze requirement for unknown and growing size

   Since the number of inputs is unknown and can grow, resizing is needed.

2. Step 2: Choose array type based on resizing ability

   Dynamic arrays can resize automatically, making them suitable for this case.

3. Final Answer:

   Dynamic array, because it can resize automatically -> Option A

4. Quick Check:

   Unknown size needs dynamic array [OK]

Hint: Use dynamic arrays for unknown or growing sizes [OK]

Common Mistakes:

• Choosing static arrays for unknown size
• Confusing faster access with resizing ability
• Thinking dynamic arrays use linked nodes