Bài tập 1

Chương trình sau minh họa cách tổ chức bộ nhớ cho mảng một chiều và hai chiều:

#include <stdio.h>
#define ARRAY_SIZE 4
#define ROW_COUNT 2

void demo_single_array() {
    int data[ARRAY_SIZE] = {1, 9, 8, 4};          
    int index;

    printf("Kích thước mảng: %d\n", sizeof(data));

    for (index = 0; index < ARRAY_SIZE; ++index)
        printf("%p: %d\n", &data[index], data[index]);

    printf("Địa chỉ bắt đầu mảng: %p\n", data); 
}

void demo_multi_array() {
    int matrix[ROW_COUNT][ARRAY_SIZE] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
    int row, col;

    printf("Kích thước ma trận: %d\n", sizeof(matrix));

    for (row = 0; row < ROW_COUNT; ++row)
        for (col = 0; col < ARRAY_SIZE; ++col)
            printf("%p: %d\n", &matrix[row][col], matrix[row][col]);
    printf("\n");

    printf("Địa chỉ matrix: %p\n", matrix);
    printf("Địa chỉ hàng 0: %p\n", matrix[0]);
    printf("Địa chỉ hàng 1: %p\n", matrix[1]);
    printf("\n");
}

int main() {
    printf("Thử nghiệm 1: Mảng số nguyên một chiều\n");
    demo_single_array();

    printf("\nThử nghiệm 2: Mảng số nguyên hai chiều\n");
    demo_multi_array();

    return 0;
}

Bài tập 2

Chương trình tính trung bình cộng của dãy số sau khi loại bỏ giá trị lớn nhất và nhỏ nhất:

#include <stdio.h>
#define MAX_SIZE 100

void read_data(int arr[], int size);
double calculate_average(int arr[], int size);

int main() {
    int numbers[MAX_SIZE];
    int count, i;
    double result;

    while(printf("Nhập số lượng phần tử: "), scanf("%d", &count) != EOF) {
        read_data(numbers, count);            
        result = calculate_average(numbers, count);   
        printf("Kết quả = %.2f\n\n", result);
    }

    return 0;
}

void read_data(int arr[], int size) {
    int i;

    for(i = 0; i < size; ++i)
        scanf("%d", &arr[i]);
}

double calculate_average(int arr[], int size) {
    int i, max_val, min_val;
    double sum;

    max_val = min_val = arr[0];
    sum = 0;

    for(i = 0; i < size; ++i) {
        sum += arr[i];

        if(arr[i] > max_val)
            max_val = arr[i];
        else if(arr[i] < min_val)
            min_val = arr[i];
    }

    sum = (sum - max_val - min_val)/(size-2);

    return sum;
}

Bài tập 3

Khởi tạo và hiển thị ma trận với giá trị cố định:

#include <stdio.h>
#define MATRIX_MAX 100

void display_matrix(int mat[][MATRIX_MAX], int size);
void fill_matrix(int mat[][MATRIX_MAX], int size, int fill_value);

int main() {
    int matrix[MATRIX_MAX][MATRIX_MAX];
    int dimension, value;

    while(printf("Nhập kích thước và giá trị: "), scanf("%d%d", &dimension, &value) != EOF) {
        fill_matrix(matrix, dimension, value);  
        display_matrix(matrix, dimension);       
        printf("\n");
    }

    return 0;
}

