From 3e821bebb9d0f7b4da125ed157e856027a19020a Mon Sep 17 00:00:00 2001
From: Pedro Folloni Pesserl <fpesserl7@gmail.com>
Date: Tue, 22 Nov 2022 00:22:03 -0300
Subject: [PATCH] add tp4
---
tp4/lib_conjunto.h | 136 +++++++++++++++++++++++++++++
tp4/makefile | 23 +++++
tp4/testa_conjunto.c | 201 +++++++++++++++++++++++++++++++++++++++++++
tp4/tp4.c | 21 +++++
4 files changed, 381 insertions(+)
create mode 100644 tp4/lib_conjunto.h
create mode 100644 tp4/makefile
create mode 100644 tp4/testa_conjunto.c
create mode 100644 tp4/tp4.c
diff --git a/tp4/lib_conjunto.h b/tp4/lib_conjunto.h
new file mode 100644
index 0000000..bae2d7a
--- /dev/null
+++ b/tp4/lib_conjunto.h
@@ -0,0 +1,136 @@
+/*
+ * 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);
diff --git a/tp4/makefile b/tp4/makefile
new file mode 100644
index 0000000..3efd261
--- /dev/null
+++ b/tp4/makefile
@@ -0,0 +1,23 @@
+# Makefile de exemplo (Manual do GNU Make)
+
+CFLAGS = -Wall -std=c90 -g # flags de compilacao
+LDFLAGS = -lm
+
+CC = gcc
+
+# arquivos-objeto
+ objects = testa_conjunto.o lib_conjunto.o
+
+all: tp4.o lib_conjunto.o
+ $(CC) -o tp4 tp4.o lib_conjunto.o $(LDFLAGS)
+
+lib_conjunto.o: lib_conjunto.c
+ $(CC) -c $(CFLAGS) lib_conjunto.c
+
+tp4.o: tp4.c
+ $(CC) -c $(CFLAGS) tp4.c
+
+clean:
+ rm -f $(objects) tp4
+
+
diff --git a/tp4/testa_conjunto.c b/tp4/testa_conjunto.c
new file mode 100644
index 0000000..9cfeaf2
--- /dev/null
+++ b/tp4/testa_conjunto.c
@@ -0,0 +1,201 @@
+/*
+ * Testes para a lib_conjunto.c
+ * Disciplina CI1001 - Programacao I
+ * Autor: Marcos Castilho
+ * Data: 18/08/2022
+*/
+
+#include <stdio.h>
+#include "lib_conjunto.h"
+#define TAM 21
+
+int main (void) {
+ conjunto_t *a, *b, *u, *i, *d, *d1, *copia, *sub;
+ int k, ex;
+
+ /* Teste para conjunto vazio */
+ printf ("---> Teste 1\n");
+ if (! (a= cria_cjt (TAM))) {
+ printf ("falha na criacao do conjunto\n");
+ return 1;
+ }
+ if (! vazio_cjt (a)) {
+ printf("ERRO: criou conjunto nao vazio\n");
+ return 1;
+ }
+ printf("OK: conjunto vazio\n");
+
+ /* Teste de insercao de elementos no conjunto */
+ printf ("---> Teste 2\n");
+ for (k=1; k <= 10; k++){
+ ex= insere_cjt (a, 2*k);
+ if (ex == 0) {
+ printf ("acabou espaco ao tentar inserir %d! Pode aumentar se quiser\n",2*k);
+ }
+ }
+ printf ("Inseriu todos os elementos corretamente em a\n");
+
+ /* Teste de impressao em conjunto com segundo teste de conjunto vazio */
+ printf ("---> Teste 3\n");
+ if (vazio_cjt (a)) {
+ printf ("ERRO: conjunto a misteriosamente ficou vazio\n");
+ return 1;
+ }
+ imprime_cjt (a);
+ printf ("A saida deve ter sido os números pares de 2 a 20, senao esta errado\n");
+ printf ("Lembrando que a impressao eh sempre em ordem crescente, pelo enunciado\n");
+
+ /* Criando conjunto para testes de uniao, interseccao e diferenca */
+ printf ("---> Teste 4\n");
+ if (! (b= cria_cjt (TAM))) {
+ printf ("falha na criacao do conjunto\n");
+ return 1;
+ }
+ for (k=1; k <= 20; k++){
+ ex= insere_cjt (b, k);
+ if (ex == 0) {
+ printf ("acabou espaco ao tentar inserir %d!\n",k);
+ }
+ }
+ imprime_cjt (b);
+ printf ("A saida deve ter sido todos os números de 1 a 20, senao esta errado\n");
+
+ /* Teste para uniao de dois conjuntos */
+ printf ("---> Teste 5\n");
+ if (! (u= uniao_cjt (a, b))) {
+ printf ("falha na uniao de dois conjuntos\n");
+ return 1;
+ }
+ imprime_cjt (u);
+ printf ("uniao: A saida deve ter sido todos os números de 1 a 20, senao esta errado\n");
+
+ /* Teste para intersecao de dois conjuntos */
+ printf ("---> Teste 6\n");
+ if (! (i= interseccao_cjt (a, b))) {
+ printf ("falha na interseccao de dois conjuntos\n");
+ return 1;
+ }
+ imprime_cjt (i);
+ printf ("intersec: A saida deve ter sido os números pares de 2 a 20, senao esta errado\n");
+
+ /* Teste para diferenca de dois conjuntos */
+ printf ("---> Teste 7\n");
+ if (! (d= diferenca_cjt (a, b))) {
+ printf ("falha na diferenca de dois conjuntos\n");
+ return 1;
+ }
+ imprime_cjt (d);
+ printf ("A saida deve ter sido o conjunto vazio, senao esta errado\n");
+ if (! (d1= diferenca_cjt (b, a))) {
+ printf ("falha na diferenca de dois conjuntos\n");
+ return 1;
+ }
+ imprime_cjt (d1);
+ printf ("diferenca: A saida deve ter sido os impares entre 1 e 19, senao esta errado\n");
+
+ /* Teste de estar contido e contem */
+ printf ("---> Teste 8\n");
+ if (! contido_cjt (a, b)) {
+ printf("ERRO: o conjunto a esta garantidamente contido no conjunto b e o programa falhou\n");
+ return 1;
+ }
+ printf("OK: conjunto a esta contido no conjunto b\n");
+
+ if (contido_cjt (b, a)) {
+ printf("ERRO: o conjunto b nao esta contido no conjunto a e o programa falhou\n");
+ return 1;
+ }
+ printf("OK: conjunto b nao esta contido no conjunto a\n");
+
+ /* Teste de igualdade de conjunto */
+ printf ("---> Teste 9\n");
+ if (! sao_iguais_cjt (a, i)) {
+ printf ("ERRO: estes conjuntos sao iguais e o programa falhou\n");
+ return 1;
+ }
+ printf("OK: conjuntos iguais\n");
+
+ if (sao_iguais_cjt (a, b)) {
+ printf ("ERRO: estes conjuntos nao sao iguais e o programa falhou\n");
+ return 1;
+ }
+ printf("OK: conjuntos diferentes\n");
+
+ /* Testes de remocao, retira do inicio do meio e do fim */
+ printf ("---> Teste 10\n");
+ if (! retira_cjt (a, 20))
+ printf("ERRO: nao retirou %d\n",20);
+ printf ("OK: retirou 20\n");
+
+ if (! retira_cjt (a, 2))
+ printf("ERRO: nao retirou %d\n",2);
+ printf ("OK: retirou 2\n");
+
+ if (! retira_cjt (a, 10))
+ printf("ERRO: nao retirou %d\n",10);
+ printf ("OK: retirou 10\n");
+
+ imprime_cjt (a);
+ printf ("Esta impressao deve ter resultado nos números pares de 4 a 18, menos o 10, senao esta errado\n");
+
+ for (k=1; k <= 20; k++) {
+ if (! retira_cjt (a, k))
+ printf("OK: nao retirou %d\n",k);
+ else
+ printf("OK: retirou %d\n",k);
+ }
+ printf ("Removeu todos os elementos? \n");
+ imprime_cjt (a);
+ printf ("Em caso afirmativo a linha anterior contem conjunto vazio\n");
+
+ /* Teste de copia de conjuntos */
+ printf ("---> Teste 11\n");
+ if (! (copia=copia_cjt (b))) {
+ printf ("ERRO: copia falhou\n");
+ return 1;
+ }
+ imprime_cjt (copia);
+ destroi_cjt (copia);
+ printf("se a copia deu certo foram impressos os numeros de 1 a 20\n");
+
+ /* Teste de subconjuntos */
+ printf ("---> Teste 12\n");
+ for (k=0; k <= cardinalidade_cjt (b); k++){
+ if (! (sub=cria_subcjt_cjt (b, k))) {
+ printf ("ERRO: criar subconjunto falhou\n");
+ return 1;
+ }
+ imprime_cjt (sub);
+ destroi_cjt (sub);
+ printf("deve ter impresso um subconjunto de tamanho %d\n",k);
+ }
+
+ /* Teste do iterador */
+ printf ("---> Teste 14\n");
+ inicia_iterador_cjt (b);
+ while (incrementa_iterador_cjt (b, &ex) != 0)
+ printf ("%d ", ex);
+ printf("\n");
+ printf("Teste do iterador, tem que ter impresso todos numeros de 1 a 20\n");
+
+ /* Teste do retira elemento */
+ printf ("---> Teste 15\n");
+ while (! vazio_cjt (b)){
+ ex= retira_um_elemento_cjt (b);
+ printf("%d ", ex);
+ }
+ printf("\n");
+ printf("Teste do retirar, tem que ter impresso todos numeros de 20 ate 1 que estao no conjunto, em alguma ordem definida por voce\n");
+ printf("depois tem que imprimir a mensagem 'conjunto vazio' logo abaixo\n");
+ imprime_cjt(b);
+
+ /* Destroi todos os conjuntos criados */
+ destroi_cjt (a);
+ destroi_cjt (b);
+ destroi_cjt (u);
+ destroi_cjt (i);
+ destroi_cjt (d);
+ destroi_cjt (d1);
+
+ return 0;
+}
diff --git a/tp4/tp4.c b/tp4/tp4.c
new file mode 100644
index 0000000..5f3e4f6
--- /dev/null
+++ b/tp4/tp4.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "lib_conjunto.h"
+#define MAX 100
+
+int main ()
+{
+
+ /* ler os herois e suas habilidades */
+
+ /* ler a missao */
+
+ /* ler as equipes de herois */
+
+ /* a solucao eh encontrada se a missao esta contido na uniao das
+ * habilidades de uma equipe, mas tomando-se aquela de menor tamanho. */
+
+ /* libera toda a memoria alocada dinamicamente */
+
+ return 0;
+}
--
GitLab