add tp4

tp4/lib_conjunto.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);

tp4/makefile

+# 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
+
+

tp4/testa_conjunto.c

+/*
+ * 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;
+}

tp4/tp4.c

+#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;
+}