C¾ð¾î Áú¹®ÀÔ´Ï´Ù.(¼öÁ¤Çß½À´Ï´Ù)

   Á¶È¸ 4641   Ãßõ 0    

¿øº»_¼Ò½ºÄÚµå.zip (1.5K), Down : 3, 2018-11

큐 문제를 보면서 공부하다 찾아볼만한 예제도 없어서 염치불구하고 이곳에...질문 올립니다.

데이터형을 추가하고 바꿨는데, CircularQueue.c 파일에서 오류가 발생하네요. 

문제 사진과 함께, 내용을 보강합니다. 


[주어진 시뮬레이션 파일의 주제]

- 주문한 음식이 포장되어 나오기를 기다리는 고객을 위한 대기실을 만드려고 함

- 원형 큐로 구현.

[조건]

- 운영 시간은 1시간

대기실의 크기는 100명을 수용할 수 있다고 가정.

- 고객의 첫 주문 이후 15초당 다음 1명씩 주문

- 고객은 총 3가지 햄버거 중 무작위로 1개만 주문 가능

- 햄버거 조리 시간(치즈버거 12초, 불고기버거 15초, 더블버거 24초)

- 한 번에 하나의 햄버거만 조리가능

- 조리가 끝나기 전까지 다음 주문을 받지 않음

- 주문 처리가 된 고객은 대기실에서 나옴

[목표]

- 1시간 동안 여러 종류의 햄버거를 요리하는 상황에서 고객을 대기시킬 수 있는 대기실의 크기를 산출하기 위하여 크기에 따라 얼마나 안정적으로 수용할 수 있는지 확률적으로 나타내기

[만들고자 하는 과제의 요구 사항]

0. 주어진 시뮬레이션 예제 코드를 기반으로 수정.

1. 주문 시간과 전체 시간, 평균 시간을 초단위에서 분으로 변경. 

2. 조리시간과 메뉴 정보를 저장하기 위한 데이터 형을 추가하고, 이 추가한 데이터형에 맞게 큐가 동작할 수 있도록 헤더 파일, C파일 수정.

3.고객의 주문간격을 3분으로 고정하고, 고객이 주문한 후 주방에서 주문한 음식을 요리하기 

시작하기 전까지의 평균 대기시간(waitingTime)를 계산하는 프로그램 작성.

4.주문 간격을 1~5분 사이 랜덤으로 지정하고, 마찬가지로 평균 대기시간을 계산하는 프로그램 구현.

5.4의 조건에서 주방을 2개로 늘려 평균 대기시간 계산하기.

sim.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>
#include <stdlib.h>          // rand, srand 함수를 사용하기 위함
#include <time.h>            // time 함수를 사용하기 위함
#include "CircularQueue.c"
#define CUS_COME_TERM  3  // 고객의 주문 간격: 분 단위
 
#define CHE_BUR     0        // 상수: 치즈버거
#define BUL_BUR     1        // 상수: 불고기버거
#define DUB_BUR     2        // 상수: 더블버거
 
#define CHE_TERM    2       // 조리 시간(min): 치즈버거
#define BUL_TERM    3       // 조리 시간(min): 불고기버거
#define DUB_TERM    5       // 조리 시간(min): 더블버거
 