void display_matrix(int mat[][MATRIX_MAX], int size) {
    int i, j;

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

void fill_matrix(int mat[][MATRIX_MAX], int size, int fill_value) {
    int i, j;

    for(i = 0; i < size; ++i)
        for(j = 0; j < size; ++j)
            mat[i][j] = fill_value;
}

Bài tập 4

Tính toán giá trị trung vị của dãy số sau khi sắp xếp:

#include <stdio.h>
#define MAX_ELEMENTS 100

double find_median(int arr[], int count);
void load_data(int arr[], int count); 

int main() {
    int dataset[MAX_ELEMENTS];
    int num_elements;
    double median_result;

    while(printf("Nhập số phần tử: "), scanf("%d", &num_elements) != EOF) {
        load_data(dataset, num_elements);
        median_result = find_median(dataset, num_elements);
        printf("Trung vị = %g\n\n", median_result);
    }

    return 0;
}

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

double find_median(int arr[], int count) {
    double result;
    int i, j;
    
    // Sắp xếp nổi bọt
    for(i = 0; i < count - 1; i++) {
        for(j = 0; j < count - 1 - i; j++) {
            if(arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    
    if(count % 2 == 0) {
        result = (double)(arr[count / 2] + arr[count / 2 - 1]) / 2;
    } else {
        result = (double)arr[(count - 1) / 2];
    }
    
    return result;
}

Bài tập 5

Dịch chuyển các cột của ma trận sang phải:

#include <stdio.h>
#define MAX_DIMENSION 100

void read_matrix(int mat[][MAX_DIMENSION], int size);
void print_matrix(int mat[][MAX_DIMENSION], int size);
void shift_columns_right(int mat[][MAX_DIMENSION], int size);

int main() {
    int grid[MAX_DIMENSION][MAX_DIMENSION];
    int dim;

    printf("Nhập kích thước: "); 
    scanf("%d", &dim);
    read_matrix(grid, dim);

    printf("Ma trận ban đầu:\n");
    print_matrix(grid, dim);

    shift_columns_right(grid, dim);

    printf("Ma trận sau khi dịch chuyển:\n");
    print_matrix(grid, dim);

    return 0;
}

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

void print_matrix(int mat[][MAX_DIMENSION], int size) {
    int i, j;

    for (i = 0; i < size; ++i) {
        for (j = 0; j < size; ++j)
            printf("%4d", mat[i][j]);

        printf("\n");
    }
}

void shift_columns_right(int mat[][MAX_DIMENSION], int size) {
    int buffer[size];
    int i, j;
    
    // Lưu cột cuối cùng
    for(i = 0; i < size; i++) {
        buffer[i] = mat[i][size - 1];
    }
    
    // Dịch các cột sang phải
    for(i = 0; i < size; i++) {
        for(j = size - 2; j >= 0; j--) {
            mat[i][j + 1] = mat[i][j];
        }
    }
    
    // Đặt cột cuối đã lưu vào vị trí đầu tiên
    for(i = 0; i < size; i++) {
        mat[i][0] = buffer[i];
    }
}

Bài tập 6

Chuyển đổi hệ thập phân sang các hệ cơ số khác:

#include <stdio.h>
#define BUFFER_SIZE 100

void convert_base(int decimal_num, int base); 

int main() {
    int number;

    while(printf("Nhập số thập phân: "), scanf("%d", &number) != EOF) {
        convert_base(number, 2);  
        convert_base(number, 8);  
        convert_base(number, 16); 

        printf("\n");
    }

    return 0;
}

void convert_base(int decimal_num, int base) {
    int digits[BUFFER_SIZE];
    int pos = 0;
    int temp = decimal_num;
    
    if(temp == 0) {
        printf("0\n");
        return;
    }
    
    while (temp != 0) {
        digits[pos] = temp % base;
        temp = temp / base;
        pos++;
    }
    
    for (int i = pos - 1; i >= 0; i--) {
        if (digits[i] < 10) {
            printf("%d", digits[i]);
        } else {
            printf("%c", digits[i] - 10 + 'A');
        }
    }
    printf("\n");
}

Bài tập 7

Kiểm tra ma trận kỳ ảo (magic square):

#include <stdio.h>
#define MAX_MATRIX 100

void populate_matrix(int mat[][MAX_MATRIX], int size);
void show_matrix(int mat[][MAX_MATRIX], int size);
int check_magic_square(int mat[][MAX_MATRIX], int size);

int main() {
    int magic_mat[MAX_MATRIX][MAX_MATRIX];
    int dimension;

    while(printf("Nhập kích thước: "), scanf("%d", &dimension) != EOF) {
        printf("Nhập ma trận vuông:\n");  
        populate_matrix(magic_mat, dimension); 

        printf("Hiển thị ma trận:\n");  
        show_matrix(magic_mat, dimension);   

        if(check_magic_square(magic_mat, dimension))
            printf("Là ma trận kỳ ảo\n\n");
        else
            printf("Không phải ma trận kỳ ảo\n\n");
    }

    return 0;
}

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

void show_matrix(int mat[][MAX_MATRIX], int size) {
    int i, j;

    for (i = 0; i < size; ++i) {
        for (j = 0; j < size; ++j)
            printf("%4d", mat[i][j]);

        printf("\n");
    }
}

int check_magic_square(int mat[][MAX_MATRIX], int size) {
    int row_sums[100] = {0};
    int col_sums[100] = {0};
    int main_diag_sum = 0;
    int anti_diag_sum = 0;

    // Tính tổng các hàng
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            row_sums[i] += mat[i][j];
        }
    }

    // Tính tổng các cột
    for (int j = 0; j < size; j++) {
        for (int i = 0; i < size; i++) {
            col_sums[j] += mat[i][j];
        }
    }

    // Tổng đường chéo chính
    for (int i = 0; i < size; i++) {
        main_diag_sum += mat[i][i];
    }

    // Tổng đường chéo phụ
    for (int i = 0; i < size; i++) {
        anti_diag_sum += mat[i][size - 1 - i];
    }

    // Kiểm tra tất cả các tổng hàng giống nhau
    int expected_sum = row_sums[0];
    for (int i = 1; i < size; i++) {
        if (row_sums[i] != expected_sum) {
            return 0;
        }
    }

    // Kiểm tra tất cả các tổng cột giống nhau và bằng tổng hàng
    if (col_sums[0] != expected_sum) {
        return 0;
    }
    for (int j = 1; j < size; j++) {
        if (col_sums[j] != expected_sum) {
            return 0;
        }
    }

    // Kiểm tra tổng hai đường chéo
    if (main_diag_sum != expected_sum || anti_diag_sum != expected_sum) {
        return 0;
    }

    return 1;
}