C언어 12주차 과제

# 기본과제 및 제출 양식

1. 다음 사항에 대해 조사하여 보시오.(1시간 소요)

  가. 함수를 만들때 입력에 대해 Call By Value 가 무엇인지 조사하시오. 50자 이내로 적으시오.

: call by value에 의한 호출방식은 함수 호출 시 전달되는 변수의 '값'을 복사하여 함수의 인자로 전달한다.

  나. int a = 10을 선언하고, 이 값을 입력으로 받는 함수를 만든뒤 그 함수에서는 제곱근을 출력하도록 해보시오. 이 값을 main함수에 있는 변수에 담은 뒤 출력해보시오

 

#include<stdio.h>
#include<math.h>
#pragma warning (disable:4996)

double func1(int x);
int main()
{
int a = 10;
double k = func1(a);
printf("%d, %lf", a, k);

return 0;
}

double func1(int x)
{
double sol = sqrt(x);
printf("%lf\n", sol);
return sol;
}

  다. 함수를 만들때 입력에 대해 Call By Reference 가 무엇인지 조사하시오. 50자 이내로 적으시오.

: call by reference에 의한 호출방식은 함수 호출시 인자로 전달되는 변수의 레퍼런스를 전달한다. (해당 변수를 가리키게된다.) 따라서 함수 내에서 인자의 값이 변경 되면, 함수 인자로 전달된 변수의 값도 변경 된다.

  라. int* b = 20을 선언하고, 이 값의 주소를 입력으로 받는 함수를 만든뒤 그 함수에서는 제곱을 출력하도록 해보시오. 이 값을 main함수에 있는 변수에 담은 뒤 출력해보시오

  마. '나'와 '라'의 차이에 대해 설명해보시오.

: '나' 는 변수의 값만을 전달하기 때문에 호출함수의 인자값을 변화시킬 수 없지만, '라'는 그것을 가리키는 대상(레퍼런스)를 전달하기 때문에 호출함수의 인자값을 변화시킬 수 있다.

 

#include<stdio.h>
#include<math.h>
#pragma warning (disable:4996)
int func2(int* p);

int main()
{
int* b, num = 20;
b = &num;

printf("num = %d, b의 제곱 : %d", num, func2(b));

return 0;
}
int func2(int* p)
{
return ((*p) * (*p));
}

 

실행 결과

2. 배열은 포인터로 취급할 수 있다. 이 사실을 이용하여 아래 문항을 해결하시오. (2시간 소요)

  가. 메인함수에서 행벡터 {1,4,2,3,5,7,6,8,9,10} 를 int* matrix로 선언하시오.

  나. matrix의 주소를 받는 새로운 함수를 선언하시오. 함수이름은 BubbleSort로 하시오.

  다. 함수 내용은 버블정렬을 이용하여 행벡터의 숫자를 차례대로 정렬하는 기능을 갖도록 하시오.

  라. 메인함수에서 BubbleSort를 호출한 후, 호출 전후의 행벡터의 모든 값을 출력해 보시오.

 

#include<stdio.h>
#pragma warning (disable:4996)

void BubbleSort(int* p);

int main()
{
int vec[10] = { 1,4,2,3,5,7,6,8,9,10 };
int* matrix;
matrix = vec;

printf("호출 전 행벡터의 모든 값\n");
for (int i = 0; i < 10; i++)
{
printf("%d  ", matrix[i]);
}

printf("\n");
BubbleSort(matrix);

printf("호출 후 행벡터의 모든 값\n");
for (int i = 0; i < 10; i++)
{
printf("%d  ", matrix[i]);
}


return 0;
}
void BubbleSort(int* p)
{
int temp;
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 9 - i; j++)
{
if (p[j] > p[j + 1])
{
temp = p[j];
p[j] = p[j + 1];
p[j + 1] = temp;
}
}
}
}

 

실행 결과

  마. matrix의 값 10개를 받는 새로운 함수를 선언하시오. 함수이름은 Selection Sort로 하시오. 10개의 입력은 일일이 직접 써서 넘기시오.

  바. 함수 내용은 선택정렬을 이용하여 행벡터의 숫자를 차례대로 정렬하는 기능을 갖도록 하시오.

  사. 메인함수에서 Selection Sort를 호출한 후, 호출 전후의 행벡터의 모든 값을 출력해 보시오.

  아. Call By Value와 Call By Referernce의 장단점을 100자 이내로 비교해보시오