int main(void)
{
    int makeProc = 0;
    int cheOrder = 0, bulOrder = 0, dubOrder = 0;
    int min;
    double waitingtime=0;
 
    Queue que;
 
    QueueInit(&que);
    srand(time(NULL));
 
    for(min=0; min<60; min++)
    {
        if(min % CUS_COME_TERM == 0)
        {
            switch(rand() % 3)
            {
                case CHE_BUR:
                    Enqueue(&que, CHE_TERM);
                    data.cookingTime=QueTerm;
                    data.arrivalTime=min;
                    Enquee(&que,data);
                    
                    cheOrder += 1;
                    break;
 
                case BUL_BUR:
                    Enqueue(&que, BUL_TERM);
                    data.cookingTime=QueTerm;
                    data.arrivalTime=min;
                    Enquee(&que,data);
                    bulOrder += 1;
                    break;
 
                case DUB_BUR:
                    Enqueue(&que, DUB_TERM);
                    data.cookingTime=QueTerm;
                    data.arrivalTime=min;
                    Enquee(&que,data);
                    dubOrder += 1;
                    break;
            }
        }
 
        if(makeProc <= 0 && !QIsEmpty(&que))
           { Data=Dequeue(&que);
             makeProc = data.cookingTime;
             waitingtime=waitingtime+(min-data.arrivaltime);
                 makeProc = Dequeue(&que);
            } 
 
        makeProc--;
        
    }
 
    printf("Simulation Report!! \n\n");
    printf("[Order Count]\n");
    printf("- Cheese Burger: %d \n", cheOrder);
    printf("- Bulgogi Burger: %d \n", bulOrder);
    printf("- Double Burger: %d \n\n", dubOrder);
    printf("※ Waiting room size: %d \n", waitingtime);
    printf("※ Waiting room size: %d \n", arrivaltime);
 
 
    return 0;
}
 
 
cs


CircularQueue.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#ifndef CIRCULARQUEUE_H_
#define CIRCULARQUEUE_H_
 
#define TRUE     1
#define FALSE    0
 
#define QUE_LEN  100
 typedef struct Data{  //데이터형 추가(주문 시간 및 메뉴 정보 저장) 
     
     int cookingTime;
     int arrivalTime;
 }Data;
 
typedef struct _cQueue
{
    int front;                       // 삭제할 데이터의 위치를 가리키는 변수
    int rear;                        // 삽입할 데이터의 위치를 가리키는 변수
    Data queArr[QUE_LEN];             // QUE_LEN 길이를 갖는 큐 배열
} CQueue;
 
typedef CQueue Queue;
 
void QueueInit(Queue * pq);          // 큐 초기화 함수
int QIsEmpty(Queue * pq);            // 큐에 데이터가 존재하는지 확인하는 함수
 
void Enqueue(Queue * pq, int data);  // 큐에 데이터를 저장하는 함수
int Dequeue(Queue * pq);             // 큐의 데이터를 반환하는 함수
int QPeek(Queue * pq);               // 큐의 데이터를 조회하는 함수
 
#endif
 
cs


CircularQueue.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include <stdio.h>
#include <stdlib.h>            // exit 함수를 사용하기 위함
#include "CircularQueue.h"
 
// 큐 초기화 함수 //
void QueueInit(Queue * pq)
{
    pq->front = 0;
    pq->rear = 0;
}
 
// 큐에 데이터가 존재하는지 확인하는 함수 //
int QIsEmpty(Queue * pq)
{
    if(pq->front == pq->rear)
        return TRUE;
 
    else
        return FALSE;
}
 
// 큐의 다음 위치에 해당하는 배열의 인덱스 값을 반환하는 함수 //
int NextPosIdx(int pos)
{
    if(pos == QUE_LEN-1)
        return 0;
 
    else
        return pos+1;
}
 
// 큐에 데이터를 저장하는 함수 //
void Enqueue(Queue * pq, int data)
{
    if(NextPosIdx(pq->rear) == pq->front)
    {
        printf("Queue Memory FULL!!");
        exit(-1);
    }
 
    pq->rear = NextPosIdx(pq->rear);
    pq->queArr[pq->rear] = data; //여기서 오류가 발생합니다.
}
 
// 큐의 데이터를 반환하는 함수 //
int Dequeue(Queue * pq)
{
    if(QIsEmpty(pq))
    {
        printf("Queue Memory Empty!!");
        exit(-1);
    }
 
    pq->front = NextPosIdx(pq->front);
    return pq->queArr[pq->front];
}
 
// 큐의 데이터를 조회하는 함수 //
int QPeek(Queue * pq)
{
    if(QIsEmpty(pq))
    {
        printf("Queue Memory Empty!!");
        exit(-1);
    }
 
    return pq->queArr[NextPosIdx(pq->front)];
}
 
 
 
cs


고수님들의 가르침 기다리고 있겠습니다. 감사합니다. 

오류가 발생한 부분입니다.




