add t1 assignment and header files

t1/libconjunto.h

+/* 
+ * TAD conjunto
+ * Autores: 
+ *    Andre Ricardo Abed Gregio
+ *    Fabiano Silva
+ *    Luis Carlos Erpen de Bona
+ *    Marcos Alexandre Castilho 
+ *
+ * Versao 1.0.0 de 10/11/2021
+ * Versao 1.0.1 de 16/08/2022
+ * Versao 1.1.0 de 17/11/2022
+ */
+
+struct conjunto {
+    int max;    /* tamanho maximo do vetor atualmente alocado     */
+    int card;   /* cardinalidade, isto eh, tamanho usado ate max  */
+    int ptr;    /* ponteiro para algum indice do vetor (iterador) */
+    int *v;     /* vetor de inteiros com no maximo max elementos  */
+};
+typedef struct conjunto conjunto_t;
+
+/*
+ * Cria um conjunto vazio e o retorna, se falhar retorna NULL.
+ * max eh o tamanho maximo do conjunto, isto eh, o tamanho maximo do vetor
+ */
+conjunto_t *cria_cjt (int max);
+
+/*
+ * Remove todos os elementos do conjunto, libera espaco e devolve NULL.
+ */
+conjunto_t *destroi_cjt (conjunto_t *c);
+
+/*
+ * Retorna 1 se o conjunto esta vazio e 0 caso contrario.
+ */
+int vazio_cjt (conjunto_t *c);
+
+/*
+ * Retorna a cardinalidade do conjunto, isto eh, o numero de elementos presentes nele.
+ */
+int cardinalidade_cjt (conjunto_t *c);
+
+/*
+ * Insere o elemento no conjunto, garante que nao existam repeticoes.
+ * Retorna 1 se a operacao foi bem sucedida. Se tentar inserir elemento existente,
+ * nao faz nada e retorna 1 tambem. Retorna 0 em caso de falha por falta de espaco.
+ */
+int insere_cjt (conjunto_t *c, int elemento);
+
+/*
+ * Remove o elemento 'elemento' do conjunto caso ele exista.
+ * Retorna 1 se a operacao foi bem sucedida e 0 se o elemento nao existe.
+ */
+int retira_cjt (conjunto_t *c, int elemento);
+
+/*
+ * Retorna 1 se o elemento pertence ao conjunto e 0 caso contrario.
+ */
+int pertence_cjt (conjunto_t *c, int elemento);
+
+/*
+ * Retorna 1 se o conjunto c1 esta contido no conjunto c2 e 0 caso contrario.
+ */
+int contido_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Retorna 1 se o conjunto c1 eh igual ao conjunto c2 e 0 caso contrario.
+ */
+int sao_iguais_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna o conjunto diferenca entre c1 e c2, nesta ordem.
+ * Retorna NULL se a operacao falhou.
+ */
+conjunto_t *diferenca_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna o conjunto interseccao entre os conjuntos c1 e c2.
+ * Retorna NULL se a operacao falhou.
+ */
+conjunto_t *interseccao_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna o conjunto uniao entre os conjunto c1 e c2.
+ * Retorna NULL se a operacao falhou.
+ */
+conjunto_t *uniao_cjt (conjunto_t *c1, conjunto_t *c2);
+
+/*
+ * Cria e retorna uma copia do conjunto c e NULL em caso de falha.
+ */
+conjunto_t *copia_cjt (conjunto_t *c);
+
+/*
+ * Cria e retorna um subconjunto com elementos aleatorios do conjunto c.
+ * Se o conjunto for vazio, retorna um subconjunto vazio.
+ * Se n >= cardinalidade (c) entao retorna o proprio conjunto c.
+ * Supoe que a funcao srand () tenha sido chamada antes.
+ */
+conjunto_t *cria_subcjt_cjt (conjunto_t *c, int n);
+
+/*
+ * Imprime os elementos do conjunto sempre em ordem crescente,
+ * mesmo que a estrutura interna nao garanta isso.
+ * Na impressao os elementos sao separados por um unico espaco
+ * em branco entre os elementos, sendo que apos o ultimo nao
+ * deve haver espacos em branco. Ao final imprime um \n.
+ */
+void imprime_cjt (conjunto_t *c);
+
+/*
+ * As funcoes abaixo implementam um iterador que vao permitir
+ * percorrer os elementos do conjunto.
+ * O ponteiro ptr da struct (iterador) pode ser inicializado para apontar 
+ * para o primeiro elemento e incrementado ate' o ultimo elemento 
+ * do conjunto.
+ */
+
+/*
+ * Inicializa ptr usado na funcao incrementa_iterador 
+ */
+void inicia_iterador_cjt (conjunto_t *c);
+
+/*
+ * Devolve no parametro ret_iterador o elemento apontado e incrementa o iterador.
+ * A funcao retorna 0 caso o iterador ultrapasse o ultimo elemento, ou retorna
+ * 1 caso o iterador aponte para um elemento valido (dentro do conjunto).
+ */
+int incrementa_iterador_cjt (conjunto_t *c, int *ret_iterador);
+
+/*
+ * Escolhe um elemento qualquer do conjunto para ser removido, o remove e
+ * o retorna.
+ * Nao faz teste se conjunto eh vazio, deixa para main fazer isso       
+ */
+int retira_um_elemento_cjt (conjunto_t *c);

t1/libfila.h

