1차원 배열의 메모리 배치 분석

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

void analyze_1d_array() {
    int data[SIZE] = {1, 9, 8, 4};
    printf("전체 배열 크기: %zu 바이트\n", sizeof(data));
    
    for(int idx = 0; idx < SIZE; ++idx) {
        printf("주소 %p - 값: %d\n", (void*)&data[idx], data[idx]);
    }
    printf("배열 이름의 값: %p\n", (void*)data);
}

배열은 메모리 상에 연속적으로 할당되며, 배열 이름 data는 첫 번째 요소의 주소인 &data[0]과 동일한 값을 가진다.

2차원 배열의 메모리 구조 탐구

void analyze_2d_structure() {
    int matrix[ROWS][SIZE] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
    
    printf("2차원 배열 전체 크기: %zu 바이트\n", sizeof(matrix));
    
    for(int r = 0; r < ROWS; ++r) {
        for(int c = 0; c < SIZE; ++c) {
            printf("주소 %p - 값: %d\n", (void*)&matrix[r][c], matrix[r][c]);
        }
    }
    
    printf("매트릭스 시작 주소: %p\n", (void*)matrix);
    printf("첫 번째 행 주소: %p\n", (void*)matrix[0]);
    printf("두 번째 행 주소: %p\n", (void*)matrix[1]);
}

2차원 배열은 행 단위로 연속 저장되며, 각 행의 주소 차이는 한 행이 차지하는 바이트 수(여기서는 16바이트)와 일치한다.

평균 계산 함수: 최대/최소 제외

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

double calculate_trimmed_average(int arr[], int count) {
    int max_val = arr[0], min_val = arr[0];
    double total = 0.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);
}

read_values()는 사용자 입력을 배열에 저장하며, calculate_trimmed_average()는 최댓값과 최솟값을 제외한 나머지 요소들의 평균을 산출한다. 함수 인수는 배열 이름으로 전달된다.

정방행렬 초기화 및 출력

#define MAX_SIZE 100

void display_matrix(int grid[][MAX_SIZE], int dim) {
    for(int r = 0; r < dim; ++r) {
        for(int c = 0; c < dim; ++c) {
            printf("%d ", grid[r][c]);
        }
        printf("\n");
    }
}

void fill_matrix(int grid[][MAX_SIZE], int dim, int value) {
    for(int r = 0; r < dim; ++r) {
        for(int c = 0; c < dim; ++c) {
            grid[r][c] = value;
        }
    }
}

함수 매개변수에서 2차원 배열을 선언할 때는 두 번째 차원의 크기를 명시해야 하며, 호출 시에는 배열 이름만 전달하면 된다.

중앙값 계산 알고리즘

double find_median(int series[], int length) {
    // 오름차순 정렬 (버블 정렬)
    for(int step = 0; step < length - 1; ++step) {
        for(int pos = 0; pos < length - 1 - step; ++pos) {
            if(series[pos] > series[pos + 1]) {
                int temp = series[pos];
                series[pos] = series[pos + 1];
                series[pos + 1] = temp;
            }
        }
    }
    
    // 중앙값 결정
    if(length % 2 == 1) {
        return series[length / 2];
    } else {
        return (series[length / 2 - 1] + series[length / 2]) / 2.0;
    }
}

행렬 우측 순환 이동

void shift_right(int grid[][MAX_SIZE], int dim) {
    for(int row = 0; row < dim; ++row) {
        int last = grid[row][dim - 1];
        for(int col = dim - 1; col > 0; --col) {
            grid[row][col] = grid[row][col - 1];
        }
        grid[row][0] = last;
    }
}

진법 변환 유틸리티 함수

void convert_base(int decimal, int base) {
    char result[MAX_SIZE];
    int index = 0;
    
    do {
        int remainder = decimal % base;
        if(remainder < 10) {
            result[index++] = '0' + remainder;
        } else {
            result[index++] = 'A' + (remainder - 10);
        }
        decimal /= base;
    } while(decimal > 0);
    
    // 결과 역순 출력
    for(int i = index - 1; i >= 0; --i) {
        printf("%c", result[i]);
    }
    printf("\n");
}

마법 사각형 판별

int is_magic_square(int square[][MAX_SIZE], int dim) {
    // 기준 합: 첫 번째 행의 합
    int base_sum = 0;
    for(int c = 0; c < dim; ++c) {
        base_sum += square[0][c];
    }
    
    // 각 행 검사
    for(int r = 0; r < dim; ++r) {
        int row_sum = 0;
        for(int c = 0; c < dim; ++c) {
            row_sum += square[r][c];
        }
        if(row_sum != base_sum) return 0;
    }
    
    // 각 열 검사
    for(int c = 0; c < dim; ++c) {
        int col_sum = 0;
        for(int r = 0; r < dim; ++r) {
            col_sum += square[r][c];
        }
        if(col_sum != base_sum) return 0;
    }
    
    // 주대각선 검사
    int diag_sum = 0;
    for(int i = 0; i < dim; ++i) {
        diag_sum += square[i][i];
    }
    if(diag_sum != base_sum) return 0;
    
    // 반대각선 검사
    diag_sum = 0;
    for(int i = 0; i < dim; ++i) {
        diag_sum += square[i][dim - 1 - i];
    }
    if(diag_sum != base_sum) return 0;
    
    return 1;
}