Algoritmos e Estruturas de Dados [LEEC] (2024/2025)

Enunciado do Trabalho Prático

[Calendário] [Changelog] [Introdução] [Descrição] [Interface] [Avaliação] [Mooshak] [Erro de Execução] [Observações]

Calendário

30/abr - Início da inscrição dos grupos (no Mooshak).
09/mai - Divulgação da 1ª versão do enunciado.
16/mai - O Mooshak começa a aceitar as submissões da fase 1.
16/mai - Final da inscrição dos grupos (o Mooshak deixa de aceitar mais inscrições).
23/mai - O Mooshak começa a aceitar as submissões da fase 2.
~~23/mai - [20:00] Data e hora limite de entrega da 1ª fase.~~
28/mai - [20:00] Data e hora limite de entrega da 1ª fase. [Houve adiamento.]
06/jun - [20:00] Data e hora limite de entrega da 2ª fase.
11-18/jun - Discussões.

Changelog

26/maio - A implementação da História no programa é completamente rotineira. Para os alunos ganharem tempo, no caso de quererem usar, a Introdução deste enunciado oferece agora ficheiros com uma implementação completa da coleção História, incluindo a implementação do comando de listagem da História no programa principal. Os alunos são livres de usar diretamente ou de adaptar o código da forma que quiserem.
25/maio - Foi corrigido um erro no output do teste B06 no ficheiro fase2.zip. Se já tinha descarregado esse ficheiro, por favor, volte a fazê-lo.
25/maio - Foi corrigido outro erro no enunciado. Nos exemplo de execução, havia falhas no output do comando H.
25/maio - Foi corrigido um erro no enunciado. O tempo para as burocracias é 50 seg. e não 30 seg.
25/maio - Foi criada a nova secção "Erro de Execução".
24/maio - Os testes públicos da fase 2 foram adicionados na secção Mooshak.
24/maio - O concurso do Mooshak já está a aceitar submissões para a 2ª fase.
23/maio - Adicionados alguns detalhes nas explicações relativas à segunda fase. Adicionados dois exemplos de execução relativos à segunda fase.
22/maio - O prazo limite para a entrega da fase 1 passou para 28/mai. Mas não espere por essa data para começar a trabalhar na fase 2.
21/maio - A linha que apresenta o comando X tinha sido apagada por acidente e foi restaurada.
16/maio - Os testes públicos da fase 1 foram adicionados na secção Mooshak.
16/maio - O concurso do Mooshak já está a aceitar submissões para a 1ª fase.
16/maio - Adicionado um ficheiro "MainSupermercado.c" incompleto para servir de inspiração.
16/maio - Adicionado um exemplo de execução para se saber qual o output a produzir.
14/maio - Adicionada a frase: "Vamos considerar que o peso unitário 1 indica especificamente que o produto é vendido avulso. Não há produtos pré-embalados com peso de 1 grama."
10/maio - Os comandos foram revistos para serem mais fáceis de memorizar.
10/maio - A descrição do fecho do supermercado foi enriquecida com mais detalhes.
10/maio - Faltava o comando P que cria um produto novo no stock.
09/maio - Versão inicial do enunciado.

Introdução

Este enunciado descreve o trabalho prático da disciplina de Algoritmos e Estruturas de Dados do 1º ano da Licenciatura em Engenharia Eletrotécnica e Computadores. Os alunos podem e devem tirar todas as dúvidas com os docentes da disciplina.

O trabalho é para ser realizado por grupos de 2 alunos.

O trabalho tem 2 fases de entrega.

Vão ser realizadas discussões do projeto.

O programa é para ser escrito em ANSI-C (a norma oficial do C), e tem de ser desenvolvido usando a metodologia de programação da disciplina. Note que há alguns aspetos específicos novos que foram apresentados na aula teórica 08.

Pode aproveitar código ou inspirar-se neste pequeno ficheiro: MainSupermercado.c. Ainda, uma implementação completa da coleção História, para quem quiser aproveitar: Registo.h, Registo.c, Historia.h, Historia.c.

Supermercado - compre 1 pelo preço de 2 e leve 1 de graça!

Objetivo

O objetivo deste trabalho é desenvolver um programa para efetuar a gestão de um dia de atividade dum grande supermercado:

O supermercado tem um diversificado stock de produtos, e há reabastecimentos ocasionais.
Os clientes circulam pelos corredores escolhendo e colocando produtos nos seus cestos de compras.
No final das suas compras, cada cliente vai para uma caixa efetuar o pagamento.
O supermercado mantém um histórico com estatísticas sobre as vendas individuais.

Produto

Cada produto é caraterizado por:

