C언어로 로또 총합 구하기!

[김춘복]

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

int LOTTO_CREATE_RECORD(int **ppLotto, int countRowsOrCols);

int LOTTO_CREATE_TABLE(int ***pppLotto, int countRows, int countCols);

int LOTTO_COPY_RECORD_TO_RECORD(int **ppLottoSrc, int **ppLottoDest, int countCols);

int LOTTO_COPY_RECORD_TO_TABLE_COLUMN(int **ppLottoSrc, int ***pppLottoDest, int countRows, int countCols, int column);

int LOTTO_COPY_RECORD_TO_TABLE_ROW(int **ppLottoSrc, int ***pppLottoDest, int countRows, int countCols, int row);

int LOTTO_COPY_TABLE_TO_TABLE(int ***pppLottoSrc, int ***pppLottoDest, int countRows, int countCols);

int LOTTO_COPY_TABLE_COLUMN_TO_RECORD(int ***pppLottoSrc, int **ppLottoDest, int countRows, int countCols, int column);

int LOTTO_COPY_TABLE_ROW_TO_RECORD(int ***pppLottoSrc, int **ppLottoDest, int countRows, int countCols, int row);

int LOTTO_COUNT_COLUMNS(int **ppLottoCountColumns, int countCols);

int LOTTO_COUNT_ROWS(int **ppLottoCountRows, int countRows);

int LOTTO_DROP_RECORD(int **ppLotto);

int LOTTO_DROP_TABLE(int ***pppLotto, int countRows);

int LOTTO_CREATE(int ***pppLotto, int countRows, int countCols);

int LOTTO_DROP(int ***pppLotto, int countRows);

int LOTTO_SETTING(int seedOption);

int LOTTO_INSERT_RECORD(int **ppLotto, int countCols);

int LOTTO_INSERT_TABLE(int ***pppLotto, int countRows, int countCols);

int LOTTO_ORDER_BY_RECORD(int **ppLotto, int countCols);

int LOTTO_ORDER_BY_TABLE(int ***pppLotto, int countRows, int countCols);

int LOTTO_ORDER_BY_TABLE_ASC(int ***pppLotto, int countRows, int countCols);

int LOTTO_ORDER_BY_TABLE_DESC(int ***pppLotto, int countRows, int countCols);

int LOTTO_ORDER_BY_TABLE_COLUMN_ASC(int ***pppLotto, int countRows, int countCols, int column);

int LOTTO_ORDER_BY_TABLE_COLUMN_DESC(int ***pppLotto, int countRows, int countCols, int column);

int LOTTO_UPDATE_RECORD(int **ppLotto, int countCols);

int LOTTO_UPDATE_TABLE(int ***pppLotto, int countRows, int countCols);

int LOTTO_SELECT_RECORD(int **ppLotto, int countCols);

int LOTTO_SELECT_TABLE(int ***pppLotto, int countRows, int countCols);

int LOTTO_PAPER_RUN(int ***pppLotto, int countRows, int countCols);

int LOTTO_CONNECT(char *filename, int ***pppLotto, int countRows, int countCols);

int LOTTO_DISCONNECT(char *filename, int ***pppLotto, int countRows, int countCols);

int LOTTO_ROUND_RUN(int ***pppLottoRound, int lottoRoundRows, int lottoRoundCols);

int LOTTO_SELECT_RECORD_ZERO(int **ppLotto, int countCols);

int LOTTO_SELECT_TABLE_ZERO(int ***pppLotto, int countRows, int countCols);

int LOTTO_SELECT_RECORD_TOTAL(int **ppLottoSrc, int countCols, int *sum);

int LOTTO_SELECT_RECORD_TOTAL_RANGE(int **ppLotto, int countCols, int *sum, int start, int end);

int LOTTO_SELECT_RECORD_TOTAL_BETWEEN(int **ppLotto, int countCols, int *sum, int min, int max);

int LOTTO_SELECT_RECORD_TOTAL_RANGE_BETWEEN(int **ppLotto, int countCols, int *sum, int start, int end, int min, int max);

int LOTTO_SELECT_TABLE_TOTAL(int ***pppLotto, int countRows, int countCols, int **sum);

int LOTTO_SELECT_TABLE_TOTAL_RANGE(int ***pppLotto, int countRows, int countCols, int **sum, int start, int end);

int LOTTO_SELECT_TABLE_TOTAL_BETWEEN(int ***pppLotto, int countRows, int countCols, int **sum, int min, int max);