: call by value는 원래의 값을 보존 할 수 있어 원래의 값은 건드리면 안되는 프로그램에 사용하면 좋을 것 같다고 생각했다. 하지만 값을 복사해오는 것이기 때문에 메모리의 사용량이 늘어난다 (이건 구글 검색함)

call by reference는 로직은 같으나 값을 계속 변화시켜야 하는 프로그램에서 구현하기 좋을 것 같다. 하지만 call by value와 반대로 원래의 값을 건드리기 때문에 위험 요소가 있다.

 

#include<stdio.h>
#pragma warning (disable:4996)

void SelectSort(int* p);

int main()
{
int vec[10] = { 0 };
int* matrix;
matrix = vec;
int i;

printf("matrix 값 10개를 입력하시오 : \n");
for (i = 0; i < 10; i++)
{
scanf("%d", &matrix[i]);
}


printf("호출 전 행벡터의 모든 값\n");
for (i = 0; i < 10; i++)
{
printf("%d  ", matrix[i]);
}

printf("\n");
SelectSort(matrix);

printf("호출 후 행벡터의 모든 값\n");
for (i = 0; i < 10; i++)
{
printf("%d  ", matrix[i]);
}


return 0;
}
void SelectSort(int* p)
{
int temp;
for (int i = 0; i < 9; i++)
{
for (int j = i+1; j < 10; j++)
{
if (p[i] > p[j])
{
temp = p[i];
p[i] = p[j];
p[j] = temp;
}
}
}
}

3. 이차정사각행렬도 포인터로 취급할 수 있다. 이 사실을 이용하여 아래 문항을 해결하시오. (2시간 소요)

  가. 메인함수에서 이차정사각행렬을 만들고 {1,2,3,4}를 넣으시오.

  나. 이차정사각행렬의 각 성분값을 받는 함수를 만드시오.

  다. 이차정사각행렬을 함수에 넣으면 그 역행렬이 만들어지도록 해보시오.  다음식을 참조하시오.

  라. 이차정사각행렬을 포인터를 이용하여 주소값을 넘기도록 해보시오.

  마. 이차정사각행렬을 함수에 넣으면 그 역행렬이 만들어지도록 해보시오.

 

#include<stdio.h>
#pragma warning (disable:4996)

void getMatrix(int(*p)[2]);
void inverseMatrix(int(*p)[2]);

int main()
{
int vec[2][2] = { 1,2,3,4 };
int(*matrix)[2];
matrix = vec;
int i, j;

getMatrix(matrix);

printf("초기 행렬\n");
printf("%d  %d\n", matrix[0][0], matrix[0][1]);
printf("%d  %d\n", matrix[1][0], matrix[1][1]);

inverseMatrix(matrix);

printf("역행렬\n");
printf("%d  %d\n", matrix[0][0], matrix[0][1]);
printf("%d  %d\n", matrix[1][0], matrix[1][1]);

return 0;
}
void getMatrix(int(*p)[2])
{

printf("1 행 1 열의 값 입력 : ");
scanf("%d", &p[0][0]);

printf("1 행 2 열의 값 입력 : ");
scanf("%d", &p[0][1]);

printf("2 행 1 열의 값 입력 : ");
scanf("%d", &p[1][0]);

printf("2 행 2 열의 값 입력 : ");
scanf("%d", &p[1][1]);

}
void inverseMatrix(int(*p)[2])
{
double temp;
double det = 1 / (p[0][0] * p[1][1] - p[1][0] * p[0][1]);

temp = p[0][0];
p[0][0] = det * p[1][1];
p[0][1] = -(det * p[0][1]);
p[1][0] = -(det * p[1][0]);
p[1][1] = det * temp;
}

 

실행 결과

 

# 심화과제 제출 양식( 안해도 됨 )

1. int 배열 30만개가 있다. 각 값은 {1,2,3,4.....300000} 이다.

  나. 동적할당에 대해 조사하시오. 의미와 쓰임을 중심으로 100자 이내로 정리해 보시오. https://modoocode.com/98를 참조하시오.

: 프로그래밍 시 정해진 크기의 기억공간을 미리 선언하여 놓는 것을 정적 메모리 할당 이라고 하고,

프로그램 수행 도중에 필요한 메모리를 할당 받아 사용하는 것을 동적 메모리 할당이라고 한다.

 

 

2. 버블정렬 또는 선택정렬을 이용하여 아래 문항을 해결하시오.

