Simulação de supermercado. Escreva um programa

que simule uma fila no caixa de um supermercado. A fila

é um objeto fila. Os clientes chegam em intervalos inteiros

aleatórios de 1 a 4 minutos. Além disso, cada cliente é

atendido em intervalos inteiros aleatórios de 1 a 4 minutos.

Obviamente, as taxas precisam ser equilibradas. Se a

taxa de chegada média é maior que a taxa de atendimento

médio, a fila crescerá infinitamente. Mesmo com taxas

‘equilibradas’, a aleatoriedade ainda pode causar longas

filas. Execute a simulação do supermercado para um dia

de 12 horas (720 minutos), usando o seguinte algoritmo:

1) Escolha um inteiro aleatório entre 1 e 4 para determinar

o minuto no qual o primeiro cliente chega.

2) No momento de chegada do primeiro cliente:

Determine a hora de atendimento do cliente (um inteiro

aleatório de 1 a 4);

Comece a atender o cliente;

Programe a hora de chegada do próximo cliente (um inteiro

aleatório de 1 a 4 somado à hora atual).

3) Para cada minuto do dia:

Se o próximo cliente chega, informe;

Coloque-o na fila;

Programe a hora de chegada do próximo

cliente;

Se o atendimento ao último cliente foi completado:

Informe;

Retire da fila o próximo cliente a ser atendido;

Determine a hora de conclusão do atendimento

ao cliente (um inteiro aleatório de 1 a 4

somado à hora atual).

Agora execute sua simulação para 720 minutos e responda

às perguntas a seguir:

a) Qual é o número máximo de clientes na fila, em

qualquer momento?

b) De quanto tempo foi a espera mais longa que um

cliente teve de experimentar?

c) O que acontece se o intervalo de chegada for

Passo 1

O código a seguir é uma simulação de supermercado.

Neste exercício, precisamos escrever uma simulação de supermercado. O supermercado é simulado usando queue. O primeiro cliente chega em um horário aleatório durante o dia e é atendido por um horário aleatório entre 11 e 44 minutos. Novos clientes chegam a cada 11 a 44 minutos. Se eles chegarem enquanto o cliente estiver sendo atendido, eles serão adicionados à fila. Caso contrário, eles são atendidos imediatamente. Quando o serviço for concluído, se houver clientes na fila, o próximo cliente será retirado da fila. Cada cliente tem um tempo aleatório de atendimento entre 11 e 44 minutos. A simulação é executada por 720720 minutos com o loop for.

Passo 2

O código a seguir é uma simulação de supermercado.

#include

#include

#include

typedef struct queueNode{

int timeArrived;

struct queueNode *next;

} QueueNode;

typedef QueueNode *queuePtr;

/*Prototypes*/

void enqueue(queuePtr *head, queuePtr *tail, int data);

int dequeue(queuePtr *head, queuePtr *tail);

int isEmpty(queuePtr head);

int queueCounter(queuePtr head);

int main(void){

int firstArrival,serviceTime,nextArrival;

int maxQueue = 0;

int longestWaitTime = 0;

int waitTime;

queuePtr head = NULL,tail = NULL;

srand(time(0));

/*Random moment of the first arrival*/

firstArrival = rand()%4 + 1;

/*12-hour day*/

for(int i = 1; i

/*If first customer arrived*/

if(i == firstArrival){

printf("First customer arrived.\n");

/*Get service time and the time

*of next arrival

*/

serviceTime = i + rand() % 4 + 1;

nextArrival = i + rand() % 4 + 1;

}

if(i == nextArrival){

/*If there is no customers in the line or

*being served, serve the one that came

*/

if(isEmpty(head)==1 && i > serviceTime){

serviceTime = i + rand() % 4 + 1;

}else{

/*Otherwise, add to queue*/

enqueue(&head,&tail,i);

}

printf("New customer arrived. Customers in

queue: %d\n", queueCounter(head));

nextArrival = nextArrival + rand() % 4 + 1;

}

if(i == serviceTime){

/*When service is completed*/

if(isEmpty(head)==1){

/*If there are no customers in queue*/

printf("All customers have been

served.\n");

}else{

/*If there are customers in queue,

*dequeue the next one

*/

waitTime = i - dequeue(&head,&tail);

if(waitTime > longestWaitTime){

/*Find the longest wait time*/

longestWaitTime = waitTime;

}

printf("Next customer. Customers in

queue: %d\n", queueCounter(head));

/*Calculate the service time*/

serviceTime = serviceTime

+ rand() % 4 + 1;

}

}

/*Check the number of people in the queue in each

*minute of the day

*/

if(queueCounter(head) > maxQueue){

maxQueue = queueCounter(head);

}

}

printf("The maximum number of customers is:

%d\n",maxQueue);

printf("The longest time a customer has waited in

queue is: %d\n",longestWaitTime);

return 0;

}

void enqueue(queuePtr *head, queuePtr *tail, int data){

queuePtr newNode = malloc(sizeof(QueueNode));

if(newNode == NULL) return;

newNode->timeArrived = data;

newNode->next = NULL;

if(isEmpty(*head)==1){

/*If the queue is empty, set head and

*tail at the newNode

*/

*head = newNode;

*tail = newNode;

}else{

(*tail)->next = newNode;

*tail = newNode;

}

}

int dequeue(queuePtr *head, queuePtr *tail){

int value = (*head)->timeArrived;

queuePtr temp;

temp = *head;

*head = (*head)->next;

/*If queue is empty, set end of queue to null*/

if(*head == NULL){

*tail = NULL;

}

/*Free space*/

free(temp);

return value;

}

int isEmpty(queuePtr head){

/*Check if the queue is empty*/

if(head == NULL) return 1;

return 0;

}

int queueCounter(queuePtr head){

/*Count the number of customers in queue*/

int count = 0;

while(head != NULL){

count++;

head=head->next;

}

return count;

}

Passo 3

O número máximo teórico de clientes na fila é quando leva 4 minutos para atender um cliente e os outros clientes chegam a cada minuto. Isso é igual a 540 clientes na fila.

Se as taxas de tempo de atendimento e de chegada estiverem equilibradas, o maior número observado de clientes na fila é 20

A espera teórica mais longa na fila é quando leva 4 minutos para atender um cliente e os outros clientes chegam a cada minuto. É igual a 537 minutos.

Se as taxas de tempo de serviço e tempo de chegada estiverem equilibradas, a espera mais longa observada na fila será de 52 minutos.

Se o intervalo de chegada for alterado de 1 a 4 minutos para 1 a 3 minutos, o número de clientes e o tempo de espera aumentam.

Resposta

Ver o desenvolvimento.