int makeProc = 0;

    int cheOrder = 0, bulOrder = 0, dubOrder = 0;

    int min;

    double waitingtime = 0.0;

    int QueTerm;

    Queue que;

    QueueInit(&que);

    srand(time(NULL));


    for (min = 0; min < 60; min++)

    {

        if (min % CUS_COME_TERM == 0)

        {

            switch (rand() % 3)

            {

            case CHE_BUR:

                Enqueue(&que, CHE_TERM);

                Data.cookingTime = QueTerm;

                Data.arrivalTime = min;

                cheOrder += 1;

                break;


            case BUL_BUR:

                Enqueue(&que, BUL_TERM);

                data.cookingTime = QueTerm;

                data.arrivalTime = min;

                bulOrder += 1;

                break;


            case DUB_BUR:

                Enqueue(&que, DUB_TERM);

                data.cookingTime = QueTerm;

                data.arrivalTime = min;

                dubOrder += 1;

                break;

            }

        }

        if (makeProc <= 0 && !QIsEmpty(&que))

        {

            Data = Dequeue(&que);

            makeProc = data.cookingTime;

            waitingtime = waitingtime + (min - data.arrivaltime);

            makeProc = Dequeue(&que);

        }

        makeProc--;

    }

    printf("Simulation Report!! \n\n");

    printf("[Order Count]\n");

    printf("- Cheese Burger: %d \n", cheOrder);

    printf("- Bulgogi Burger: %d \n", bulOrder);

    printf("- Double Burger: %d \n\n", dubOrder);

    printf("※ 대기시간: %d \n", waitingtime);

    printf("※ 평균시간: %d \n", arrivalTime);

    return 0;

}




ªÀº±Û Àϼö·Ï ½ÅÁßÇÏ°Ô.
¹«¾Æ 2018-11
À½.. ¹¹¶ö±î...
2¹øºÎÅÍ ¸·È÷³×¿ä.. ¶ó´Â Áú¹®¿¡ ´ë´äÀº...
¿­½ÉÈ÷ Çϼ¼¿ä ¹Û¿¡ ¾øÀ» °Í °°½À´Ï´Ù.

Á¤È®ÇÏ°Ô ¹®Á¦¸¦ Ãß·Á¼­ ¿Ã¸®¼¼¿ä.
     
È®ÀÎÀÌ ´Ê¾ú³×¿ä. Áú¹® ³»¿ë º¸°­Çß½À´Ï´Ù.
Á¤ÀǼ® 2018-11
°í¼ö´ÔµéÀÌ¾ß Äڵ带 Çѹø ¾³ º¸¸é ¹Ù·Î ¾Æ½Ã°ÚÁö¸¸,,,¿À·ù ³»¿ëÀ» ¾Ë·ÁÁֽøé, ¸ÕÀú ºÁ¾ßÇÒ °÷À» ã±â ½¬¿ï°Å °°¾Æ¿ä.
¹Ú°æ¿ø 2018-11
queArr[idx] º¯¼öÀÇ Å¸ÀÔÀº Á¤ÀÇÇϽŠ"Data" ŸÀÔÀÔ´Ï´Ù. Enqueue ÇÔ¼ö°¡ queArr[idx]¿¡´Ù°¡ Áý¾î³ÖÀ¸·Á´Â data º¯¼ö´Â "int" ŸÀÔÀÌ°í¿ä...
¾îµð¼­ ¹®Á¦°¡ »ý°å´ÂÁö ¿¡·¯ ¸Þ½ÃÁö¿Í Äڵ常 º¸¿©ÁÖ½Ã¸é ´äº¯ÀÌ ´õ »¡¸® ´Þ¸± °Í °°³×¿ä
     
³×, ¿¡·¯¸Þ½ÃÁö È­¸é ¶ÇÇÑ Ã·ºÎÇß½À´Ï´Ù.
¹«¾Æ 2018-11
pq->queArr[pq->rear] = data; //¿©±â¼­ ¿À·ù°¡ ¹ß»ýÇÕ´Ï´Ù.
pq->queArr[] ´Â ÀÚ·áÇüÀÌ Data ÀÌ°í
data ´Â ÀÚ·áÇüÀÌ int ¶ó¼­ ´ëÀÔÀÌ ¾ÈµÇÁÒ.