올림픽에 100명의 사람들이 출전하였고, 그 사람들의 점수는 0~100 점 중 임의로 입력되도록 srand를 이용하여 만드시오. 0~100 사이에서 0.1 단위로 점수를 매기시오.

  가. 정렬 기법을 10회만 사용하여 90~100등 사이는 예선 탈락이 되도록 해 보시오.

  나. 정렬 기법을 3회만 사용하여, 1등은 금메달, 2등은 은메달, 3등은 동메달이 되도록 뽑아보시오.

     단, 동점자가 발생하지 않도록 해 보시오. 힌트) 점수를 만들어 내었을때 이미 뽑았던 값이 또 뽑혔는지 검사하면 됨.

 

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#pragma warning (disable:4996)

void SelectSort(double* p);
int main()
{
    srand(time(NULL));
    double score[100];
    double* ptr;
    ptr = score;
    int i, j;
    double temp;
    int scorecnt = 0;
    int isSame = 0;

    // 중복되지 않는 난수발생기

   while (scorecnt < 100)
   {
       isSame = 0;
       temp = (double)(rand() % 1001) / 10;
       for (int i = 0; i < scorecnt; i++)
       {
           if (temp == score[i])
           {
               isSame = 1;
               break;
           }
       }
       if (isSame == 0)
       {
           score[scorecnt] = temp;
           scorecnt++;
       }
   }

    printf("ㅡㅡㅡ100명의 점수ㅡㅡㅡ\n");
    for (i = 0; i < 99; i++)
    {
        printf("%lf\n", score[i]);
    }
    
    SelectSort(ptr);

    printf("예선 탈락자 10명\n");
    for (i = 99; i > 89; i--)
    {
        printf("%d등의 점수 : %lf\n", i + 1, score[i]);
    }

    printf("상위 3명\n");
    for (i = 0; i < 3; i++)
    {
        printf("%d등의 점수 : %lf\n", i + 1, score[i]);
    }


    return 0;

}
void SelectSort(double* p)
{
    double temp;
    for (int i = 0; i < 99; i++)
    {
        for (int j = i + 1; j < 100; j++)
        {
            if (p[i] < p[j])
            {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
}

 

실행 결과

 

  다. '나'에서 동점자가 발생하지 않도록 하는 기능을 응용하여 45개의 수 중 겹치지 않는 6개의 임의의 수를 뽑아주는 '로또'를 만들어 보시오. 컴퓨터가 6개의 겹치지 않는 수를 정하도록 한 뒤, 사용자로부터 겹치지 않는 6개의 숫자 입력을 받아 결과를 출력해보시오. 사용자 선택의 수가 겹칠경우, 사용자 선택을 전부 다시 하도록 하시오.

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#pragma warning (disable:4996)
void SelectSort(int* p);
int main()
{
    int i, j, temp;
    int lotto[6];
    int* ptr;
    ptr = lotto;

    int user[6];
    int* ptr2;
    ptr2 = user;

    int lottocount = 0;
    int usercount = 0;
    int isSame = 0;
 

    srand(time(NULL));
    while (lottocount < 6)
    {
        isSame = 0;
        temp = rand() % 45 + 1;
        for (int i = 0; i < lottocount; i++)
        { 
            if (temp == lotto[i]) 
            { 
                isSame = 1;
                break;
            }
        }
        if (isSame == 0) 
        {
            lotto[lottocount] = temp;
            lottocount++;
        }
    }

    SelectSort(ptr);

    printf("추첨 숫자\n");
    for (i = 0; i < 6; i++)
    {
        printf("%d ", ptr[i]);
    }
    printf("\n");

    printf("ㅡㅡㅡlotto 번호 입력ㅡㅡㅡ\n");


    for (i = 0; i < 6; i++)
    {
        scanf("%d", &user[i]);
        for (j = 0; j < i; j++)
        {
            if (user[i] == user[j])
            {
                printf("중복되는 숫자를 입력하셨습니다.\n");
                i = -1;
            }
        }
    }


    SelectSort(ptr2);
    printf("사용자가 고른 번호\n");

    for (i = 0; i < 6; i++)
    {
        printf("%d ", user[i]);
    }

    int cnt = 0;

    for (i = 0; i < 6; i++)
    {
        if (lotto[i] == user[i])
        {
            cnt++;
        }
    }

    if (cnt == 6)
        printf("로또 당첨! 축하합니다\n");
    else printf("꽝\n");


    return 0;

}
void SelectSort(int* p)
{
    int temp;
    for (int i = 0; i < 5; i++)
    {
        for (int j = i + 1; j < 6; j++)
        {
            if (p[i] > p[j])
            {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
}

 

중복되는 숫자 입력, 그리고 로또 당첨

 

로또를 맞히지 못하였을 때