Single-dimensional array declaration in C Sharp (C#) - Time & Space Complexity

Time Complexity: Single-dimensional array declaration

O(n)

Understanding Time Complexity

When we declare a single-dimensional array, we want to know how the time to create it changes as the array size grows.

We ask: How does the work needed to set up the array grow when the array gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

int n = 1000;
int[] numbers = new int[n];
for (int i = 0; i < n; i++)
{
    numbers[i] = 0;
}
    

This code creates an array of size n and sets each element to zero.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for loop that sets each element in the array.
• How many times: It runs exactly n times, once for each element.

How Execution Grows With Input

As the array size n grows, the number of steps to set elements grows the same way.

Input Size (n)	Approx. Operations
10	10 steps to set elements
100	100 steps to set elements
1000	1000 steps to set elements

Pattern observation: The work grows directly in proportion to the array size.

Final Time Complexity

Time Complexity: O(n)

This means the time to set up the array grows linearly as the array gets bigger.

Common Mistake

[X] Wrong: "Declaring an array is instant and does not depend on size."

[OK] Correct: Even though the array variable is declared quickly, initializing each element takes time proportional to the array size.

Interview Connect

Understanding how array creation time grows helps you explain memory setup and initialization in real programs.

Self-Check

"What if we removed the loop that sets elements to zero? How would the time complexity change?"

Practice

1. Which of the following correctly declares a single-dimensional array of integers in C#?

easy

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

B. int numbers = new int[5];

C. int[] numbers = int[5];

D. int numbers[] = new int();

Solution

1. Step 1: Understand array declaration syntax

   In C#, a single-dimensional array is declared by specifying the type followed by square brackets and then initializing with 'new' and size.

2. Step 2: Check each option

   int[] numbers = new int[5]; correctly uses 'int[] numbers = new int[5];'. Others have syntax errors or wrong types.

3. Final Answer:

   int[] numbers = new int[5]; -> Option A

4. Quick Check:

   Correct array declaration = int[] numbers = new int[5]; [OK]

Hint: Remember: type[] name = new type[size]; for arrays [OK]

Common Mistakes:

• Forgetting square brackets after type
• Not using 'new' keyword
• Declaring array without size or initializer

2. Which of the following is the correct syntax to declare and initialize a single-dimensional string array with 3 elements in C#?

easy

A. string[] names = new string[2] {"Anna", "Bob", "Cara"};

B. string names[] = {"Anna", "Bob", "Cara"};

C. string[] names = new string {"Anna", "Bob", "Cara"};

D. string[] names = new string[] {"Anna", "Bob", "Cara"};

Solution

1. Step 1: Understand array initialization syntax

   In C#, you can initialize an array with values using 'new type[] { values }' or just '{ values }' if declaration and initialization are combined.

2. Step 2: Check each option

   string[] names = new string[] {"Anna", "Bob", "Cara"}; is fully correct. string[] names = new string[2] {"Anna", "Bob", "Cara"}; incorrectly specifies size 2 with 3 initializers (compile error). string names[] = {"Anna", "Bob", "Cara"}; uses invalid syntax. string[] names = new string {"Anna", "Bob", "Cara"}; invalid syntax (missing array dimensions).

3. Final Answer:

   string[] names = new string[] {"Anna", "Bob", "Cara"}; -> Option D

4. Quick Check:

   Explicit array init with new string[] = string[] names = new string[] {"Anna", "Bob", "Cara"}; [OK]

Hint: Use 'new type[] { ... }' for explicit array initialization [OK]

Common Mistakes:

• Specifying size with initializer list
• Using C-style array syntax
• Omitting 'new' keyword incorrectly

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

int[] arr = new int[3] {10, 20, 30};
Console.WriteLine(arr[1]);

medium

A. 20

B. 10

C. 30

D. Runtime error

Solution

1. Step 1: Understand array indexing

   Arrays in C# are zero-based, so arr[0] = 10, arr[1] = 20, arr[2] = 30.

2. Step 2: Identify the printed element

   The code prints arr[1], which is 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   arr[1] = 20 [OK]

Hint: Remember arrays start at index 0 in C# [OK]

Common Mistakes:

• Confusing index 1 with index 0
• Expecting output to be 10 or 30
• Thinking array indexes start at 1

4. Identify the error in the following C# code snippet:

int[] values;
values = new int[3];
values[3] = 100;

medium

A. Array size is not specified

B. Index out of range error

C. Missing array initialization

D. Syntax error in declaration

Solution

1. Step 1: Check array size and indexing

   The array 'values' is declared with size 3, so valid indexes are 0, 1, and 2.

2. Step 2: Analyze the assignment

   Assigning to values[3] is invalid and causes an IndexOutOfRangeException at runtime.

3. Final Answer:

   Index out of range error -> Option B

4. Quick Check:

   Accessing index 3 in size 3 array causes error [OK]

Hint: Array indexes go from 0 to size-1 only [OK]

Common Mistakes:

• Using index equal to array size
• Forgetting zero-based indexing
• Assuming array auto-expands

5. You want to declare a single-dimensional array of 4 doubles and initialize it with values 1.1, 2.2, 3.3, and 4.4. Which code snippet correctly does this and allows you to change the third element later?

hard

A. double[] data = new double[3] {1.1, 2.2, 3.3, 4.4}; data[2] = 5.5;

B. double[] data = new double[3]; data[2] = 5.5;

C. double[] data = new double[4] {1.1, 2.2, 3.3, 4.4}; data[2] = 5.5;

D. double data[] = new double[] {1.1, 2.2, 3.3, 4.4}; data[3] = 5.5;

Solution

1. Step 1: Check array declaration and initialization

   double[] data = new double[4] {1.1, 2.2, 3.3, 4.4}; data[2] = 5.5; declares an array of size 4 with initial values and allows modification of elements.

2. Step 2: Verify element modification

   double[] data = new double[3] {1.1, 2.2, 3.3, 4.4}; data[2] = 5.5; incorrectly specifies size 3 with 4 initializers (compile error). double data[] = new double[] {1.1, 2.2, 3.3, 4.4}; data[3] = 5.5; uses invalid syntax but index 3 is valid for size 4 array. double[] data = new double[3]; data[2] = 5.5; declares size 3, not 4, missing initialization.

3. Final Answer:

   double[] data = new double[4] {1.1, 2.2, 3.3, 4.4}; data[2] = 5.5; -> Option C

4. Quick Check:

   Explicit size and initializer with modifiable element = double[] data = new double[4] {1.1, 2.2, 3.3, 4.4}; data[2] = 5.5; [OK]

Hint: Use 'new type[size] {values}' to declare and initialize arrays [OK]

Common Mistakes:

• Mismatching array size and initializer count
• Using wrong index for element change
• Omitting 'new' keyword in some contexts