테스트1: 정수형 1차원 배열

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

void test1() {
    int arr[SIZE] = {1, 9, 8, 4};          
    int index;

    // 배열 arr의 메모리 크기 출력
    printf("sizeof(arr) = %d\n", sizeof(arr));

    // 각 요소의 주소와 값 출력 
    for (index = 0; index < SIZE; ++index)
        printf("%p: %d\n", &arr[index], arr[index]);

    // 배열 이름 arr의 값 출력 
    printf("arr = %p\n", arr); 
}

void test2() {
    int matrix[COUNT][SIZE] = {{1, 9, 8, 4}, {2, 0, 4, 9}};
    int row, col;

    // 2차원 배열 matrix의 메모리 크기 출력
    printf("sizeof(matrix) = %d\n", sizeof(matrix));

    // 각 요소의 주소와 값 출력 
    for (row = 0; row < COUNT; ++row)
        for (col = 0; col < SIZE; ++col)
            printf("%p: %d\n", &matrix[row][col], matrix[row][col]);
    printf("\n");

    // 2차원 배열 이름 matrix, 그리고 matrix[0], matrix[1]의 값 출력
    printf("matrix = %p\n", matrix);
    printf("matrix[0] = %p\n", matrix[0]);
    printf("matrix[1] = %p\n", matrix[1]);
    printf("\n");
}

int main() {
    printf("테스트1: 정수형 1차원 배열\n");
    test1();

    printf("\n테스트2: 정수형 2차원 배열\n");
    test2();

    return 0;
}

질문1: 배열은 연속적으로 저장되며, arr의 값과 &arr[0]은 동일하다.

질문2: 배열은 연속적으로 저장되며, 명백히 같은 구조를 가진다.

테스트2:

#include <stdio.h>
#define MAX_SIZE 100

// 함수 선언
void input(int array[], int size);
double calculate(int array[], int size);

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

    while(printf("Enter n: "), scanf("%d", &count) != EOF) {
        input(numbers, count);            // 함수 호출
        result = calculate(numbers, count);    // 함수 호출
        printf("ans = %.2f\n\n", result);
    }

    return 0;
}

// 함수 정의
void input(int array[], int size) {
    int index;

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

// 함수 정의
double calculate(int array[], int size) {
    int index, maxVal, minVal;
    double total = 0;

    maxVal = minVal = array[0];
    total = 0;

    for(index = 0; index < size; ++index) {
        total += array[index];

        if(array[index] > maxVal)
            maxVal = array[index];
        else if(array[index] < minVal)
            minVal = array[index];
    }

    total = (total - maxVal - minVal)/(size-2);

    return total;
}

관찰: 1차원 배열 매개변수 array[]는 실제 값으로 전달된다.

질문: input은 array에 값을 할당하고, calculate는 최대값과 최소값을 제외한 평균을 계산한다.

테스트3:

#include <stdio.h>
#define MAX_SIZE 100

// 함수 선언
void display(int matrix[][MAX_SIZE], int size);
void initialize(int matrix[][MAX_SIZE], int size, int value);

int main() {
    int matrix[MAX_SIZE][MAX_SIZE];
    int size, val;

    while(printf("Enter n and value: "), scanf("%d%d", &size, &val) != EOF) {
        initialize(matrix, size, val);  // 함수 호출
        display(matrix, size);       // 함수 호출
        printf("\n");
    }

    return 0;
}

// 함수 정의
void display(int matrix[][MAX_SIZE], int size) {
    int row, col;

    for(row = 0; row < size; ++row) {
        for(col = 0; col < size; ++col)
            printf("%d ", matrix[row][col]);
        printf("\n");
    }
}

// 함수 정의
void initialize(int matrix[][MAX_SIZE], int size, int value) {
    int row, col;

    for(row = 0; row < size; ++row)
        for(col = 0; col < size; ++col)
            matrix[row][col] = value;
}

관찰: 2차원 배열 매개변수 matrix[][], 실제 값으로 전달된다.

질문1: 두 번째 차원의 크기를 지정해야 한다.

질문2: display는 2차원 배열의 값을 출력하고, initialize는 n x n 행렬에 value 값을 입력한다.

테스트4:

#include <stdio.h>
#define MAX_SIZE 100
double median(int array[], int size);
void input(int array[], int size);

int main() {
    int data[MAX_SIZE];
    int count;
    double result;

    while(printf("Enter n: "), scanf("%d", &count) != EOF) {
        input(data, count);
        result = median(data, count);
        printf("ans = %g\n\n", result);
    }

    return 0;
}

void input(int array[], int size){
    int index;
    for(index=0;indexarray[j+1]){
            temp=array[j];
            array[j]=array[j+1];
            array[j+1]=temp;
        }
        }
    }
    if(size%2==0)  
    sum = (array[size/2-1]+array[size/2])/2.0;
    else 
    sum = array[size/2];
    return sum;
}