designação do produto
quantidade
preço unitário em cêntimos
peso unitário em gramas

A designação é uma string sem espaços, mas onde se podem usar hífenes como separadores. Por exemplo, "arroz-risotto-XPTO-extra-475g"; "arroz-carolino-ACME-regular-1kg"; "banana-importada-DEL-VALE"; "banana-da-madeira".

Muitos produtos são vendidos pré-embalados, em pacotes com peso fixo. Por exemplo, pacotes de arroz com 1 kg. Neste caso, a quantidade do produto indica o número de embalagens e o peso unitário diz respeito ao peso da embalagem.

Há produtos que são vendidos avulso, ou seja a peso. Por exemplo, bananas. Neste caso, a quantidade indica o número total de gramas e, além disso, o peso unitário será sempre 1, pois um grama de produto pesa exatamente 1 grama.

Vamos considerar que o peso unitário 1 indica especificamente que o produto é vendido avulso. Não há produtos pré-embalados com peso de 1 grama.

Algum produto que seja vendido pré-embalado, mas em pacotes com peso variável, por exemplo carne pré-embalada, considera-se que está a ser vendido avulso.

Tecnicamente, podem existir produtos disponíveis a custo zero, mas nunca com custo negativo.

Stock

O stock é uma coleção de produtos.

Em cada produto do stock, o campo quantidade indica a quantidade total disponível para venda nas instalações do supermercado.

Há um comando para aumentar o stock dum produto existente e outro comando para criar um produto novo. Também há um comando para listar o estado stock.

Cliente

Cada cliente é caraterizado por:

designação do cliente
cesto de compras

Do ponto de vista do supermercado, os clientes são pessoas anónimas. Contudo, precisamos de ter alguma forma de nos referirmos a um cliente, por exemplo para indicar que um dado cliente escolhe um certo produto, ou para indicar que esse cliente vai para uma certa caixa efetuar o pagamento. Vamos identificar cada cliente usando o número inteiro que indica a sua ordem de chegada ao supermercado, a começar em 0.

A única coisa substancial que precisamos de saber de cada cliente é quais são os produtos que tem no cesto. Por isso, basicamente, "cliente" e "cesto de compras" são a mesma coisa.

O cesto de compras é uma coleção de produtos, onde o campo quantidade de cada produto indica a quantidade que reside no cesto.

Há um comando para colocar um certo número de unidades dum produto no cesto. Se não existir stock suficiente, então deve ser dada a mensagem de erro prevista. Por exemplo, se o cliente precisar de 3 pacotes de arroz e só existirem 2, então a operação falha. O cliente tem sempre a liberdade de pedir 3 pacotes a seguir. Também há um comando para listar o estado dos clientes.

Histórico

Cada registo do histórico é caraterizado por:

designação do cliente
designação da caixa usada pelo cliente
momento em que o pagamento e outras burocracias se concretiza.
valor total das compras feitas e pagas
peso total das compras feitas e pagas

Cria-se e adiciona-se um registo histórico sempre que um cliente termina o pagamento.

Depois dum cliente pagar, presume-se que o cliente abandona o supermercado. O objeto que representa o cliente deve ser destruído, incluindo o seu cesto de compras. No histórico, fica a informação resumida atrás indicada.

Há um comando para listar o estado corrente do histórico.

Caixa

Cada caixa é caraterizada por:

designação da caixa
os clientes que estão na caixa

Em cada caixa, os clientes são processados por ordem de chegada. Quando um cliente chega a uma caixa, já não a abandona mais - vamos assumir isso para simplificar.

O supermercado tem um número de caixas fixo, concretamente 10 caixas. As caixas são numeradas de 0 a 9. O valor 10 deve estar numa constante do programa principal, para ser fácil de alterar.

A caixa zero é especial. Representa a saída do supermercado sem compras e sem qualquer espera. O cliente pode usar a caixa zero apenas se tiver o cesto vazio - se tiver alguma coisa no cesto, nem que seja um produto de custo zero, então terá de usar as outras caixas.

Se o cliente tiver o cesto vazio, o normal será usar a caixa zero - mas o cliente também pode decidir ir para uma caixa normal e aguardar pela sua vez.

O valor mínimo da constante para o número de caixas é 1. No caso de ser usado esse valor mínimo, existirá apenas a caixa 0.

Para simplificar, presume-se que todas as caixas estão permanentemente abertas. Não se prevê a possibilidade duma caixa estar temporariamente fechada.

Há um comando para colocar um cliente numa dada caixa e outro para colocar um cliente na caixa com maior disponibilidade. Também há um comando para listar o estado das caixas.

