Uma fábrica de enchimento de sumos precisa de comprar novas máquinas para uma das fases finais da sua produção. Antes da compra, o concelho de administradores decidiu mandar desenvolver uma simulação para aferir o nível da produção. A simulação consiste no enunciado descrito na Visão Geral, tendo em conta as instruções, implementação, pontuação e penalizações descritas neste documento. Crie um programa que permita remover uma caixa etiquetada do tapete rolante e encaminhá-la para a fila de empilhamento. Devem ser encaminhadas até duas caixas para que haja um empilhamento. Enquanto a máquina estiver ocupada, não poderão ser encaminhadas novas caixas.

Passo 1

Então, temos uma fábrica de sucos que está precisando comprar novas máquinas para uma das fases finais da produção. Antes de fazer essa compra, o time de administradores decidiu criar uma simulação para entender melhor como a produção vai se comportar. O que precisamos fazer aqui é criar um programa que consiga:
  1. Remover uma caixa etiquetada do tapete rolante.
  2. Enviar essa caixa para uma fila de empilhamento.
  3. Permitir que até duas caixas sejam enviadas para o empilhamento ao mesmo tempo.
  4. Garantir que, enquanto a máquina estiver ocupada processando caixas, novas caixas não possam ser enviadas.
Para resolver isso, vamos precisar entender conceitos como filas (queues), controle de estado da máquina (ocupada ou livre) e como gerenciar múltiplas caixas ao mesmo tempo. Vamos lá!

Passo 2

Primeiro, vamos pensar em como representar as caixas e o tapete rolante. Podemos considerar cada caixa como um objeto com uma etiqueta. O tapete rolante pode ser representado como uma fila, já que as caixas chegam em ordem e são processadas na sequência.
Aqui, vamos precisar usar uma estrutura de dados chamada “fila” (queue) que funciona no estilo “primeiro a entrar, primeiro a sair” (FIFO - First In, First Out). Isso significa que a primeira caixa que chega será a primeira a ser processada.

Passo 3

Agora, precisamos representar a máquina que processa as caixas para empilhamento. A máquina pode estar em dois estados: “livre” ou “ocupada”. Quando uma máquina está livre, ela pode começar a processar uma ou duas caixas. Se estiver ocupada, não podemos enviar novas caixas até que ela termine o processamento atual.
Vamos usar uma variável para controlar o estado da máquina. Por exemplo, uma variável booleana chamada maquina_ocupada que será False quando a máquina estiver livre e True quando estiver ocupada.

Passo 4

Vamos pensar em como implementar a lógica para remover uma caixa do tapete rolante e enviá-la para a fila de empilhamento. Quando a máquina estiver livre, ela pode pegar até duas caixas da fila e começar o empilhamento, mudando seu estado para “ocupada”.
Depois que o empilhamento for concluído, a máquina volta a ficar “livre” e pode processar as próximas caixas da fila.

Passo 5

Para implementar isso no programa, podemos seguir estes passos:
  1. Criar uma fila para o tapete rolante.
  2. Adicionar caixas etiquetadas a essa fila.
  3. Implementar a lógica da máquina que verifica se está livre.
  4. Se a máquina estiver livre, remover até duas caixas da fila e iniciar o empilhamento.
  5. Enquanto a máquina estiver ocupada, não permitir que novas caixas sejam enviadas para o empilhamento.
  6. Após o empilhamento, atualizar o estado da máquina para livre.

Passo 6

Vamos agora escrever um exemplo simples de como isso pode ser implementado em Python. Não se preocupe se você não conhece Python profundamente, vou explicar cada parte:
from collections import deque
import time

# Inicializa a fila do tapete rolante
tapete_rolante = deque()

# Função para adicionar caixas ao tapete
def adicionar_caixa(etiqueta):
    tapete_rolante.append(etiqueta)
    print(f"Caixa {etiqueta} adicionada ao tapete rolante.")

# Estado da máquina
maquina_ocupada = False

# Função para processar empilhamento
def processar_empilhamento():
    global maquina_ocupada
    if not maquina_ocupada and len(tapete_rolante) > 0:
        caixas_para_empilhar = []
        for _ in range(2):  # Até duas caixas
            if len(tapete_rolante) > 0:
                caixas_para_empilhar.append(tapete_rolante.popleft())
        if caixas_para_empilhar:
            maquina_ocupada = True
            print(f"Empilhando caixas: {', '.join(caixas_para_empilhar)}")
            # Simula o tempo de empilhamento
            time.sleep(2)
            print("Empilhamento concluído.")
            maquina_ocupada = False
    else:
        if maquina_ocupada:
            print("Máquina está ocupada. Aguarde...")
        else:
            print("Nenhuma caixa para empilhar.")

# Exemplo de uso
adicionar_caixa("A1")
adicionar_caixa("A2")
adicionar_caixa("A3")

processar_empilhamento()  # Processa A1 e A2
processar_empilhamento()  # Processa A3
processar_empilhamento()  # Não há mais caixas

Resposta

Com esse programa, você consegue simular a remoção de caixas etiquetadas do tapete rolante e enviá-las para a fila de empilhamento, respeitando as regras de até duas caixas por empilhamento e garantindo que enquanto a máquina estiver ocupada, novas caixas não possam ser enviadas. Basta executar o código e observar como as caixas são processadas!

Exercícios relacionados