(pq->queArr[pq->rear]).cookingTime = data;
ÀÌ µÇµç
(pq->queArr[pq->rear]).arrivalTime = data;
ÀÌ µÇµç.
¾Æ´Ô ´Ù¸¥ ¹«¾ùÀÌ µÇµç... ¿øÇÏ´Â °ÍÀ¸·Î ´ëÀÔÇϼ¼¿ä.

¾Æ..±×¸®°í.. ÇÁ·Î±×·¡¹Ö ÇÒ ¶§ Æú´õ¸íÀº °¡±ÞÀû ÇѱÛÀ» ¾²Áö¸¶¼¼¿ä. ³ªÁß¿¡ º°°Å ¾Æ´Ñ°Å ¶§¹®¿¡ »ðÁúÀ» ²Ï ±íÀÌÇÏ´Â °æ¿ì°¡ »ý±é´Ï´Ù.
     
ÀÏ´Ü ±× ºÎºÐÀº ¼öÁ¤Çߴµ¥ ´ÙÀ½ºÎºÐ¿¡¼­ ¶Ç ¹®Á¦°¡ ¹ß»ýÇϳ׿ä.
int Dequeue(Queue * pq)
{
if (QIsEmpty(pq))
{
printf("Queue Memory Empty!!");
exit(-1);
}

pq->front = NextPosIdx(pq->front);
return pq->queArr[pq->front];
}

// Å¥ÀÇ µ¥ÀÌÅ͸¦ Á¶È¸ÇÏ´Â ÇÔ¼ö //
int QPeek(Queue * pq)
{
if (QIsEmpty(pq))
{
printf("Queue Memory Empty!!");
exit(-1);
}
return pq->queArr[NextPosIdx(pq->front)];
}
ÀÏ´Ü ¿À·ù°¡ ¹ß»ýÇÏ´Â ºÎºÐµé ½ÇÇà°á°ú ĸóÇؼ­ ¿Ã¸®°Ú½À´Ï´Ù.
¹«¾Æ 2018-11
³»¿ë¿¡ º¸¸é
Enqueue(&que, CHE_TERM);
Enquee(&que,data);
ÀÌ·¸°Ô ºñ½ÁÇÑ À̸§ÀÇ ´Ù¸¥ ÀÔ·Â ÆĶó¹ÌÅÍ ÇÔ¼ö°¡ Àִµ¥
¿ÀŸÀΰ¡¿ä? ÀǵµµÈ °Ç°¡¿ä?
     
È®ÀÎÀÌ ´Ê¾ú³×¿ä. Á˼ÛÇÕ´Ï´Ù. È¥ÀÚ¼­ À̸®Àú¸® Çغ»´Ù°í ¸¸Á®ºÃ´Âµ¥ ½Ã°£ÀÌ ÀÌ·¸°Ô Áö³µ³×¿ä..
Enquee(&que,data);  ÀÌ°Ç ¿ÀŸ°°¾Æ¼­ »°½À´Ï´Ù.


QnA
Á¦¸ñPage 2205/5688
2015-12   1537013   ¹é¸Þ°¡
2014-05   5001182   Á¤ÀºÁØ1
2016-08   3486   ÀÌ°ÇÈñ
2018-11   4642   ¾È°³¼Ó¿µ¿ø
2021-04   2574   °Ü¿ï³ª¹«
2022-12   1578   ¹Ú¹®Çü
2005-09   5207   Á¤³²¿µ
2008-09   5182   ±è°Ç¿ì
2008-09   6052   ±èÁßÈñ
2016-08   4123   inquisitive
2018-11   3397   LINKINPARK
2005-09   6026   ±è°æ¶ô
2012-02   4995   À嵿°Ç2014
2003-01   10884   Á¤¿ø¿õ
2008-10   5959   ±èÁ¤ÈÆ
2014-03   3524   1mÀü
2017-08   3295   ¼­¿ïI±èµ¿¼ö
2021-05   1971   INMD
2017-08   3534   Sakura24
2008-10   4853   À庴µÎ
2021-05   2504   °í¿À½º
2023-01   2800   Rainwalk