Na identificação da caixa com maior disponibilidade, em caso de empate escolhe-se a que tiver índice menor.

Tempo

O cliente entra no supermercado e vai enchendo livremente o seu cesto de compras sem restrições de tempo.

A questão do tempo só se coloca na altura do pagamento, nas caixas. Geralmente o cliente olha para as várias caixas e escolhe aquela que lhe parece minimizar o tempo de espera. O tempo de espera depende do número de clientes que está em cada caixa e se têm o cesto mais ou menos cheio.

Nas caixas, o tempo de processamento de cada cliente é o seguinte:

Para os produtos pré-embalados: 1 segundo por cada item. Por exemplo, 10 pacotes de arroz fazem gastar 10 segundos.
Para os produtos avulso (os que têm 1 grama como peso unitário): 1 segundo para todo o produto. Por exemplo, 1 kg ou 2 kg de bananas fazem gastar 1 segundo, não interessa a quantidade.
Para as burocracias, 50 segundos fixos. As burocracias consistem em efetuar o pagamento e em responder às seguintes perguntas:
- Quer um saco?
- Tem o cartão cliente?
- Conhece a nossa APP?
- Quer fatura com número de contribuinte?
- Gostaria de contribuir com um adicional de 1% para a organização XYZ?

Simulação da passagem do tempo

Existe um comando que faz avançar o tempo um certo número de segundos. O avanço do tempo provoca efeitos em todas as caixas que tenham clientes.

Para o programa ser realista, simula-se paralelismo. Por exemplo, para avançar 100 segundos, visitam-se 100 vezes, circularmente e por ordem, todas as caixas, fazendo avançar cada caixa 1 segundo de cada vez.

Presume-se que durante o avanço do tempo, nenhum cliente novo chega a uma caixa. O avanço do tempo é só para processar os clientes que já estão nas caixas.

O tipo do cliente precisa de ter um campo inteiro tempo, que é preenchido (no momento em que um cliente vai para a caixa) com o tempo de processamento previsto (calcula-se esse tempo na ocasião). Quando um cliente atinge a primeira posição da sua fila e as suas compras estão a processadas, vai-se descontando a passagem do tempo, um segundo de cada vez, nesse campo tempo.

Fecho do supermercado

Quando o supermercado encerra, todos os clientes que estão nas caixas permanecem nas mesmas caixas.

Para os clientes que ainda estão à procura de produtos mas têm o cesto vazio, eles são forcados a ir imediatamente para a caixa 0, pela ordem em que chegaram ao supermercado. ("Ir para a caixa zero" significa abandonar o supermercado no próximo segundo de passagem de tempo.)

Para os clientes que ainda estão à procura de produtos mas já têm alguma coisa no cesto, eles são forcados a ir imediatamente para a caixa 1, onde está um funcionário que faz horas extraordinárias. Esses clientes vão para a caixa 1, pela ordem em que chegaram ao supermercado.

Enquanto houver clientes nas caixas, faz-se passar o tempo continuamente até todos os clientes serem servidos.

O comando de fecho do supermercado deve produzir o seguinte output:

Depois de mandar para as caixas todos os clientes fora das caixas, listam-se os clientes e as caixas para provar que todos os clientes foram para as caixas corretas e pela ordem correta. Os clientes são processados por ordem de número de identificação.
Agora faz-se passar o tempo para que todos os clientes sejam processados e, no final, lista-se o histórico para provar que o processamento foi efetuado corretamente pela ordem correta.
Finalmente, escreve-se a mensagem de despedida e o programa termina.

Interface com o utilizador - Comandos

O programa funciona através de comandos introduzidos pelo utilizador. É o utilizador que atualiza o stock, coloca produtor no cesto dum determinado cliente, manda avançar o tempo para os pagamentos nas caixas poderem acontecer, etc.

Nesta secção, damos alguma informação geral sobre os comandos, e listamos os comandos concretos a suportar.

Formatos

Os comandos são pedidos ao utilizador usando o prompt '> '. Cada comando é identificado por uma letra, pode ser dada em maiúsculas ou minúsculas. Por exemplo, o comando de fecho do supermercado pode ser escrito 'f' ou 'F'.

O formato do output dos comandos é rígido, para poder avaliado pelo Mooshak.

Nos exemplos deste documento, todo o texto introduzido pelo utilizador aparece em negrito. Já texto escrito pelo programa aparece de forma normal. Para não haver dúvidas, explicitamos as mudanças de linha usando o símbolo '↩'.

Comandos com erros

1 - Se o utilizador introduzir um comando desconhecido, o programa escreve a mensagem "Comando desconhecido.↩". Por exemplo:

> K↩
Comando desconhecido.↩

