Exercise 1: Array Memory Layout

This program demonstrates memory allocation patterns for one-dimensional and two-dimensional arrays:

#include <stdio.h>
#define ROWS 4
#define COLS 2

void show_1d_layout() {
    int vector[ROWS] = { 10, 20, 30, 40 };
    
    printf("Vector size: %d bytes\n", sizeof(vector));
    for (int i = 0; i < ROWS; ++i)
        printf("%p: %d\n", &vector[i], vector[i]);
    printf("Vector address: %p\n", vector);
}

void show_2d_layout() {
    int matrix[COLS][ROWS] = { {50, 60, 70, 80}, {90, 100, 110, 120} };
    
    printf("Matrix size: %d bytes\n", sizeof(matrix));
    for (int i = 0; i < COLS; ++i)
        for (int j = 0; j < ROWS; ++j)
            printf("%p: %d\n", &matrix[i][j], matrix[i][j]);
    
    printf("\nMatrix addresses:\n%p\n%p\n%p\n", matrix, matrix[0], matrix[1]);
}

int main() {
    printf("1D Array Demonstration\n");
    show_1d_layout();
    
    printf("\n2D Array Demonstration\n");
    show_2d_layout();
    
    return 0;
}

Observations:

1. 1D array elements are contiguous in memory
2. 2D arrays use row-major contiguous allocation

Exercise 2: Adjusted Average Calculation

Computes average after excluding minimum and maximum values:

#include <stdio.h>
#define MAX_SIZE 100

void read_data(int arr[], int count) {
    for(int i = 0; i < count; ++i)
        scanf("%d", &arr[i]);
}

double trimmed_average(int arr[], int count) {
    int min_val = arr[0], max_val = arr[0];
    double total = 0;
    
    for(int i = 0; i < count; ++i) {
        total += arr[i];
        if(arr[i] > max_val) max_val = arr[i];
        if(arr[i] < min_val) min_val = arr[i];
    }
    
    return (total - max_val - min_val) / (count - 2);
}

int main() {
    int data[MAX_SIZE];
    int count;
    
    while(printf("Enter count: "), scanf("%d", &count) != EOF) {
        read_data(data, count);
        double result = trimmed_average(data, count);
        printf("Result: %.2f\n\n", result);
    }
    return 0;
}

Exercise 3: Matrix Initialization and Output

Initializes and displays a square matrix:

#include <stdio.h>
#define MAX_DIM 100

void display_matrix(int mat[][MAX_DIM], int size) {
    for(int i = 0; i < size; ++i) {
        for(int j = 0; j < size; ++j)
            printf("%d ", mat[i][j]);
        printf("\n");
    }
}

void init_matrix(int mat[][MAX_DIM], int size, int val) {
    for(int i = 0; i < size; ++i)
        for(int j = 0; j < size; ++j)
            mat[i][j] = val;
}

int main() {
    int matrix[MAX_DIM][MAX_DIM];
    int size, value;
    
    while(printf("Enter size and value: "), scanf("%d%d", &size, &value) != EOF) {
        init_matrix(matrix, size, value);
        display_matrix(matrix, size);
        printf("\n");
    }
    return 0;
}

Notes: Column dimension must be specified in function parameters.

Exercise 4: Median Calculation

Computes median value after sorting elements:

#include <stdio.h>
#define MAX_ELEMENTS 100

void read_numbers(int nums[], int count) {
    printf("Enter %d numbers: ", count);
    for(int i = 0; i < count; i++)
        scanf("%d", &nums[i]);
}

void bubble_sort(int nums[], int count) {
    for(int i = 0; i < count-1; i++)
        for(int j = 0; j < count-i-1; j++)
            if(nums[j] > nums[j+1]) {
                int swap = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = swap;
            }
}

double find_median(int nums[], int count) {
    bubble_sort(nums, count);
    return (count % 2) ? nums[count/2] : (nums[count/2 - 1] + nums[count/2]) / 2.0;
}

int main() {
    int numbers[MAX_ELEMENTS];
    int count;
    
    while(printf("Enter count: "), scanf("%d", &count) != EOF) {
        read_numbers(numbers, count);
        double med = find_median(numbers, count);
        printf("Median: %g\n\n", med);
    }
    return 0;
}

Exercise 5: Matrix Column Rotation

Performs right rotation of matrix columns:

#include <stdio.h>
#define MAX_DIM 100

void read_matrix(int mat[][MAX_DIM], int size) {
    for(int i = 0; i < size; i++)
        for(int j = 0; j < size; j++)
            scanf("%d", &mat[i][j]);
}

void print_matrix(int mat[][MAX_DIM], int size) {
    for(int i = 0; i < size; i++) {
        for(int j = 0; j < size; j++)
            printf("%4d", mat[i][j]);
        printf("\n");
    }
}

void rotate_columns(int mat[][MAX_DIM], int size) {
    int last_col[MAX_DIM];
    
    for(int i = 0; i < size; i++)
        last_col[i] = mat[i][size - 1];
    
    for(int col = size - 1; col > 0; col--)
        for(int row = 0; row < size; row++)
            mat[row][col] = mat[row][col - 1];
    
    for(int i = 0; i < size; i++)
        mat[i][0] = last_col[i];
}

int main() {
    int matrix[MAX_DIM][MAX_DIM];
    int size;
    
    printf("Enter size: ");
    scanf("%d", &size);
    read_matrix(matrix, size);
    
    printf("Original matrix:\n");
    print_matrix(matrix, size);
    
    rotate_columns(matrix, size);
    
    printf("Rotated matrix:\n");
    print_matrix(matrix, size);
    
    return 0;
}

Exercise 6: Base Conversion

Converts decimal numbers to binary, octal, and heaxdecimal:

#include <stdio.h>
#define MAX_DIGITS 100

void convert_base(int num, int base) {
    int digits[MAX_DIGITS], idx = 0;
    
    if(num == 0) {
        printf("0\n");
        return;
    }
    
    while(num > 0) {
        digits[idx++] = num % base;
        num /= base;
    }
    
    for(idx--; idx >= 0; idx--) {
        if(digits[idx] < 10)
            printf("%d", digits[idx]);
        else
            printf("%c", digits[idx] - 10 + 'A');
    }
    printf("\n");
}

int main() {
    int number;
    
    while(printf("Enter decimal: "), scanf("%d", &number) != EOF) {
        convert_base(number, 2);
        convert_base(number, 8);
        convert_base(number, 16);
        printf("\n");
    }
    return 0;
}