int LOTTO_SELECT_TABLE_TOTAL_RANGE_BETWEEN(int ***pppLotto, int countRows, int countCols, int **sum, int start, int end, int min, int max);

int LOTTO_SELECT_TABLE_TOTAL_AVERAGE(int ***pppLotto, int countRows, int countCols, int average);

int LOTTO_CREATE_RECORD(int **ppLotto, int countRowsOrCols)

{

    // 1. 1차원 배열을 동적 할당한다.

    *ppLotto = (int *)malloc(sizeof(int) * countRowsOrCols);

    if (*ppLotto == NULL)

    {

        printf("동적 할당 실패\n");

        return -1;

    }

    // 2. 1차원 배열의 각 요소에 0을 초기화한다.

    for (int i = 0; i < countRowsOrCols; i++)

    {

        (*ppLotto)[i] = 0;

    }

    // 3. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_CREATE_TABLE(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열을 동적 할당한다.

    *pppLotto = (int **)malloc(sizeof(int *) * countRows);

    if (*pppLotto == NULL)

    {

        printf("동적 할당 실패\n");

        return -1;

    }

    // 2. 2차원 배열의 각 요소에 0을 초기화한다.

    for (int i = 0; i < countRows; i++)

    {

        (*pppLotto)[i] = NULL;

        LOTTO_CREATE_RECORD(&((*pppLotto)[i]), countCols);

    }

    // 3. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COPY_RECORD_TO_RECORD(int **ppLottoSrc, int **ppLottoDest, int countCols)

{

    // 1. 1차원 배열의 각 요소를 복사한다.

    for (int i = 0; i < countCols; i++)

    {

        (*ppLottoDest)[i] = (*ppLottoSrc)[i];

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COPY_RECORD_TO_TABLE_COLUMN(int **ppLottoSrc, int ***pppLottoDest, int countRows, int countCols, int column)

{

    // 1. 1차원 배열의 각 요소를 복사한다.

    for (int i = 0; i < countRows; i++)

    {

        (*pppLottoDest)[i][column] = (*ppLottoSrc)[i];

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COPY_RECORD_TO_TABLE_ROW(int **ppLottoSrc, int ***pppLottoDest, int countRows, int countCols, int row)

{

    // 1. 1차원 배열의 각 요소를 복사한다.

    for (int i = 0; i < countCols; i++)

    {

        (*pppLottoDest)[row][i] = (*ppLottoSrc)[i];

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COPY_TABLE_TO_TABLE(int ***pppLottoSrc, int ***pppLottoDest, int countRows, int countCols)

{

    // 1. 2차원 배열의 각 요소를 복사한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_COPY_RECORD_TO_RECORD(&((*pppLottoSrc)[i]), &((*pppLottoDest)[i]), countCols);

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COPY_TABLE_COLUMN_TO_RECORD(int ***pppLottoSrc, int **ppLottoDest, int countRows, int countCols, int column)

{

    // 1. 2차원 배열의 각 요소를 복사한다.

    for (int i = 0; i < countRows; i++)

    {

        (*ppLottoDest)[i] = (*pppLottoSrc)[i][column];

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COPY_TABLE_ROW_TO_RECORD(int ***pppLottoSrc, int **ppLottoDest, int countRows, int countCols, int row)

{

    // 1. 2차원 배열의 각 요소를 복사한다.

    for (int i = 0; i < countCols; i++)

    {

        (*ppLottoDest)[i] = (*pppLottoSrc)[row][i];

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COUNT_COLUMNS(int **ppLottoCountColumns, int countCols)

{

    // 1. 1차원 배열의 각 요소를 카운트한다.

    for (int i = 0; i < countCols; i++)

    {

        (*ppLottoCountColumns)[i] = i + 1;

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_COUNT_ROWS(int **ppLottoCountRows, int countRows)

{

    // 1. 1차원 배열의 각 요소를 카운트한다.

    for (int i = 0; i < countRows; i++)

    {

        (*ppLottoCountRows)[i] = i + 1;

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_DROP_RECORD(int **ppLotto)

{

    // 1. 1차원 배열의 메모리를 해제한다.

    free(*ppLotto);

    // 2. 1차원 배열의 주소를 NULL로 초기화한다.

    *ppLotto = NULL;

    // 3. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_DROP_TABLE(int ***pppLotto, int countRows)

{

    // 1. 2차원 배열의 메모리를 해제한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_DROP_RECORD(&((*pppLotto)[i]));

    }

    free(*pppLotto);

    // 2. 2차원 배열의 주소를 NULL로 초기화한다.

    *pppLotto = NULL;

    // 3. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_CREATE(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열을 동적 할당한다.

    LOTTO_CREATE_TABLE(pppLotto, countRows, countCols);

    // 2. 2차원 배열의 각 요소에 0을 초기화한다.

    // 3. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_DROP(int ***pppLotto, int countRows)

{

    // 1. 2차원 배열의 메모리를 해제한다.

    LOTTO_DROP_TABLE(pppLotto, countRows);

    // 2. 2차원 배열의 주소를 NULL로 초기화한다.

    // 3. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SETTING(int seedOption)

{

    if (seedOption == 0)

    {

        // 1. 밀리 초 단위로 현재 시간을 구한다.

        // 2. 현재 시간을 시드로 사용한다.

        struct timespec ts;

        clock_gettime(CLOCK_REALTIME, &ts);

        srand(ts.tv_nsec);

    }

    else if (seedOption == 1)

    {

        // 1. 초 단위로 현재 시간을 구한다.

        // 2. 현재 시간을 시드로 사용한다.

        srand(time(NULL));

    }

    else if (seedOption == 2)

    {

        // 1. 현재 시간을 구한다.

        // 2. 현재 시간을 시드로 사용한다.

        time_t now = time(NULL);

        struct tm *pnow = localtime(&now);

        srand(pnow->tm_hour + pnow->tm_min + pnow->tm_sec);

    }

    else if (seedOption == 3)

    {

        // 1. 날짜를 구한다

        // 2. 날짜를 시드로 사용한다.

        time_t now = time(NULL);

        struct tm *pnow = localtime(&now);

        srand(pnow->tm_year + 1900 + pnow->tm_mon + 1 + pnow->tm_mday);

    }

    else if (seedOption > 3)

    {

        // 1. seedOption을 시드로 사용한다.

        srand(seedOption);

    }

    else

    {

        printf("난수 생성 실패\n");

        return -1;

    }

}

int LOTTO_INSERT_RECORD(int **ppLotto, int countCols)

{

    // 1. 1차원 배열의 각 요소에 1 ~ 45 사이의 난수를 저장한다.

    for (int i = 0; i < countCols; i++)

    {

        (*ppLotto)[i] = rand() % 45 + 1;

    }

    // 4. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_INSERT_TABLE(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열의 각 요소에 1 ~ 45 사이의 난수를 저장한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_INSERT_RECORD(&((*pppLotto)[i]), countCols);

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_UPDATE_RECORD(int **ppLotto, int countCols)

{

    // 1. 1차원 배열의 각 요소에 중복된 값이 있는지 확인한다.

    for (int i = 0; i < countCols; i++)

    {

        for (int j = i + 1; j < countCols; j++)

        {

            if ((*ppLotto)[i] == (*ppLotto)[j])

            {

                // 2. 중복된 값이 있으면 1번으로 돌아가서 다시 난수를 저장한다.

                LOTTO_INSERT_RECORD(ppLotto, countCols);

                LOTTO_UPDATE_RECORD(ppLotto, countCols);

            }

        }

    }

    // 3. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_UPDATE_TABLE(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열의 각 요소에 중복된 값이 있는지 확인한다.

    for (int i = 0; i < countRows; i++)

    {

        for (int j = 0; j < i; j++)

        {

            int count = 0;

            for (int k = 0; k < countCols; k++)

            {

                if ((*pppLotto)[i][k] == (*pppLotto)[j][k])

                {

                    if (i >= 1)

                    {

                        // 2. 중복된 값이 있으면 1번으로 돌아가서 다시 난수를 저장한다.

                        count++;

                        if (count == 6)

                        {

                            LOTTO_INSERT_RECORD(&((*pppLotto)[i]), countCols);

                            LOTTO_UPDATE_RECORD(&((*pppLotto)[i]), countCols);

                            j = i;

                            i--;

                            break;

                        }

                    }

                }

            }

        }

    }

    // 3. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_ORDER_BY_RECORD(int **ppLotto, int countCols)

{

    // 1. 1차원 배열의 각 요소를 오름차순으로 정렬한다.

    for (int i = 0; i < countCols; i++)

    {

        for (int j = i + 1; j < countCols; j++)

        {

            if ((*ppLotto)[i] > (*ppLotto)[j])

            {

                int temp = (*ppLotto)[i];

                (*ppLotto)[i] = (*ppLotto)[j];

                (*ppLotto)[j] = temp;

            }

        }

    }

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_ORDER_BY_TABLE(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열의 각 요소를 오름차순으로 정렬한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_ORDER_BY_RECORD(&((*pppLotto)[i]), countCols);

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_ORDER_BY_TABLE_ASC(int ***pppLotto, int countRows, int countCols)

{

    for (int i = 0; i < countRows; i++)

    {

        for (int j = i + 1; j < countRows; j++)

        {

            for (int k = 0; k < countCols; k++)

            {

                if ((*pppLotto)[i][k] > (*pppLotto)[j][k])

                {

                    int *temp = (*pppLotto)[i];

                    (*pppLotto)[i] = (*pppLotto)[j];

                    (*pppLotto)[j] = temp;

                    break;

                }

                else if ((*pppLotto)[i][k] < (*pppLotto)[j][k])

                {

                    break;

                }

            }

        }

    }

}

int LOTTO_ORDER_BY_TABLE_DESC(int ***pppLotto, int countRows, int countCols)

{

    for (int i = 0; i < countRows; i++)

    {

        for (int j = i + 1; j < countRows; j++)

        {

            for (int k = 0; k < countCols; k++)

            {

                if ((*pppLotto)[i][k] < (*pppLotto)[j][k])

                {

                    int *temp = (*pppLotto)[i];

                    (*pppLotto)[i] = (*pppLotto)[j];

                    (*pppLotto)[j] = temp;

                    break;

                }

                else if ((*pppLotto)[i][k] > (*pppLotto)[j][k])

                {

                    break;

                }

            }

        }

    }

}

int LOTTO_ORDER_BY_TABLE_COLUMN_ASC(int ***pppLotto, int countRows, int countCols, int column)

{

    for (int i = 0; i < countRows; i++)

    {

        for (int j = i + 1; j < countRows; j++)

        {

            if ((*pppLotto)[i][column] > (*pppLotto)[j][column])

            {

                int *temp = (*pppLotto)[i];

                (*pppLotto)[i] = (*pppLotto)[j];

                (*pppLotto)[j] = temp;

            }

        }

    }

}

int LOTTO_ORDER_BY_TABLE_COLUMN_DESC(int ***pppLotto, int countRows, int countCols, int column)

{

    // 1. 2차원 배열의 각 요소를 내림차순으로 정렬한다.

    for (int i = 0; i < countRows; i++)

    {

        for (int j = i + 1; j < countRows; j++)

        {

            if ((*pppLotto)[i][column] < (*pppLotto)[j][column])

            {

                int *temp = (*pppLotto)[i];

                (*pppLotto)[i] = (*pppLotto)[j];

                (*pppLotto)[j] = temp;

            }

        }

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_RECORD(int **ppLotto, int countCols)

{

    // 1. 1차원 배열의 각 요소를 출력한다.

    for (int i = 0; i < countCols; i++)

    {

        printf("%d ", (*ppLotto)[i]);

    }

    printf("\n");

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_TABLE(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열의 각 요소를 출력한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_SELECT_RECORD(&((*pppLotto)[i]), countCols);

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_PAPER_RUN(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열을 동적 할당한다.

    LOTTO_CREATE_TABLE(pppLotto, countRows, countCols);

    // 2. 씨드를 밀리 초 단위로 설정한다.

    LOTTO_SETTING(0);

    // 3. 2차원 배열의 각 요소에 1 ~ 45 사이의 난수를 저장한다.

    LOTTO_INSERT_TABLE(pppLotto, countRows, countCols);

    // 4. 2차원 배열의 각 요소를 오름차순으로 정렬한다.

    LOTTO_ORDER_BY_TABLE(pppLotto, countRows, countCols);

    // 5. 2차원 배열의 각 요소에 중복된 값이 있는지 확인한다.

    LOTTO_UPDATE_TABLE(pppLotto, countRows, countCols);

    // 6. 2차원 배열의 행을 오름차순으로 정렬한다.

    LOTTO_ORDER_BY_TABLE_ASC(pppLotto, countRows, countCols);

    // 7. 2차원 배열의 각 요소를 출력한다.

    LOTTO_SELECT_TABLE(pppLotto, countRows, countCols);

    // 8. 2차원 배열의 메모리를 해제한다.

    LOTTO_DROP_TABLE(pppLotto, countRows);

    return 0;

}

int LOTTO_ROUND_RUN(int ***pppLottoRound, int lottoRoundRows, int lottoRoundCols)

{

    // 1. 로또 당첨 번호를 연결한다.

    LOTTO_CONNECT("WinningNumbers.txt", pppLottoRound, lottoRoundRows, lottoRoundCols);

    // 2. 로또 당첨 번호를 출력한다.

    LOTTO_SELECT_TABLE(pppLottoRound, lottoRoundRows, lottoRoundCols);

    // 3. 로또 당첨 번호 연결을 해제한다.

    LOTTO_DISCONNECT("WinningNumbers.txt", pppLottoRound, lottoRoundRows, lottoRoundCols);

    return 0;

}

int LOTTO_CONNECT(char *filename, int ***pppLotto, int countRows, int countCols)

{

    FILE *fp = NULL;

    fp = fopen(filename, "r");

    if (fp == NULL)

    {

        printf("파일 열기 실패\n");

        return -1;

    }

    //LOTTO_CREATE_TABLE(pppLotto, countRows, countCols);

    for (int i = 0; i < countRows; i++)

    {

        //LOTTO_CREATE_RECORD(&((*pppLotto)[i]), countCols);

        for (int j = 0; j < countCols; j++)

        {

            fscanf(fp, "%d", &((*pppLotto)[i][j]));

        }

    }

    fclose(fp);

    return 0;

}

int LOTTO_DISCONNECT(char *filename, int ***pppLotto, int countRows, int countCols)

{

    // 1. 로또 당첨 번호를 연결을 해제한다.

    //LOTTO_DROP_TABLE(pppLotto, countRows);

}

int LOTTO_SELECT_RECORD_ZERO(int **ppLotto, int countCols)

{

    // 1. 1차원 배열의 각 요소를 0으로 초기화한다.

    for (int i = 0; i < countCols; i++)

    {

        (*ppLotto)[i] = 0;

    }

}

int LOTTO_SELECT_TABLE_ZERO(int ***pppLotto, int countRows, int countCols)

{

    // 1. 2차원 배열의 각 요소를 0으로 초기화한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_SELECT_RECORD_ZERO(&((*pppLotto)[i]), countCols);

    }

}

int LOTTO_SELECT_RECORD_TOTAL(int **ppLottoSrc, int countCols, int *sum)

{

    // 1. 1차원 배열의 각 요소를 출력한다.

    // 2. 1차원 배열의 각 요소를 더한다.

    // 3. 1차원 배열에 합계를 저장한다.

    for (int i = 0; i < countCols; i++)

    {

        *sum += (*ppLottoSrc)[i];

    }

    // 4. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_RECORD_TOTAL_RANGE(int **ppLotto, int countCols, int *sum, int start, int end)

{

    // 1. 1차원 배열의 각 요소를 출력한다.

    // 2. 1차원 배열의 각 요소를 더한다.

    for (int i = start; i <= end; i++)

    {

        *sum += (*ppLotto)[i];

    }

    // 3. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_RECORD_TOTAL_BETWEEN(int **ppLotto, int countCols, int *sum, int min, int max)

{

    // 1. 1차원 배열의 각 요소를 출력한다.

    // 2. 1차원 배열의 각 요소를 더한다.

    for (int i = 0; i < countCols; i++)

    {

        *sum += (*ppLotto)[i];

    }

    // 3. 합계가 min ~ max 사이인지 확인한다.

    if (*sum >= min && *sum <= max)

    {

        // 4. 1차원 배열의 주소를 반환한다.

        return 0;

    }

    else

    {

        // 4. 1차원 배열의 주소를 반환한다.

        *sum = 0;

        return -1;

    }

    // 4. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_RECORD_TOTAL_RANGE_BETWEEN(int **ppLotto, int countCols, int *sum, int start, int end, int min, int max)

{

    // 1. 1차원 배열의 각 요소를 출력한다.

    // 2. 1차원 배열의 각 요소를 더한다.

    for (int i = start; i <= end; i++)

    {

        *sum += (*ppLotto)[i];

    }

    // 3. 합계가 min ~ max 사이인지 확인한다.

    if (*sum >= min && *sum <= max)

    {

        // 4. 1차원 배열의 주소를 반환한다.

        return 0;

    }

    else

    {

        // 4. 1차원 배열의 주소를 반환한다.

        *sum = 0;

        return -1;

    }

    // 4. 1차원 배열의 주소를 반환한다.

    // 2. 1차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_TABLE_TOTAL(int ***pppLotto, int countRows, int countCols, int **sum)

{

    // 1. 2차원 배열의 각 요소를 출력한다.

    // 2. 2차원 배열의 각 요소를 더한다.

    // 3. 2차원 배열에 합계를 1차원 배열에 순서대로 저장한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_SELECT_RECORD_TOTAL(&((*pppLotto)[i]), countCols, &((*sum)[i]));

    }

    // 4. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_TABLE_TOTAL_RANGE(int ***pppLotto, int countRows, int countCols, int **sum, int start, int end)

{

    // 1. 2차원 배열의 각 요소를 출력한다.

    // 2. 2차원 배열의 각 요소를 더한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_SELECT_RECORD_TOTAL_RANGE(&((*pppLotto)[i]), countCols, &((*sum)[i]), start, end);

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_TABLE_TOTAL_BETWEEN(int ***pppLotto, int countRows, int countCols, int **sum, int min, int max)

{

    // 1. 2차원 배열의 각 요소를 출력한다.

    // 2. 2차원 배열의 각 요소를 더한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_SELECT_RECORD_TOTAL_BETWEEN(&((*pppLotto)[i]), countCols, &((*sum)[i]), min, max);

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_TABLE_TOTAL_RANGE_BETWEEN(int ***pppLotto, int countRows, int countCols, int **sum, int start, int end, int min, int max)

{

    // 1. 2차원 배열의 각 요소를 출력한다.

    // 2. 2차원 배열의 각 요소를 더한다.

    for (int i = 0; i < countRows; i++)

    {

        LOTTO_SELECT_RECORD_TOTAL_RANGE_BETWEEN(&((*pppLotto)[i]), countCols, &((*sum)[i]), start, end, min, max);

    }

    // 2. 2차원 배열의 주소를 반환한다.

    return 0;

}

int LOTTO_SELECT_TABLE_TOTAL_AVERAGE(int ***pppLotto, int countRows, int countCols, int average)

{

    int *sum = NULL;

    int *pAverage = NULL;

    LOTTO_CREATE_RECORD(&sum, countRows);

    LOTTO_CREATE_RECORD(&pAverage, 300 / average);

    LOTTO_SELECT_TABLE_TOTAL_BETWEEN(pppLotto, countRows, countCols, &sum, 0, 300);

    for (int i = 0; i < 300 / average; i++)

    {

        for (int j = 0; j < countRows; j++)

        {

            if (*((*pppLotto)[j]) >= i * average && *((*pppLotto)[j]) < (i + 1) * average)

            {

                pAverage[i]++;

            }

        }

    }

    int indexer = 0;

    for (int i = 0; i < 300 / average; i++)

    {

        printf("(%d %d) : %d\n", indexer + 1, i * average + average, pAverage[i]);

        indexer = i * average + average;

    }

    LOTTO_DROP_RECORD(&sum);

    LOTTO_DROP_RECORD(&pAverage);

    return 0;

}

int LOTTO_SELECT_TABLE_TOTAL_AVERAGE_RANGE(int ***pppLotto, int countRows, int countCols, int average)

{

    int *sum = NULL;

    int *pAverage = NULL;

    LOTTO_CREATE_RECORD(&sum, countRows);

    LOTTO_CREATE_RECORD(&pAverage, 300 / average);

    LOTTO_SELECT_TABLE_TOTAL_RANGE_BETWEEN(pppLotto, countRows, countCols, &sum, 1, 6, 0, 300);

    for (int i = 0; i < 300 / average; i++)

    {

        for (int j = 0; j < countRows; j++)

        {

            if (*((*pppLotto)[j]) >= i * average && *((*pppLotto)[j]) < (i + 1) * average)

            {

                pAverage[i]++;

            }

        }

    }

    int indexer = 0;

    for (int i = 0; i < 300 / average; i++)

    {

        printf("(%d %d) : %d\n", indexer + 1, i * average + average, pAverage[i]);

        indexer = i * average + average;

    }

    LOTTO_DROP_RECORD(&sum);

    LOTTO_DROP_RECORD(&pAverage);

    return 0;

}

int main(void)

{

    int **ppLottoPaper = NULL;

    int lottoPaperRows = 5;

    int lottoPaperCols = 6;

    int **ppLottoRound = NULL;

    int lottoRoundRows = 1102;

    int lottoRoundCols = 8;

    int *pLottoPaperSelectTotal = NULL;

    int *pLottoRoundSelectTotal = NULL;

    int **ppLottoPaperSelectTotal = NULL;

    int **ppLottoRoundSelectTotal = NULL;

    int *pLottoPaperCountRows = NULL;

    int *pLottoRoundCountRows = NULL;

    // 로또를 구입하다.

    // 1. 2차원 배열을 동적 할당한다.

    LOTTO_CREATE_TABLE(&ppLottoPaper, lottoPaperRows, lottoPaperCols);

    // 2. 씨드를 밀리 초 단위로 설정한다.

    LOTTO_SETTING(0);

    // 3. 2차원 배열의 각 요소에 1 ~ 45 사이의 난수를 저장한다.

    LOTTO_INSERT_TABLE(&ppLottoPaper, lottoPaperRows, lottoPaperCols);

    // 4. 2차원 배열의 각 요소를 오름차순으로 정렬한다.

    LOTTO_ORDER_BY_TABLE(&ppLottoPaper, lottoPaperRows, lottoPaperCols);

    // 5. 2차원 배열의 각 요소에 중복된 값이 있는지 확인한다.

    LOTTO_UPDATE_TABLE(&ppLottoPaper, lottoPaperRows, lottoPaperCols);

    // 6. 2차원 배열의 행을 오름차순으로 정렬한다.

    LOTTO_ORDER_BY_TABLE_ASC(&ppLottoPaper, lottoPaperRows, lottoPaperCols);

    // 7. 2차원 배열의 각 요소를 출력한다.

    LOTTO_SELECT_TABLE(&ppLottoPaper, lottoPaperRows, lottoPaperCols);

    // 로또의 총합을 구하다.

    // 1. 1차원 배열을 동적 할당한다.

    LOTTO_CREATE_RECORD(&pLottoPaperSelectTotal, lottoPaperRows);

    // 2. 2차원 배열의 행의 합계를 1차원 배열에 저장한다.

    LOTTO_SELECT_TABLE_TOTAL(&ppLottoPaper, lottoPaperRows, lottoPaperCols, &pLottoPaperSelectTotal);

    // 3. 1차원 배열의 각 요소를 출력한다.

    LOTTO_SELECT_RECORD(&pLottoPaperSelectTotal, lottoPaperRows);

    // 당첨번호를 불러오다.

    // 1. 2차원 배열을 동적 할당한다.

    LOTTO_CREATE_TABLE(&ppLottoRound, lottoRoundRows, lottoRoundCols);

    // 2. 당첨번호를 연결한다.

    LOTTO_CONNECT("WinningNumbers.txt", &ppLottoRound, lottoRoundRows, lottoRoundCols);

    // 3. 1차원 배열을 동적 할당한다.

    LOTTO_CREATE_RECORD(&pLottoRoundSelectTotal, lottoRoundRows);

    // 4. 2차원 배열의 행의 합계를 1차원 배열에 저장한다.

    LOTTO_SELECT_TABLE_TOTAL_RANGE(&ppLottoRound, lottoRoundRows, lottoRoundCols, &pLottoRoundSelectTotal, 1, 6);

    // 5. 1차원 배열의 각 요소를 출력한다.

    //LOTTO_SELECT_RECORD(&pLottoRoundSelectTotal, lottoRoundRows);

    // 6. 2차원 배열의 각 요소를 출력한다.

    LOTTO_SELECT_TABLE(&ppLottoRound, lottoRoundRows, lottoRoundCols);

    // 로또 및 당첨번호의 총합을 구하다.

    // 1. 2차원 배열을 동적 할당한다.

    LOTTO_CREATE_TABLE(&ppLottoPaperSelectTotal, lottoPaperRows, 2);

    LOTTO_CREATE_TABLE(&ppLottoRoundSelectTotal, lottoRoundRows, 2);

    // 2. 1차원 배열을 동적 할당한다.

    LOTTO_CREATE_RECORD(&pLottoPaperCountRows, lottoPaperRows);

    LOTTO_CREATE_RECORD(&pLottoRoundCountRows, lottoRoundRows);

    // 3. 1차원 배열의 각 요소를 카운트한다.

    LOTTO_COUNT_ROWS(&pLottoPaperCountRows, lottoPaperRows);

    LOTTO_COUNT_ROWS(&pLottoRoundCountRows, lottoRoundRows);

    // 4. 2차원 배열에 1차원 배열의 각 요소를 저장한다.

    LOTTO_COPY_RECORD_TO_TABLE_COLUMN(&pLottoPaperSelectTotal, &ppLottoPaperSelectTotal, lottoPaperRows, 2, 0);

    LOTTO_COPY_RECORD_TO_TABLE_COLUMN(&pLottoRoundSelectTotal, &ppLottoRoundSelectTotal, lottoRoundRows, 2, 0);

    // 5. 2차원 배열에 1차원 배열의 각 요소를 저장한다.

    LOTTO_COPY_RECORD_TO_TABLE_COLUMN(&pLottoPaperCountRows, &ppLottoPaperSelectTotal, lottoPaperRows, 2, 1);

    LOTTO_COPY_RECORD_TO_TABLE_COLUMN(&pLottoRoundCountRows, &ppLottoRoundSelectTotal, lottoRoundRows, 2, 1);

    // 6. 2차원 배열의 각 요소를 출력한다.

    //LOTTO_SELECT_TABLE(&ppLottoPaperSelectTotal, lottoPaperRows, 2);

    //LOTTO_SELECT_TABLE(&ppLottoRoundSelectTotal, lottoRoundRows, 2);

    // 7. 2차원 배열의 첫 번째 열을 기준으로 내림차순으로 정렬한다.

    //LOTTO_ORDER_BY_TABLE_COLUMN_DESC(&ppLottoPaperSelectTotal, lottoPaperRows, 2, 0);

    //LOTTO_ORDER_BY_TABLE_COLUMN_DESC(&ppLottoRoundSelectTotal, lottoRoundRows, 2, 0);

    // 8. 2차원 배열의 각 요소를 출력한다.

    //LOTTO_SELECT_TABLE(&ppLottoPaperSelectTotal, lottoPaperRows, 2);

    // 9. 2차원 배열의 두 번째 열을 기준으로 내림차순으로 정렬한다.

    //LOTTO_ORDER_BY_TABLE_COLUMN_DESC(&ppLottoPaperSelectTotal, lottoPaperRows, 2, 1);

    //LOTTO_ORDER_BY_TABLE_COLUMN_DESC(&ppLottoRoundSelectTotal, lottoRoundRows, 2, 1);

    // 10. 2차원 배열의 각 요소를 출력한다.

    LOTTO_SELECT_TABLE(&ppLottoPaperSelectTotal, lottoPaperRows, 2);

    // 11. 2차원 배열의 총합을 구해서 일정한 간격으로 출력한다.

    LOTTO_SELECT_TABLE_TOTAL_AVERAGE(&ppLottoPaperSelectTotal, lottoPaperRows, 2, 50);

    // 12. 2차원 배열의 총합을 구해서 일정한 간격으로 출력한다.

    LOTTO_SELECT_TABLE_TOTAL_AVERAGE_RANGE(&ppLottoRoundSelectTotal, lottoRoundRows, 2, 50);

    // 메모리를 해제하다.

    // 13. 1차원 배열의 메모리를 해제한다.

    LOTTO_DROP_RECORD(&pLottoRoundCountRows);

    // 14. 1차원 배열의 메모리를 해제한다.

    LOTTO_DROP_RECORD(&pLottoPaperCountRows);

    // 15. 2차원 배열의 메모리를 해제한다.

    LOTTO_DROP_TABLE(&ppLottoRoundSelectTotal, lottoRoundRows);

    // 16. 2차원 배열의 메모리를 해제한다.

    LOTTO_DROP_TABLE(&ppLottoPaperSelectTotal, lottoPaperRows);

    // 4. 1차원 배열의 메모리를 해제한다.

    LOTTO_DROP_RECORD(&pLottoRoundSelectTotal);

    // 5. 당첨번호를 연결을 해제한다.

    LOTTO_DISCONNECT("WinningNumbers.txt", &ppLottoRound, lottoRoundRows, lottoRoundCols);

    // 4. 1차원 배열의 메모리를 해제한다.

    LOTTO_DROP_RECORD(&pLottoRoundSelectTotal);

    // 4. 1차원 배열의 메모리를 해제한다.

    LOTTO_DROP_RECORD(&pLottoPaperSelectTotal);

    // 8. 2차원 배열의 메모리를 해제한다.

    LOTTO_DROP_TABLE(&ppLottoPaper, lottoPaperRows);

    return 0;

}

LottoMagic.c

30.68KB

WinningNumbers.txt

26.49KB