2 - Muitos dos comandos possuem argumentos, que no nosso caso serão sempre strings e números inteiros não negativos. Por favor, assuma que o utilizador introduz sempre uma string onde se espera uma string, e um inteiro onde se espera um inteiro. Por outras palavras, não perca tempo a validar a sintaxe do input do utilizador.

Contudo deverá validar outros aspetos: argumentos a mais ou a menos; valores inteiros negativos; nomes de produto com espaços. Se o utilizador introduzir um comando com um erro destes, o programa escreve a mensagem "Dados invalidos.↩". Por exemplo:

> P "arroz da tasmania" -1000 "estou-a-mais"↩
Dados invalidos.↩

3 - Qualquer outra situação em que o utilizador tente fazer algo de impossível, por exemplo colocar no cesto do cliente múltiplas unidades dum produto com stock insuficiente ou sair por uma caixa que não existe, o programa escreve a mensagem "Nao pode fazer isso.↩".

Há algumas possibilidades relativamente a pedidos impossíveis de concretizar, mas a mensagem de erro é sempre a mesma. Por exemplo:

> D "arroz-da-tasmania" 1000↩
Nao pode fazer isso.↩

Os comandos

Eis os comandos a implementar, com indicação se são da fase 1 ou da fase 2:

[1] ? - mostra os comandos disponíveis.
[1] C - Cliente novo entra no supermercado.
[1] D x p n - O cliente x acrescenta n unidades do produto p ao seu cesto.
[1] E - Lista todos os clientes que estão no supermercado por ordem de chegada, escrevendo para cada cliente: a designação, se está numa caixa e qual, o conteúdo do cesto por ordem alfabética. Detalhes nos exemplos de execução.
[1] P p n c g - Novo produto acrescentado no stock, com designação p, quantidade n, preço c e peso g.
[1] Q p n - O stock do produto existente p é incrementado n unidades.
[1] R - Lista o stock por ordem alfabética, escrevendo toda a informação dos produtos em stock. Detalhes nos exemplos de execução.
[1] . - Termina imediatamente a execução do programa, sem se preocupar com as caixas e os clientes.
[2] X x n - O cliente x junta-se à caixa n.
[2] Y x - O cliente x junta-se à caixa com menor tempo de espera.
[2] Z - Lista todas as caixas por ordem, indicando para cada caixa o seu índice e os clientes que estão na fila. Detalhes nos exemplos de execução.
[2] H - lista o Histórico corrente pela ordem pela qual foram acrescentados os registos. Detalhes nos exemplos de execução.
[2] T s - avança o Tempo s segundos.
[2] F - Fecha o supermercado e finaliza a execução do programa.

O texto exato que cada um deste comandos escreve será aqui divulgado daqui a alguns dias.

Exemplo de execução para a fase 1

Os seguintes exemplos de execução servem também para mostrar o formato das mensagens que o programa deve produzir.

Você precisa se seguir rigorosamente estes formatos, porque o seu programa será parcialmente avaliado no Mooshak. Use o concurso do Mooshak que está disponível, para validar esses formatos.

> ?
  ? - Ajuda
  C - Cliente novo
  D x p n - Cliente coloca produto no cesto
  E - lista Clientes
  P p n c g - Produto novo
  Q p n - reabastecimento de Produto.
  R - lista Produtos em stock
  X x n - cliente vai para uma Caixa
  Y x - cliente vai para a melhor Caixa
  Z - lista Caixas
  H - lista Historico
  T s - avanca Tempo
  F - Fecha o supermercado e termina o programa
  . - Termina o programa imediatamente
> P erro erro erro
Dados invalidos.
> P
Dados invalidos.
> P arroz 1 1 1 1
Dados invalidos.
> P 1 arroz 1 1
Dados invalidos.
> C joao
Dados invalidos.
> C 1
Dados invalidos.
> D 1 arroz 22
Nao pode fazer isso.
> Q arroz 20
Nao pode fazer isso.
> R
-- Stock --
  vazio
> P arroz-ACME-regular-1kg 100 130 1000
Cria o novo produto arroz-ACME-regular-1kg
> P arroz-ACME-regular-1kg 100 130 1000
Nao pode fazer isso.
> P caspian-caviar-beluga-avulso 1000 800 1
Cria o novo produto caspian-caviar-beluga-avulso
> R
-- Stock --
  Produto arroz-ACME-regular-1kg: 100 unidades, 130 centimos, 1000 gramas
  Produto caspian-caviar-beluga-avulso: 1000 unidades, 800 centimos, 1 gramas
