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.