# Module 3 : Array (Static)

<span>By the end of this module, students will be able to:</span>

<span>-</span><span> Understand the fundamental differences between Python lists and C arrays</span>

<span>-</span><span> Declare and initialize static arrays with appropriate data types</span>

<span>-</span><span> Access and manipulate array elements using indexing</span>

<span>-</span><span> Implement common array operations (traversal, searching, sorting)</span>

<span>-</span><span> Work with multi-dimensional arrays</span>

<span>-</span><span> Apply string manipulation using character arrays</span>

<span>-</span><span> Debug common array-related errors and memory issues</span>

<span>-</span><span> Transition effectively from Python list operations to C array operations</span>

# 1. Introduction: From Python Lists to C Arrays

### 1.1 Key Differences Overview

| Aspect | Python Lists | C Arrays |
|--------|--------------|----------|
| **Size** | Dynamic (can grow/shrink) | Fixed size (static) |
| **Type** | Can store mixed types | Single type only |
| **Memory** | Automatic management | Manual bounds checking |
| **Declaration** | `list = [1, 2, 3]` | `int arr[5] = {1, 2, 3, 4, 5};` |
| **Bounds Checking** | Automatic (raises IndexError) | No automatic checking |
| **Performance** | Slower (overhead) | Faster (direct memory access) |