> Q caspian-caviar-beluga-avulsoX 500
Nao pode fazer isso.
> Q caspian-caviar-beluga-avulso 500
Reabastece o produto caspian-caviar-beluga-avulso
> r
-- Stock --
  Produto arroz-ACME-regular-1kg: 100 unidades, 130 centimos, 1000 gramas
  Produto caspian-caviar-beluga-avulso: 1500 unidades, 800 centimos, 1 gramas
> E
-- Clientes --
  vazio
> c
Chega o cliente 0
> c
Chega o cliente 1
> c
Chega o cliente 2
> E
-- Clientes --
  Cliente 0:
    vazio
  Cliente 1:
    vazio
  Cliente 2:
    vazio
> D 1 caspian-caviar-beluga-avulso 20
Acrescenta caspian-caviar-beluga-avulso
> D 1 arroz-ACME-regular-1kg 1
Acrescenta arroz-ACME-regular-1kg
> D 1 caspian-caviar-beluga-avulso 20
Acrescenta caspian-caviar-beluga-avulso
> E
-- Clientes --
  Cliente 0:
    vazio
  Cliente 1:
    Produto arroz-ACME-regular-1kg: 1 unidades, 130 centimos, 1000 gramas
    Produto caspian-caviar-beluga-avulso: 40 unidades, 800 centimos, 1 gramas
  Cliente 2:
    vazio
> R
-- Stock --
  Produto arroz-ACME-regular-1kg: 99 unidades, 130 centimos, 1000 gramas
  Produto caspian-caviar-beluga-avulso: 1460 unidades, 800 centimos, 1 gramas
> .
Obrigado. Volte sempre!

Exemplo de execução para a fase 2 sem usar comandos T e F

> P arroz-ACME-regular-1kg 100 130 1000
Cria o novo produto arroz-ACME-regular-1kg
> P caspian-caviar-beluga-avulso 1000 800 1
Cria o novo produto caspian-caviar-beluga-avulso
> C
Chega o cliente 0
> C
Chega o cliente 1
> C
Chega o cliente 2
> C
Chega o cliente 3
> C
Chega o cliente 4
> C
Chega o cliente 5
> D 1 caspian-caviar-beluga-avulso 20
Acrescenta caspian-caviar-beluga-avulso
> D 1 arroz-ACME-regular-1kg 2
Acrescenta arroz-ACME-regular-1kg
> D 2 arroz-ACME-regular-1kg 48
Acrescenta arroz-ACME-regular-1kg
> E
-- Clientes --
  Cliente 0:
    vazio
  Cliente 1:
    Produto arroz-ACME-regular-1kg: 2 unidades, 130 centimos, 1000 gramas
    Produto caspian-caviar-beluga-avulso: 20 unidades, 800 centimos, 1 gramas
  Cliente 2:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 3:
    vazio
  Cliente 4:
    vazio
  Cliente 5:
    vazio
> Z
-- Caixas --
  Caixa 0:
    vazio
  Caixa 1:
    vazio
  Caixa 2:
    vazio
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    vazio
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> X 1 0
Nao pode fazer isso.
> X 1 5
Cliente 1 para caixa 5
> X 0 5
Cliente 0 para caixa 5
> X 2 1
Cliente 2 para caixa 1
> X 0 5
Nao pode fazer isso.
> X 0 9
Nao pode fazer isso.
> X 3 22
Nao pode fazer isso.
> E
-- Clientes --
  Cliente 0 [5]:
    vazio
  Cliente 1 [5]:
    Produto arroz-ACME-regular-1kg: 2 unidades, 130 centimos, 1000 gramas
    Produto caspian-caviar-beluga-avulso: 20 unidades, 800 centimos, 1 gramas
  Cliente 2 [1]:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 3:
    vazio
  Cliente 4:
    vazio
  Cliente 5:
    vazio
> Z
-- Caixas --
  Caixa 0:
    vazio
  Caixa 1:
    Cliente 2: 98 segundos, 6240 centimos
  Caixa 2:
    vazio
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    Cliente 1: 53 segundos, 16260 centimos
    Cliente 0: 50 segundos, 0 centimos
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> Y 3
Cliente 3 para caixa 0
> E
-- Clientes --
  Cliente 0 [5]:
    vazio
  Cliente 1 [5]:
    Produto arroz-ACME-regular-1kg: 2 unidades, 130 centimos, 1000 gramas
    Produto caspian-caviar-beluga-avulso: 20 unidades, 800 centimos, 1 gramas
  Cliente 2 [1]:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 3 [0]:
    vazio
  Cliente 4:
    vazio
  Cliente 5:
    vazio