테스트5:

#include <stdio.h>
#define MAX_SIZE 100

// 함수 선언
void read(int matrix[][MAX_SIZE], int size);
void print(int matrix[][MAX_SIZE], int size);
// 함수 rotate_to_right 선언
// ×××
void rotate_to_right(int matrix[][MAX_SIZE],int size);
int main() {
    int matrix[MAX_SIZE][MAX_SIZE];
    int size;

    printf("입력n: "); 
    scanf("%d", &size);
    read(matrix, size);

    printf("원래 행렬:\n");
    print(matrix, size);

    // 함수 rotate_to_right 호출
    // 待补足
    rotate_to_right(matrix,size);

    printf("변환 후 행렬:\n");
    print(matrix, size);

    return 0;
}

// 함수 정의
// 기능: n x n 행렬 입력
void read(int matrix[][MAX_SIZE], int size) {
    int row, col;
    
    for (row = 0; row < size; ++row) {
        for (col = 0; col < size; ++col)
            scanf("%d", &matrix[row][col]);
    }
}

// 함수 정의
// 기능: n x n 행렬 출력
void print(int matrix[][MAX_SIZE], int size) {
    int row, col;

    for (row = 0; row < size; ++row) {
        for (col = 0; col < size; ++col)
            printf("%4d", matrix[row][col]);

        printf("\n");
    }
}

// 함수 rotate_to_right 정의
// 기능: n x n 행렬을 오른쪽으로 한 칸 이동
// xxx
void rotate_to_right(int matrix[][MAX_SIZE],int size){
int row,col,temp;
for(row=0;row0;col--){
        matrix[row][col]=matrix[row][col-1];
    }
    matrix[row][0] = temp;
}
}

테스트6:

#include <stdio.h>
#define MAX_SIZE 100

void decimal_to_base(int number, int base);

int main() {
    int num;

    while(printf("Input decimal integer: "), scanf("%d", &num) != EOF) {
        decimal_to_base(num, 2);  // 함수 호출: 숫자를 이진수로 변환
        decimal_to_base(num, 8);  // 함수 호출: 숫자를 팩토리얼로 변환
        decimal_to_base(num, 16); // 함수 호출: 숫자를 십육진수로 변환

        printf("\n");
    }

    return 0;
}

void decimal_to_base(int number, int base){
    int index=0;
    char buffer[MAX_SIZE];
    while(number!=0){
        if(number%base<10){
        buffer[index]='0'+number%base;
        index++;
    }
        else{
        buffer[index]='A'+(number%base-10);
        index++;
    }
        number=number/base;
    }
    for(int i=index-1;i>=0;i--)
    printf("%c",buffer[i]);
    printf("\n");
}    

테스트7:

#include <stdio.h>
#define MAX_SIZE 100

// 함수 선언
void readMatrix(int matrix[][MAX_SIZE], int size);
void displayMatrix(int matrix[][MAX_SIZE], int size);
int isMagic(int matrix[][MAX_SIZE],int size);
//待补足函数is_magic声明
// xxx

int main() {
    int matrix[MAX_SIZE][MAX_SIZE];
    int size;

    while(printf("Input n: "), scanf("%d", &size) != EOF) {
        printf("Input square matrix:\n");  
        readMatrix(matrix, size); 

        printf("Output matrix:\n");  
        displayMatrix(matrix, size);   

        if(isMagic(matrix, size))
            printf("It is a magic matrix\n\n");
        else
            printf("It is not a magic matrix\n\n");
    }

    return 0;
}

// 함수 정의
// 기능: n x n 행렬 입력
void readMatrix(int matrix[][MAX_SIZE], int size) {
    int row, col;
    
    for (row = 0; row < size; ++row) {
        for (col = 0; col < size; ++col)
            scanf("%d", &matrix[row][col]);
    }
}

// 기능: n x n 행렬 출력
void displayMatrix(int matrix[][MAX_SIZE], int size) {
    int row, col;

    for (row = 0; row < size; ++row) {
        for (col = 0; col < size; ++col)
            printf("%4d", matrix[row][col]);

        printf("\n");
    }
}

// 기능: n x n 행렬이 마방진인지 판단
//待补足函数is_magic定义
// xxx
int isMagic(int matrix[][MAX_SIZE],int size){
    int row, col, sum1=0, sum2=0, sum3=0, sum4=0, total=0;
    for(col=0;col