+/*
+ * TAD fila
+ * Autores:
+ *    Marcos Alexandre Castilho
+ *    Luis Carlos Erpen de Bona
+ *
+ * Primeira versão em 18/10/2019
+ * Versao 1.0.0 de 10/11/2021
+ * Versao 1.0.1 de 08/2022
+ * Versao 2.0.0 de 14/12/2022
+ */
+
+struct nodo_f {
+    int elem;
+    struct nodo_f *prox;
+};
+typedef struct nodo_f nodo_f_t;
+
+struct fila {
+    nodo_f_t *ini;
+    nodo_f_t *fim;
+    int tamanho; /* numero de elementos na fila */
+};
+typedef struct fila fila_t;
+
+/* Cria uma fila vazia e a retorna, se falhar retorna NULL. */
+fila_t *cria_fila ();
+
+/* Remove todos os elementos da fila, libera espaco e devolve NULL. */
+fila_t *destroi_fila (fila_t *f);
+
+/* Retorna 1 se a fila esta vazia e 0 caso contrario. */
+int vazia_fila (fila_t *f);
+
+/* Retorna o numero de elementos da fila. */
+int tamanho_fila (fila_t *f);
+
+/* Insere o elemento no final da fila (politica FIFO).
+ * Retorna 1 se a operacao foi bem sucedida e 0 caso contrario. */
+int insere_fila (fila_t *f, int elemento);
+
+/* Remove o elemento do inicio da fila (politica FIFO) e o retorna
+ * no parametro *elemento. Retorna 1 se a operacao foi bem sucedida
+ * e 0 caso contrario. */
+int retira_fila (fila_t *f, int *elemento);
+
+/* para depuracao */
+void imprime_fila (fila_t *f);

t1/liblef.h

+/* Implementa o TAD Lista de Eventos Futuros (LEF) 
+ * Feito em C para a disciplina CI1001 - Programacao 1 
+ * Autor: Luis C. E. Bona 
+ *
+ * Versao 1.0.0 10/11/2021
+ * Versao 1.0.1 16/08/2022
+ * Versao 2.0.0 14/12/2022
+ */
+
+/* A  LEF é uma lista que armazena eventos ordenados pelo membro tempo 
+ * do tipo evento_t. Cada evento pode ter um tipo e armazenar em dados 
+ * diferentes estruturas de dados que permitem descrever cada evento. */
+
+/*
+ * evento_t possui os dados que descrevem os eventos 
+ */
+typedef  struct evento {
+    int tempo;  /* tempo logico do evento */
+    int tipo;   /* inteiro para diferenciar os diferentes tipos de evento */
+    int dado1;  /* um inteiro para guardar dados do evento */
+    int dado2;  /* um inteiro para guardar dados do evento */
+} evento_t;
+
+/*
+ * nodo_t eh uma estrutura interna que representa cada nodo da LEF.
+ * Externamente o usuario da biblioteca nao vai receber essa estrutura para 
+ * evitar acesso direto ao ponteiro prox.
+ */
+typedef struct nodo_lef {
+    evento_t *evento;
+    struct nodo_lef *prox;
+} nodo_lef_t;
+
+/*
+ * Representacao da LEF 
+ */
+typedef struct lef {
+    nodo_lef_t *Primeiro;
+} lef_t;
+
+/* 
+ * Cria uma LEF vazia 
+ */
+lef_t *cria_lef ();
+
+/* 
+ * Destroi a LEF e retorna NULL. 
+ */ 
+lef_t *destroi_lef (lef_t *l);
+
+/* 
+ * Adiciona um evento na primeira posicao da LEF. Uma nova copia
+ * da estrutura evento sera feita. 
+ * Retorna 1 em caso de sucesso, 0 caso contrario.
+ */ 
+int adiciona_inicio_lef (lef_t *l, evento_t *evento);
+
+/* 
+ * Adiciona um evento de acordo com o valor evento->tempo na LEF. 
+ * Uma nova copia da estrutura evento sera feita 
+ * Retorna 1 em caso de sucesso, 0 caso contrario.
+ */
+int adiciona_ordem_lef (lef_t *l, evento_t *evento);
+
+/* 
+ * Retorna e retira o primeiro evento da LEF. 
+ * A responsabilidade por desalocar
+ * a memoria associada eh de quem chama essa funcao.
+ */
+evento_t *obtem_primeiro_lef (lef_t *l);

t1/makefile

+# Makefile de exemplo (Manual do GNU Make)
+     
+CFLAGS = -Wall -std=c90 -g  # flags de compilacao
+LDFLAGS = -lm
+
+CC = gcc
+
+# arquivos-objeto
+	objects = mundo.o libconjunto.o  liblef.o libfila.o 
+     
+mundo: mundo.o libconjunto.o  liblef.o libfila.o
+	$(CC) -o mundo mundo.o libconjunto.o  liblef.o libfila.o $(LDFLAGS)
+
+libconjunto.o: libconjunto.c
+	$(CC) -c $(CFLAGS) libconjunto.c
+
+liblef.o: liblef.c
+	$(CC) -c $(CFLAGS) liblef.c
+
+libfila.o: libfila.c
+	$(CC) -c $(CFLAGS) libfila.c
+
+mundo.o: mundo.c
+	$(CC) -c $(CFLAGS) mundo.c
+
+clean:
+	rm -f $(objects) mundo
+
+