> Z
-- Caixas --
  Caixa 0:
    Cliente 3: 0 segundos, 0 centimos
  Caixa 1:
    Cliente 2: 98 segundos, 6240 centimos
  Caixa 2:
    vazio
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    Cliente 1: 53 segundos, 16260 centimos
    Cliente 0: 50 segundos, 0 centimos
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> H
-- Historia --
  vazio
> .
Obrigado. Volte sempre!

Exemplo de execução para a fase 2 usando todos os comandos

> P arroz-ACME-regular-1kg 100 130 1000
Cria o novo produto arroz-ACME-regular-1kg
> P caspian-caviar-beluga-avulso 1000 800 1
Cria o novo produto caspian-caviar-beluga-avulso
> C
Chega o cliente 0
> C
Chega o cliente 1
> C
Chega o cliente 2
> C
Chega o cliente 3
> C
Chega o cliente 4
> C
Chega o cliente 5
> C
Chega o cliente 6
> C
Chega o cliente 7
> D 1 caspian-caviar-beluga-avulso 20
Acrescenta caspian-caviar-beluga-avulso
> D 1 arroz-ACME-regular-1kg 2
Acrescenta arroz-ACME-regular-1kg
> D 2 arroz-ACME-regular-1kg 48
Acrescenta arroz-ACME-regular-1kg
> D 6 arroz-ACME-regular-1kg 6
Acrescenta arroz-ACME-regular-1kg
> D 7 arroz-ACME-regular-1kg 7
Acrescenta arroz-ACME-regular-1kg
> E
-- Clientes --
  Cliente 0:
    vazio
  Cliente 1:
    Produto arroz-ACME-regular-1kg: 2 unidades, 130 centimos, 1000 gramas
    Produto caspian-caviar-beluga-avulso: 20 unidades, 800 centimos, 1 gramas
  Cliente 2:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 3:
    vazio
  Cliente 4:
    vazio
  Cliente 5:
    vazio
  Cliente 6:
    Produto arroz-ACME-regular-1kg: 6 unidades, 130 centimos, 1000 gramas
  Cliente 7:
    Produto arroz-ACME-regular-1kg: 7 unidades, 130 centimos, 1000 gramas
> Z
-- Caixas --
  Caixa 0:
    vazio
  Caixa 1:
    vazio
  Caixa 2:
    vazio
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    vazio
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> H
-- Historia --
  vazio
> T 1000
Tempo corrente: 1000 segundos
> T 500
Tempo corrente: 1500 segundos
> T 0
Tempo corrente: 1500 segundos
> X 1 5
Cliente 1 para caixa 5
> X 0 5
Cliente 0 para caixa 5
> X 2 1
Cliente 2 para caixa 1
> X 5 0
Cliente 5 para caixa 0
> X 3 2
Cliente 3 para caixa 2
> E
-- Clientes --
  Cliente 0 [5]:
    vazio
  Cliente 1 [5]:
    Produto arroz-ACME-regular-1kg: 2 unidades, 130 centimos, 1000 gramas
    Produto caspian-caviar-beluga-avulso: 20 unidades, 800 centimos, 1 gramas
  Cliente 2 [1]:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 3 [2]:
    vazio
  Cliente 4:
    vazio
  Cliente 5 [0]:
    vazio
  Cliente 6:
    Produto arroz-ACME-regular-1kg: 6 unidades, 130 centimos, 1000 gramas
  Cliente 7:
    Produto arroz-ACME-regular-1kg: 7 unidades, 130 centimos, 1000 gramas
> Z
-- Caixas --
  Caixa 0:
    Cliente 5: 0 segundos, 0 centimos
  Caixa 1:
    Cliente 2: 98 segundos, 6240 centimos
  Caixa 2:
    Cliente 3: 50 segundos, 0 centimos
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    Cliente 1: 53 segundos, 16260 centimos
    Cliente 0: 50 segundos, 0 centimos
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> H
-- Historia --
  vazio
> T 0
Tempo corrente: 1500 segundos
> Z
-- Caixas --
  Caixa 0:
    Cliente 5: 0 segundos, 0 centimos
  Caixa 1:
    Cliente 2: 98 segundos, 6240 centimos
  Caixa 2:
    Cliente 3: 50 segundos, 0 centimos
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    Cliente 1: 53 segundos, 16260 centimos
    Cliente 0: 50 segundos, 0 centimos
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> T 1
Tempo corrente: 1501 segundos
> E
-- Clientes --
  Cliente 0 [5]:
    vazio
  Cliente 1 [5]:
    Produto arroz-ACME-regular-1kg: 2 unidades, 130 centimos, 1000 gramas
    Produto caspian-caviar-beluga-avulso: 20 unidades, 800 centimos, 1 gramas
  Cliente 2 [1]:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 3 [2]:
    vazio
  Cliente 4:
    vazio
  Cliente 6:
    Produto arroz-ACME-regular-1kg: 6 unidades, 130 centimos, 1000 gramas
  Cliente 7:
    Produto arroz-ACME-regular-1kg: 7 unidades, 130 centimos, 1000 gramas