### 1.2 Why Arrays Matter in C
[![](https://learn.digilabdte.com/uploads/images/gallery/2025-09/scaled-1680-/image-1757897488278.png)](https://learn.digilabdte.com/uploads/images/gallery/2025-09/image-1757897488278.png)

**Memory Efficiency:**
- Arrays store elements in contiguous memory locations
- Faster access compared to dynamic structures
- Predictable memory usage

**Performance:**
- Direct indexing without function call overhead
- Cache-friendly memory access patterns
- Essential for embedded systems and real-time applications

# New Page



# 2. Array Declaration and Initialization

### 2.1 Basic Array Declaration

**Python vs C Comparison:**

| Python | C |
|--------|---|
| `numbers = [1, 2, 3, 4, 5]` | `int numbers[5] = {1, 2, 3, 4, 5};` |
| `grades = []` | `float grades[100];` |
| `name = "Alice"` | `char name[10] = "Alice";` |

**C Array Declaration Syntax:**
```c
data_type array_name[size];
data_type array_name[size] = {value1, value2, ...};
```

### 2.2 Different Initialization Methods

#### 2.2.1 Complete Initialization
```c
int numbers[5] = {10, 20, 30, 40, 50};
char vowels[5] = {'a', 'e', 'i', 'o', 'u'};
float prices[3] = {12.5, 25.0, 8.75};
```

#### 2.2.2 Partial Initialization
```c
int scores[10] = {95, 87, 92};  // First 3 elements initialized
                                 // Remaining 7 elements = 0
char grades[5] = {'A', 'B'};     // grades[0]='A', grades[1]='B'
                                 // grades[2]=grades[3]=grades[4]='\0'
```

#### 2.2.3 Size Inference
```c
int data[] = {1, 2, 3, 4, 5};    // Size automatically becomes 5
char message[] = "Hello World";   // Size becomes 12 (including '\0')
```

#### 2.2.4 Zero Initialization
```c
int zeros[100] = {0};            // All elements initialized to 0
char buffer[50] = "";            // All characters initialized to '\0'
```

#### 2.2.5 Uninitialized Arrays (Dangerous!)
```c
int uninitialized[10];           // Contains garbage values!
// Always initialize arrays before use
```

### 2.3 Array Size and Memory

**Understanding Array Size:**
```c
int numbers[5];                  // 5 integers × 4 bytes = 20 bytes
char name[20];                   // 20 characters × 1 byte = 20 bytes
double values[10];               // 10 doubles × 8 bytes = 80 bytes

// Getting array size at compile time
int size = sizeof(numbers) / sizeof(numbers[0]);  // Result: 5
```

**Python vs C Size Operations:**
| Python | C |
|--------|---|
| `len(list)` | `sizeof(array) / sizeof(array[0])` |
| `list.append(item)` | Not possible with static arrays |
| `list.pop()` | Not possible with static arrays |

# 3. Array Indexing and Access

### 3.1 Basic Indexing

**Python vs C Indexing:**

| Operation | Python | C |
|-----------|--------|---|
| **First element** | `list[0]` | `array[0]` |
| **Last element** | `list[-1]` | `array[size-1]` |
| **Nth element** | `list[n]` | `array[n]` |
| **Modify element** | `list[0] = 10` | `array[0] = 10;` |

#### 3.1.1 Valid Indexing Example
```c
int numbers[5] = {10, 20, 30, 40, 50};

printf("First element: %d\n", numbers[0]);    // Output: 10
printf("Third element: %d\n", numbers[2]);    // Output: 30
printf("Last element: %d\n", numbers[4]);     // Output: 50

// Modifying elements
numbers[1] = 99;
printf("Modified second element: %d\n", numbers[1]);  // Output: 99
```

#### 3.1.2 Index Bounds and Common Errors

**Critical Difference from Python:**
```python
# Python - Safe bounds checking
my_list = [1, 2, 3, 4, 5]
print(my_list[10])  # Raises IndexError: list index out of range
```

```c
// C - NO automatic bounds checking!
int my_array[5] = {1, 2, 3, 4, 5};
printf("%d\n", my_array[10]);  // Undefined behavior! May print garbage
my_array[10] = 999;           // Buffer overflow! May crash program
```

**Common Index-Related Errors:**

1. **Off-by-One Error:**
```c
int arr[5] = {1, 2, 3, 4, 5};
// WRONG: Accessing index 5 (valid indices: 0-4)
for (int i = 0; i <= 5; i++) {    // ERROR: i goes up to 5
    printf("%d ", arr[i]);
}

// CORRECT:
for (int i = 0; i < 5; i++) {     // i goes from 0 to 4
    printf("%d ", arr[i]);
}
```

2. **Negative Index Error:**
```c
int arr[5] = {1, 2, 3, 4, 5};
int index = -1;
printf("%d\n", arr[index]);  // Undefined behavior! C has no negative indexing
```

3. **Uninitialized Index:**
```c
int arr[10];
int i;                      // Uninitialized variable
printf("%d\n", arr[i]);     // Using uninitialized i as index - dangerous!
```

### 3.2 Safe Array Access Patterns

#### 3.2.1 Bounds Checking Function
```c
#include <stdio.h>
#include <stdbool.h>

bool is_valid_index(int index, int array_size) {
    return (index >= 0 && index < array_size);
}

int safe_access(int arr[], int size, int index) {
    if (is_valid_index(index, size)) {
        return arr[index];
    } else {
        printf("Error: Index %d out of bounds (0-%d)\n", index, size-1);
        return -1;  // Return error value
    }
}

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    printf("Safe access: %d\n", safe_access(numbers, 5, 2));   // Valid
    printf("Safe access: %d\n", safe_access(numbers, 5, 10));  // Invalid
    
    return 0;
}
```

# 4. Array Input and Output Operations

### 4.1 Reading Array Elements

#### 4.1.1 Reading with Known Size
```c
#include <stdio.h>

int main() {
    int numbers[5];
    
    printf("Enter 5 integers:\n");
    for (int i = 0; i < 5; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &numbers[i]);
    }
    
    printf("You entered: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    return 0;
}
```

#### 4.1.2 Reading with User-Specified Size
```c
#include <stdio.h>
#define MAX_SIZE 100

int main() {
    int arr[MAX_SIZE];
    int n;
    
    printf("How many numbers do you want to enter (max %d): ", MAX_SIZE);
    scanf("%d", &n);
    
    // Input validation
    if (n <= 0 || n > MAX_SIZE) {
        printf("Invalid size! Please enter between 1 and %d\n", MAX_SIZE);
        return 1;
    }
    
    printf("Enter %d numbers:\n", n);
    for (int i = 0; i < n; i++) {
        printf("Number %d: ", i + 1);
        scanf("%d", &arr[i]);
    }
    
    printf("Your numbers: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    return 0;
}
```

### 4.2 Displaying Array Elements

#### 4.2.1 Basic Display
```c
void print_array(int arr[], int size) {
    printf("Array contents: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
```

#### 4.2.2 Formatted Display
```c
void print_array_formatted(int arr[], int size) {
    printf("┌");
    for (int i = 0; i < size; i++) {
        printf("────┬");
    }
    printf("\b┐\n");  // Backspace to replace last ┬ with ┐
    
    printf("│");
    for (int i = 0; i < size; i++) {
        printf("%3d │", arr[i]);
    }
    printf("\n");
    
    printf("└");
    for (int i = 0; i < size; i++) {
        printf("────┴");
    }
    printf("\b┘\n");
    
    printf(" ");
    for (int i = 0; i < size; i++) {
        printf("%3d  ", i);
    }
    printf("\n");
}
```

# 5. Common Array Operations

### 5.1 Array Traversal

#### 5.1.1 Forward Traversal
```c
// Python equivalent: for item in list:
for (int i = 0; i < size; i++) {
    printf("%d ", arr[i]);
}
```

#### 5.1.2 Reverse Traversal
```c
// Python equivalent: for item in reversed(list):
for (int i = size - 1; i >= 0; i--) {
    printf("%d ", arr[i]);
}
```

#### 5.1.3 Traversal with Condition
```c
// Print only even numbers
for (int i = 0; i < size; i++) {
    if (arr[i] % 2 == 0) {
        printf("%d ", arr[i]);
    }
}
```

### 5.2 Finding Maximum and Minimum

**Python vs C Comparison:**
| Python | C |
|--------|---|
| `max(list)` | Manual implementation |
| `min(list)` | Manual implementation |

#### 5.2.1 Finding Maximum
```c
int find_max(int arr[], int size) {
    if (size <= 0) {
        printf("Error: Empty array\n");
        return INT_MIN;  // Return minimum integer value
    }
    
    int max = arr[0];  // Assume first element is maximum
    
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    
    return max;
}
```

#### 5.2.2 Finding Minimum
```c
int find_min(int arr[], int size) {
    if (size <= 0) {
        printf("Error: Empty array\n");
        return INT_MAX;  // Return maximum integer value
    }
    
    int min = arr[0];
    
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    
    return min;
}
```

#### 5.2.3 Finding Both Max and Min with Position
```c
#include <stdio.h>

typedef struct {
    int max_value;
    int max_index;
    int min_value;
    int min_index;
} MinMaxResult;

MinMaxResult find_min_max(int arr[], int size) {
    MinMaxResult result = {arr[0], 0, arr[0], 0};
    
    for (int i = 1; i < size; i++) {
        if (arr[i] > result.max_value) {
            result.max_value = arr[i];
            result.max_index = i;
        }
        if (arr[i] < result.min_value) {
            result.min_value = arr[i];
            result.min_index = i;
        }
    }
    
    return result;
}
```

### 5.3 Searching in Arrays

#### 5.3.1 Linear Search
```c
int linear_search(int arr[], int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            return i;  // Return index of found element
        }
    }
    return -1;  // Element not found
}

// Usage example
int main() {
    int numbers[] = {10, 25, 8, 42, 15};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    int target = 42;
    
    int index = linear_search(numbers, size, target);
    
    if (index != -1) {
        printf("Element %d found at index %d\n", target, index);
    } else {
        printf("Element %d not found\n", target);
    }
    
    return 0;
}
```

#### 5.3.2 Count Occurrences
```c
int count_occurrences(int arr[], int size, int target) {
    int count = 0;
    
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            count++;
        }
    }
    
    return count;
}
```

#### 5.3.3 Find All Occurrences
```c
#include <stdio.h>
#define MAX_INDICES 100

int find_all_occurrences(int arr[], int size, int target, int indices[]) {
    int count = 0;
    
    for (int i = 0; i < size && count < MAX_INDICES; i++) {
        if (arr[i] == target) {
            indices[count] = i;
            count++;
        }
    }
    
    return count;  // Number of occurrences found
}

// Usage example
int main() {
    int numbers[] = {1, 3, 7, 3, 9, 3, 2};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    int target = 3;
    int indices[MAX_INDICES];
    
    int count = find_all_occurrences(numbers, size, target, indices);
    
    printf("Element %d found %d times at indices: ", target, count);
    for (int i = 0; i < count; i++) {
        printf("%d ", indices[i]);
    }
    printf("\n");
    
    return 0;
}
```

### 5.4 Array Modification Operations

#### 5.4.1 Filling Arrays
```c
void fill_array(int arr[], int size, int value) {
    for (int i = 0; i < size; i++) {
        arr[i] = value;
    }
}

// Fill with sequential numbers
void fill_sequence(int arr[], int size, int start) {
    for (int i = 0; i < size; i++) {
        arr[i] = start + i;
    }
}
```

#### 5.4.2 Copying Arrays
```c
void copy_array(int source[], int destination[], int size) {
    for (int i = 0; i < size; i++) {
        destination[i] = source[i];
    }
}

// Usage
int main() {
    int original[] = {1, 2, 3, 4, 5};
    int copy[5];
    
    copy_array(original, copy, 5);
    
    return 0;
}
```

#### 5.4.3 Reversing Arrays
```c
void reverse_array(int arr[], int size) {
    for (int i = 0; i < size / 2; i++) {
        // Swap elements
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}
```

# 6. Mathematical Operations on Arrays

### 6.1 Statistical Operations

#### 6.1.1 Sum and Average
```c
#include <stdio.h>

int sum_array(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

double average_array(int arr[], int size) {
    if (size == 0) return 0.0;
    return (double)sum_array(arr, size) / size;
}

// Usage
int main() {
    int scores[] = {85, 92, 78, 96, 88};
    int size = 5;
    
    int total = sum_array(scores, size);
    double avg = average_array(scores, size);
    
    printf("Total: %d\n", total);
    printf("Average: %.2f\n", avg);
    
    return 0;
}
```

#### 6.1.2 Standard Deviation
```c
#include <math.h>

double standard_deviation(int arr[], int size) {
    if (size <= 1) return 0.0;
    
    double mean = average_array(arr, size);
    double sum_squared_diff = 0.0;
    
    for (int i = 0; i < size; i++) {
        double diff = arr[i] - mean;
        sum_squared_diff += diff * diff;
    }
    
    return sqrt(sum_squared_diff / (size - 1));
}
```

### 6.2 Array Comparison

#### 6.2.1 Check if Arrays are Equal
```c
#include <stdbool.h>

bool arrays_equal(int arr1[], int arr2[], int size) {
    for (int i = 0; i < size; i++) {
        if (arr1[i] != arr2[i]) {
            return false;
        }
    }
    return true;
}
```

#### 6.2.2 Element-wise Operations
```c
void add_arrays(int arr1[], int arr2[], int result[], int size) {
    for (int i = 0; i < size; i++) {
        result[i] = arr1[i] + arr2[i];
    }
}

void multiply_array_scalar(int arr[], int size, int scalar) {
    for (int i = 0; i < size; i++) {
        arr[i] *= scalar;
    }
}
```

# 7. Character Arrays and Strings

### 7.1 Character Arrays vs Strings

**Understanding C Strings:**
In C, strings are arrays of characters terminated by a null character (`'\0'`).

```c
// Character array (not necessarily a string)
char letters[5] = {'H', 'e', 'l', 'l', 'o'};

// String (null-terminated character array)
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

// Easier string initialization
char message[] = "Hello";  // Automatically adds '\0'
char name[20] = "Alice";   // name[0]='A', name[1]='l', ..., name[5]='\0'
```

### 7.2 String Input/Output

#### 7.2.1 String Input Methods

```c
#include <stdio.h>

int main() {
    char name[50];
    
    // Method 1: scanf (stops at whitespace)
    printf("Enter your first name: ");
    scanf("%s", name);  // No & needed for arrays
    
    // Method 2: fgets (reads entire line)
    printf("Enter your full name: ");
    fgets(name, sizeof(name), stdin);
    
    // Method 3: scanf with character set
    printf("Enter your name: ");
    scanf("%[^\n]", name);  // Read until newline
    
    printf("Hello, %s!\n", name);
    return 0;
}
```

#### 7.2.2 String Output
```c
char message[] = "Programming in C";

// Method 1: printf with %s
printf("Message: %s\n", message);

// Method 2: puts (automatically adds newline)
puts(message);

// Method 3: Character by character
for (int i = 0; message[i] != '\0'; i++) {
    printf("%c", message[i]);
}
printf("\n");
```

### 7.3 String Manipulation Functions

#### 7.3.1 String Length
```c
#include <string.h>

// Using library function
int len = strlen(str);

// Manual implementation
int string_length(char str[]) {
    int length = 0;
    while (str[length] != '\0') {
        length++;
    }
    return length;
}
```

#### 7.3.2 String Copy
```c
#include <string.h>

// Using library function
strcpy(destination, source);

// Manual implementation
void string_copy(char dest[], char src[]) {
    int i = 0;
    while (src[i] != '\0') {
        dest[i] = src[i];
        i++;
    }
    dest[i] = '\0';  // Don't forget null terminator!
}
```

#### 7.3.3 String Concatenation
```c
#include <string.h>

// Using library function
strcat(destination, source);

// Manual implementation
void string_concatenate(char dest[], char src[]) {
    int dest_len = string_length(dest);
    int i = 0;
    
    while (src[i] != '\0') {
        dest[dest_len + i] = src[i];
        i++;
    }
    dest[dest_len + i] = '\0';
}
```

#### 7.3.4 String Comparison
```c
#include <string.h>

// Using library function
int result = strcmp(str1, str2);
// Returns: 0 if equal, <0 if str1 < str2, >0 if str1 > str2

// Manual implementation
int string_compare(char str1[], char str2[]) {
    int i = 0;
    while (str1[i] != '\0' && str2[i] != '\0') {
        if (str1[i] < str2[i]) return -1;
        if (str1[i] > str2[i]) return 1;
        i++;
    }
    
    if (str1[i] == '\0' && str2[i] == '\0') return 0;
    return (str1[i] == '\0') ? -1 : 1;
}
```

### 7.4 Common String Operations

#### 7.4.1 Count Characters/Words
```c
int count_character(char str[], char ch) {
    int count = 0;
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == ch) {
            count++;
        }
    }
    return count;
}

int count_words(char str[]) {
    int words = 0;
    bool in_word = false;
    
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] != ' ' && str[i] != '\t' && str[i] != '\n') {
            if (!in_word) {
                words++;
                in_word = true;
            }
        } else {
            in_word = false;
        }
    }
    
    return words;
}
```

#### 7.4.2 String Reversal
```c
void reverse_string(char str[]) {
    int len = string_length(str);
    
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}
```

#### 7.4.3 Case Conversion
```c
#include <ctype.h>

void to_uppercase(char str[]) {
    for (int i = 0; str[i] != '\0'; i++) {
        str[i] = toupper(str[i]);
    }
}

void to_lowercase(char str[]) {
    for (int i = 0; str[i] != '\0'; i++) {
        str[i] = tolower(str[i]);
    }
}

// Manual implementation for uppercase
void manual_to_uppercase(char str[]) {
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] >= 'a' && str[i] <= 'z') {
            str[i] = str[i] - 'a' + 'A';
        }
    }
}
```

# 8. Multi-dimensional Arrays

### 8.1 Two-Dimensional Arrays

#### 8.1.1 Declaration and Initialization

```c
// Declaration
int matrix[3][4];  // 3 rows, 4 columns

// Initialization methods
int grid[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

// Alternative initialization
int numbers[2][3] = {{1, 2, 3}, {4, 5, 6}};

// Partial initialization
int scores[3][2] = {
    {95, 87},
    {92, 78},
    {88}      // Last element becomes 0
};
```

#### 8.1.2 Accessing 2D Array Elements

```c
int matrix[3][4] = {
    {1,  2,  3,  4},
    {5,  6,  7,  8},
    {9, 10, 11, 12}
};

// Accessing elements
printf("Element at row 1, column 2: %d\n", matrix[1][2]);  // Output: 7

// Modifying elements
matrix[0][0] = 100;
matrix[2][3] = 999;
```

#### 8.1.3 Input/Output for 2D Arrays

```c
#include <stdio.h>

void input_matrix(int matrix[][4], int rows) {
    printf("Enter matrix elements:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            printf("Element [%d][%d]: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }
}

void print_matrix (int matrix[][4], int rows) {
    printf("Matrix:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}
```