Why collections over arrays in C Sharp (C#) - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of modifying a List vs an Array

What will be the output of this C# code snippet?

C Sharp (C#)

int[] arr = {1, 2, 3};
var list = new List<int>(arr);
list.Add(4);
Console.WriteLine(arr.Length);
Console.WriteLine(list.Count);

A 3\n4

B 3\n3

C 4\n4

D 4\n3

💡 Hint

Remember that arrays have fixed size, but Lists can grow.

The array arr has a fixed length of 3. The List list is created from the array and then an element is added, so its count becomes 4. The array length remains 3.

🧠 Conceptual

intermediate

Why choose collections over arrays?

Which of the following is the main reason to prefer collections like List over arrays in C#?

A Arrays allow adding elements after creation, collections do not.

B Arrays support LINQ queries, collections do not.

C Collections are always faster than arrays.

D Collections can dynamically resize, arrays have fixed size.

💡 Hint

Think about flexibility in size.

Arrays have a fixed size once created. Collections like List can grow or shrink dynamically, making them more flexible for many scenarios.

❓ Predict Output

advanced

Output of modifying collection vs array reference

What will be the output of this C# code?

C Sharp (C#)

int[] arr = {10, 20, 30};
List<int> list = new List<int>(arr);
arr[0] = 100;
list[1] = 200;
Console.WriteLine(arr[0]);
Console.WriteLine(list[1]);

A 100\n200

B 10\n200

C 10\n20

D 100\n20

💡 Hint

Modifying the array changes its own elements; modifying the list changes its own copy.

The List is created as a copy of the array elements. Changing the array element at index 0 changes arr[0]. Changing the list element at index 1 changes list[1]. They are independent after creation.

🔧 Debug

advanced

Identify the error when resizing an array

What error will this C# code produce?

C Sharp (C#)

int[] arr = new int[3];
arr[3] = 10;

A NullReferenceException

B IndexOutOfRangeException

C SyntaxError

D No error, runs fine

💡 Hint

Array indices start at 0 and go up to length-1.

The array has length 3, so valid indices are 0, 1, and 2. Accessing index 3 is out of range and causes an IndexOutOfRangeException.

🚀 Application

expert

Choosing the right data structure for dynamic data

You need to store a list of user names that can grow and shrink during program execution. Which is the best choice in C#?

A Use a string[] array because it is faster to access.

B Use a Dictionary<int, string> to store user names by index.

C Use a List<string> because it can dynamically resize.

D Use a fixed size array and create a new one when resizing is needed.

💡 Hint

Think about ease of adding and removing elements.

List<string> is designed to grow and shrink dynamically, making it the best choice for a changing list of user names. Arrays have fixed size and require manual resizing.

Practice

1. Why might you choose a collection like List<T> over an array in C#?

easy

A. Because collections can change size dynamically while arrays have fixed size.

B. Because arrays have more built-in methods than collections.

C. Because collections use less memory than arrays.

D. Because arrays can store different data types in the same array.

Solution

1. Step 1: Understand array size behavior

   Arrays in C# have a fixed size once created and cannot grow or shrink.

2. Step 2: Understand collection size behavior

   Collections like List<T> can dynamically add or remove items, changing their size.

3. Final Answer:

   Because collections can change size dynamically while arrays have fixed size. -> Option A

4. Quick Check:

   Collections grow/shrink; arrays fixed size [OK]

Hint: Remember: arrays fixed size, collections flexible size [OK]

Common Mistakes:

• Thinking arrays can resize automatically
• Believing collections use less memory always
• Confusing data type storage capabilities

2. Which of the following is the correct way to declare a collection that can grow in size in C#?

easy

A. int[] numbers = new int[5];

B. List<int> numbers = new List<int>();

C. int numbers = new List<int>();

D. ArrayList numbers = new int[5];

Solution

1. Step 1: Check syntax for array declaration

   int[] numbers = new int[5]; declares a fixed-size array, not a collection.

2. Step 2: Check syntax for collection declaration

   List<int> numbers = new List<int>(); correctly declares a generic list collection that can grow.

3. Final Answer:

   List<int> numbers = new List<int>(); -> Option B

4. Quick Check:

   List<T> syntax is for growable collections [OK]

Hint: Use List<T> for growable collections, arrays need size upfront [OK]

Common Mistakes:

• Using array syntax when collection is needed
• Assigning wrong types to variables
• Confusing ArrayList with arrays

3. What will be the output of this C# code?

List<int> nums = new List<int>() {1, 2, 3};
nums.Add(4);
Console.WriteLine(nums.Count);

medium

A. Compilation error

B. 3

C. 0

D. 4

Solution

1. Step 1: Understand initial list size

   The list nums starts with 3 elements: 1, 2, 3.

2. Step 2: Analyze the Add method effect

   Calling nums.Add(4); adds one more element, increasing count to 4.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   List.Count reflects added elements [OK]

Hint: Add increases collection size; Count shows current size [OK]

Common Mistakes:

• Assuming Count stays 3 after Add
• Confusing Count with capacity
• Expecting compilation error due to Add

4. Identify the error in this code snippet:

int[] arr = new int[3];
arr.Add(5);

medium

A. Array size must be declared as 5.

B. int[] cannot store integers.

C. Arrays do not have an Add method.

D. The array must be initialized with values.

Solution

1. Step 1: Check array methods

   Arrays in C# do not have an Add method; this method belongs to collections like List.

2. Step 2: Understand array limitations

   Arrays have fixed size and cannot add elements dynamically.

3. Final Answer:

   Arrays do not have an Add method. -> Option C

4. Quick Check:

   Arrays lack Add method [OK]

Hint: Arrays fixed size, no Add method; use List for adding [OK]

Common Mistakes:

• Trying to add elements to arrays
• Confusing array size with element count
• Assuming arrays have collection methods

5. You need to store a list of user names that can change during program execution. Which approach is best and why?

hard

A. Use a List<string> because it can grow and shrink as users are added or removed.

B. Use an array because it is faster and fixed size is enough.

C. Use a fixed-size array and recreate it every time the list changes.

D. Use a string variable to store all names separated by commas.

Solution

1. Step 1: Analyze data size flexibility needs

   User names list changes size, so fixed size arrays are inconvenient.

2. Step 2: Choose collection type for dynamic data

   List<string> allows adding/removing names easily without recreating the structure.

3. Final Answer:

   Use a List<string> because it can grow and shrink as users are added or removed. -> Option A

4. Quick Check:

   Dynamic data needs collections like List [OK]

Hint: Dynamic data? Use List<T> for easy resizing [OK]

Common Mistakes:

• Choosing fixed arrays for changing data
• Using strings to store multiple values unsafely
• Recreating arrays repeatedly instead of collections