> Z
-- Caixas --
  Caixa 0:
    vazio
  Caixa 1:
    Cliente 2: 97 segundos, 6240 centimos
  Caixa 2:
    Cliente 3: 49 segundos, 0 centimos
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    Cliente 1: 52 segundos, 16260 centimos
    Cliente 0: 50 segundos, 0 centimos
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> H
-- Historia --
  Cliente 5: caixa 0, momento 1501, pagou 0, peso 0
> T 60
Tempo corrente: 1561 segundos
> E
-- Clientes --
  Cliente 0 [5]:
    vazio
  Cliente 2 [1]:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 4:
    vazio
  Cliente 6:
    Produto arroz-ACME-regular-1kg: 6 unidades, 130 centimos, 1000 gramas
  Cliente 7:
    Produto arroz-ACME-regular-1kg: 7 unidades, 130 centimos, 1000 gramas
> Z
-- Caixas --
  Caixa 0:
    vazio
  Caixa 1:
    Cliente 2: 37 segundos, 6240 centimos
  Caixa 2:
    vazio
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    Cliente 0: 42 segundos, 0 centimos
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
> H
-- Historia --
  Cliente 5: caixa 0, momento 1501, pagou 0, peso 0
  Cliente 3: caixa 2, momento 1550, pagou 0, peso 0
  Cliente 1: caixa 5, momento 1553, pagou 16260, peso 2020
> F
-- Clientes --
  Cliente 0 [5]:
    vazio
  Cliente 2 [1]:
    Produto arroz-ACME-regular-1kg: 48 unidades, 130 centimos, 1000 gramas
  Cliente 4 [0]:
    vazio
  Cliente 6 [1]:
    Produto arroz-ACME-regular-1kg: 6 unidades, 130 centimos, 1000 gramas
  Cliente 7 [1]:
    Produto arroz-ACME-regular-1kg: 7 unidades, 130 centimos, 1000 gramas
-- Caixas --
  Caixa 0:
    Cliente 4: 0 segundos, 0 centimos
  Caixa 1:
    Cliente 2: 37 segundos, 6240 centimos
    Cliente 6: 56 segundos, 780 centimos
    Cliente 7: 57 segundos, 910 centimos
  Caixa 2:
    vazio
  Caixa 3:
    vazio
  Caixa 4:
    vazio
  Caixa 5:
    Cliente 0: 42 segundos, 0 centimos
  Caixa 6:
    vazio
  Caixa 7:
    vazio
  Caixa 8:
    vazio
  Caixa 9:
    vazio
-- Historia --
  Cliente 5: caixa 0, momento 1501, pagou 0, peso 0
  Cliente 3: caixa 2, momento 1550, pagou 0, peso 0
  Cliente 1: caixa 5, momento 1553, pagou 16260, peso 2020
  Cliente 4: caixa 0, momento 1562, pagou 0, peso 0
  Cliente 2: caixa 1, momento 1598, pagou 6240, peso 48000
  Cliente 0: caixa 5, momento 1603, pagou 0, peso 0
  Cliente 6: caixa 1, momento 1654, pagou 780, peso 6000
  Cliente 7: caixa 1, momento 1711, pagou 910, peso 7000
Obrigado. Volte sempre!

Avaliação

Eis como a nota será calculada:

O Mooshak testa com detalhe as funcionalidades mais importantes do programa, e atribui pontos que correspondem a 12 valores da nota.
A parte da qualidade do código é avaliada manualmente e contribui com um valor de 8 valores.

A apreciação da qualidade, inclui pelo menos estes elementos:

Boa organização, clareza e simplicidade das ideias programadas.
Uso correto da metodologia de programação que se aprendeu (baseada em TADs - um dos quais é o "sistema"), em particular com respeito absoluto pelo princípio da separação de responsabilidades entre as diversas componente. (A nota da qualidade poderá ser abaixo de zero se não se seguir a metodologia de todo.)
Evitar a ocorrência de ineficiências absurdamente exageradas.
Nos ficheiros ".h", todos os protótipos deverão ter um comentário, e é essencial indicar as precondições corretas, no caso de existirem.

Duas fases

Há duas fases de entrega do trabalho (em duas datas diferentes), mas os detalhes não são agora divulgados.

Ainda não há a certeza de qual o peso relativo de cada fase na nota, mas pode garantir-se que a 1ª fase terá um peso maior do que 50%.

Mooshak

O concurso do Mooshak vai começar a receber submissões no dia 16/mai.

Eis os testes públicos da fase1: fase1.zip. Quanto aos testes privados da fase 1, estes só serão conhecidos depois do prazo de entrega.

Eis os testes públicos da fase2: fase2.zip. Quanto aos testes privados da fase 2, estes só serão conhecidos depois do prazo de entrega.

Veja na "antevisão" qual a filosofia de uso do Mooshak e qual é a submissão do seu grupo que será avaliada.

Erro de Execução

Se tem programa a funcionar no seu Windows, mas o Mooshak dá "Erro de Execução", esta secção interessa-lhe.

Os principais casos relatados pelos alunos têm a ver com duas situações (mas poderá haver outras):

Falta do campo info e da sua inicialização correta, para cada tipo struct.
Chamada das funções dos dicionários sem usar o padrão correto. O padrão correto consiste em indicar a chave fazendo sempre uma chamada de criaStr ou criaInt:
- elementoDicionario(dicio, criaStr(s))
- elementoDicionario(dicio, criaInt(n))

O Windows não é muito bom a detetar erros de execução, por exemplo o uso de apontadores indefinidos. O Linux é bastante melhor nisso e o Mooshak está instalado no Linux.

Se não estiver a ver onde está o erro, o ideal seria corrigir o programa usando uma máquina com Linux, por exemplo nos nossos laboratórias.

Está aqui uma alternativa. Submeta neste concurso. O seu programa será executado no Linux usando o teste A10 da primeira fase.

Neste concurso, o resultado é (estranhamente) apresentado sob a forma dum erro de compilação, pois essa é a única forma disponível para o Mooshak comunicar com o utilizador.

Clique no link "Erro de Compilação" para ver as informações. Caso tenha ocorrido um erro de execução no teste A10, verá uma mensagem semelhante à apresentada a seguir.

As linhas que começam por #, representam pela ordem inversa a sequência de chamadas que conduziu ao erro de execução.

Reading symbols from ./programa.out...
(No debugging symbols found in ./programa.out)
Starting program: /home/mooshak/data/contests/LEEC_AED_2025_RUNTIME_ERROR/submissions/00751819_A_amd/programa.out < /home/mooshak/data/contests/LEEC_AED_2025_RUNTIME_ERROR/languages/C/a10_input
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Program received signal SIGSEGV, Segmentation fault.
0x00005555555598ff in compara ()
#0  0x00005555555598ff in compara ()
#1  0x000055555555ba55 in ordenaVetor ()
#2  0x0000555555559c69 in criaIteradorOrdenado ()
#3  0x0000555555558946 in iteradorOrdenadoDicionario ()
#4  0x0000555555555f7f in iteradorClientela ()
#5  0x0000555555557cb7 in iteradorClientelaSupermercado ()
#6  0x0000555555556566 in mostraClientela ()
#7  0x0000555555556926 in cmdListaClientela ()
#8  0x00005555555570b6 in interpretador ()
#9  0x00005555555571f8 in main ()
A debugging session is active.

	Inferior 1 [process 612461] will be killed.

Quit anyway? (y or n) [answered Y; input not from terminal]
gdb: warning: Couldn't determine a path for the index cache directory.

Observações

Os grupos são incentivados a discutir entre si os aspetos mais gerais do projeto, inclusivamente no fórum. Mas sempre que chega o momento de escrever código, e agora com aspetos concretos e de detalhe, esse tem de ser um esforço interno a cada grupo (trabalhando de forma independente de todos os outros grupos). A escrita de código exige esforço intelectual, mas só com esforço se consegue evoluir.
O objetivo deste projeto é levar os alunos a praticar. Um aluno que pratique de forma genuína ganha experiência e provavelmente não terá dificuldade em conseguir aprovação no exame final.
Cuidado com as fraudes. Por exemplo, se alguém dum grupo oferecer o projeto resolvido a um elemento de outro grupo, trata-se duma fraude envolvendo dois grupos (já tem acontecido). Também se um grupo deixa o código num local público e outro grupo obtém esse código, também se considera fraude dos dois grupos (já tem acontecido). Ainda um terceiro caso: se dois grupos se juntam para fazer o projeto conjuntamente e depois o entregam em duplicado, também se considera fraude (já tem acontecido). Há muitas outras situações que têm acontecido. Em suma, cada grupo é responsável pelo seu projeto e não o pode mostrar ou oferecer, direta ou indiretamente, o seu código a outro grupo.

Final

Bom trabalho! Esperamos que goste.