From 3e19a993551c999ee10e8c4533692d91858a3947 Mon Sep 17 00:00:00 2001
From: Pedro Folloni Pesserl <fpesserl7@gmail.com>
Date: Mon, 27 Feb 2023 17:38:59 -0300
Subject: [PATCH] replace tabs with spaces and remove binary files
---
calculadora/calculadora.c | 450 +++++++++++++++----------------
calculadora/libpilha.c | 56 ++--
t1/libconjunto.c | 308 ++++++++++-----------
t1/libfila.c | 100 +++----
t1/liblef.c | 140 +++++-----
t1/mundo.c | 548 +++++++++++++++++++-------------------
tp1/racionais | Bin 20864 -> 0 bytes
tp1/racionais.c | 144 +++++-----
tp2/lib_racionais.c | 108 ++++----
tp2/lib_racionais.h | 4 +-
tp2/makefile | 2 +-
tp2/tp2 | Bin 20008 -> 0 bytes
tp2/tp2.c | 36 +--
tp3/lib_racionais.c | 162 +++++------
tp3/makefile | 2 +-
tp3/tp3 | Bin 24864 -> 0 bytes
tp3/tp3.c | 118 ++++----
tp4/lib_conjunto.c | 296 ++++++++++----------
tp4/makefile | 2 +-
tp4/tp4 | Bin 30504 -> 0 bytes
tp4/tp4.c | 158 +++++------
21 files changed, 1317 insertions(+), 1317 deletions(-)
delete mode 100755 tp1/racionais
delete mode 100755 tp2/tp2
delete mode 100755 tp3/tp3
delete mode 100755 tp4/tp4
diff --git a/calculadora/calculadora.c b/calculadora/calculadora.c
index 818b7bd..b286d17 100644
--- a/calculadora/calculadora.c
+++ b/calculadora/calculadora.c
@@ -31,22 +31,22 @@ typedef double t_operador;
Retorna 1 se o caracter c representa um operador valido e 0 caso
contrario. */
int converte_operador(t_operador *op, char c) {
- switch(c) {
- case '+': *op = SOM; break;
- case '-': *op = SUB; break;
- case '*': *op = MUL; break;
- case '/': *op = DIV; break;
- case '^': *op = EXP; break;
- default : return 0;
- }
- return 1;
+ switch(c) {
+ case '+': *op = SOM; break;
+ case '-': *op = SUB; break;
+ case '*': *op = MUL; break;
+ case '/': *op = DIV; break;
+ case '^': *op = EXP; break;
+ default : return 0;
+ }
+ return 1;
}
/* Retorna 1 se o operador op1 tem precedencia sobre o operador op2.
Retorna 0 caso contrario. */
int precedencia_maior_ou_igual(t_operador op1, t_operador op2) {
- return floor(op1) >= floor(op2);
+ return floor(op1) >= floor(op2);
}
@@ -54,32 +54,32 @@ int precedencia_maior_ou_igual(t_operador op1, t_operador op2) {
operador sobre esses valores e empilha o resultado na pilha de
valores. */
int opera(t_operador op, t_pilha *valores) {
- double val_esq, val_dir;
-
- if(!desempilha(&val_dir, valores))
- return 0;
- if(!desempilha(&val_esq, valores))
- return 0;
- if(op == SOM)
- return empilha(val_esq + val_dir, valores);
- if(op == SUB)
- return empilha(val_esq - val_dir, valores);
- if(op == MUL)
- return empilha(val_esq * val_dir, valores);
- if(op == DIV && val_dir != 0.0)
- return empilha(val_esq / val_dir, valores);
- if(op == EXP)
- return empilha(pow(val_esq, val_dir), valores);
-
- return 0;
+ double val_esq, val_dir;
+
+ if(!desempilha(&val_dir, valores))
+ return 0;
+ if(!desempilha(&val_esq, valores))
+ return 0;
+ if(op == SOM)
+ return empilha(val_esq + val_dir, valores);
+ if(op == SUB)
+ return empilha(val_esq - val_dir, valores);
+ if(op == MUL)
+ return empilha(val_esq * val_dir, valores);
+ if(op == DIV && val_dir != 0.0)
+ return empilha(val_esq / val_dir, valores);
+ if(op == EXP)
+ return empilha(pow(val_esq, val_dir), valores);
+
+ return 0;
}
/* Imprime na saida de erro (stderr) a mensagem de erro e a linha e
a coluna da entrada onde o erro foi detectado. */
void erro(char *msg, int col, int *flag_erro) {
- fprintf(stderr, "ERRO: %s (coluna %d)\n", msg, col);
- *flag_erro = 1;
+ fprintf(stderr, "ERRO: %s (coluna %d)\n", msg, col);
+ *flag_erro = 1;
}
@@ -90,32 +90,32 @@ void erro(char *msg, int col, int *flag_erro) {
ne leitura ou ne alocação de memoria. */
/*
char* le_entrada() {
- char *ent, *ret_realloc, *ret_fgets;
- int tam, pos;
-
- ent = NULL;
- tam = 0;
- pos = 0;
-
- do {
- tam += TAM_ENTRADA;
- ret_realloc = (char*) realloc(ent, sizeof(char) * tam);
- if(!ret_realloc) {
- free(ent);
- return NULL;
- }
- ent = ret_realloc;
- ent[tam - 1] = ' ';
- ret_fgets = fgets(ent + pos, tam - pos, stdin);
- pos = tam - 1;
- } while(ret_fgets && ent[tam - 1] == '\0' && ent[tam - 2] != '\n');
-
- if(!ret_fgets && tam == TAM_ENTRADA) {
- free(ent);
- return NULL;
- }
-
- return ent;
+ char *ent, *ret_realloc, *ret_fgets;
+ int tam, pos;
+
+ ent = NULL;
+ tam = 0;
+ pos = 0;
+
+ do {
+ tam += TAM_ENTRADA;
+ ret_realloc = (char*) realloc(ent, sizeof(char) * tam);
+ if(!ret_realloc) {
+ free(ent);
+ return NULL;
+ }
+ ent = ret_realloc;
+ ent[tam - 1] = ' ';
+ ret_fgets = fgets(ent + pos, tam - pos, stdin);
+ pos = tam - 1;
+ } while(ret_fgets && ent[tam - 1] == '\0' && ent[tam - 2] != '\n');
+
+ if(!ret_fgets && tam == TAM_ENTRADA) {
+ free(ent);
+ return NULL;
+ }
+
+ return ent;
}
*/
@@ -125,176 +125,176 @@ char* le_entrada() {
ne leitura ou na alocação de memoria. Se o tamanho da entrada for
maior que o vetor de leitura, retorna NULL. */
char* le_entrada() {
- char *ent, *ret_fgets;
- int tam;
-
- tam = TAM_ENTRADA;
- ent = (char*) malloc(sizeof(char) * tam);
- if(!ent)
- return NULL;
- ent[tam - 1] = ' ';
- ret_fgets = fgets(ent, tam, stdin);
- if(!ret_fgets || (ent[tam - 1] == '\0' && ent[tam - 2] != '\n')) {
- free(ent);
- return NULL;
- }
- return ent;
+ char *ent, *ret_fgets;
+ int tam;
+
+ tam = TAM_ENTRADA;
+ ent = (char*) malloc(sizeof(char) * tam);
+ if(!ent)
+ return NULL;
+ ent[tam - 1] = ' ';
+ ret_fgets = fgets(ent, tam, stdin);
+ if(!ret_fgets || (ent[tam - 1] == '\0' && ent[tam - 2] != '\n')) {
+ free(ent);
+ return NULL;
+ }
+ return ent;
}
int main() {
- t_pilha *pilha_valores, *pilha_operadores;
- t_operador operador, op_topo;
- double operando, resultado, memoria = 0.0;
- char *entrada, *c, *prox;
- int flag_erro = 0;
-
- entrada = le_entrada();
- if(!entrada) {
- erro("erro de leitura", 0, &flag_erro);
- return 1;
- }
-
- c = entrada;
- /* Loop principal, le valores e realiza operacoes ate ler uma linha
- que contém "q" na primeira posição */
- while(*c != 'q') {
-
- pilha_valores = cria_pilha(TAM_PILHA);
- if(!pilha_valores) {
- erro("erro ao criar pilha de valores", 0, &flag_erro);
- return 1;
- }
-
- pilha_operadores = cria_pilha(TAM_PILHA);
- if(!pilha_operadores) {
- erro("erro ao criar pilha de operadores", 0, &flag_erro);
- return 1;
- }
-
- if( !(isdigit(*c) || *c == '('))
- /* Se o primeiro caracter não for nem um dÃgito nem um abre parênteses,
- o formato está errado. */
- erro("formato incorreto", c - entrada + 1, &flag_erro);
-
- while(*c != 'q' && *c != '\n' && !flag_erro) {
- /* Percorre o ponteiro c pela entrada até achar um q, o final da linha ou um erro. */
-
- /* Caso 1: separadores */
- if(*c == ' ' || *c == '\t')
- /* Se for separador, passa para o proximo caracter. */
- c++;
-
- /* Caso 2: operando */
- else if(isdigit(*c)) {
- /* Se for [1..9] le um valor e empilha na pilha de valores. */
- operando = strtod(c, &prox);
- if(c == prox)
- erro("operando incorreto", c - entrada + 1, &flag_erro);
- else if(!empilha(operando, pilha_valores))
- erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
- else
- c = prox;
- }
-
- /* Caso 3: abre parenteses */
- else if(*c == '(') {
- /* Se for abre parenteses, empilha PAR na pilha de operadores. */
- if(!empilha(PAR, pilha_operadores))
- erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
- else
- c++;
- }
-
- /* Caso 4: fecha parenteses */
- else if(*c == ')') {
- /* Se for fecha parenteses, processa a pilha de operadores até
- encontar um PAR. */
- while(topo(&op_topo, pilha_operadores) && op_topo != PAR && !flag_erro) {
- desempilha(&op_topo, pilha_operadores);
- if(!opera(op_topo, pilha_valores))
- erro("formato incorreto", c - entrada + 1, &flag_erro);
- }
- if(pilha_vazia(pilha_operadores) ||
- (desempilha(&op_topo, pilha_operadores) && op_topo != PAR))
- erro("formato incorreto", c - entrada + 1, &flag_erro);
- else
- c++;
- }
-
- /* Caso 5: operador */
- else if(converte_operador(&operador, *c)) {
- /* Se for um operador valido, verifica a precedencia em relacao
- ao topo da pilha de operadores. */
- while(topo(&op_topo, pilha_operadores) &&
- op_topo != PAR &&
- precedencia_maior_ou_igual(op_topo, operador) &&
- !flag_erro) {
- /* Enquando o topo da pilha tiver precedencia, desempilha e
- processa o operador do topo da pilha. */
- desempilha(&op_topo, pilha_operadores);
- if(!opera(op_topo, pilha_valores))
- erro("formato incorreto", c - entrada + 1, &flag_erro);
- }
- if(!empilha(operador, pilha_operadores))
- /* Empilha o novo operador na pilha de operadores. */
- erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
- else
- c++;
- }
-
- /* Caso 6: memória */
- else if(*c == 'm') {
- /* Se for m, empilha o valor guardado na memória na pilha de valores */
- if(!empilha(memoria, pilha_valores))
- erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
- else
- c++;
- }
-
- /* Caso 7: caracter invalido na entrada */
- else
- erro("caracter desconhecido", c - entrada + 1, &flag_erro);
- }
-
- /* Sai da leitura se encontrar um q em qualquer posição da entrada */
- if(*c == 'q') break;
-
- if(!flag_erro) {
- /* Nesse ponto o processamento da entrada terminou (por enquanto sem erros)
- e pode ser o caso da pilha de operadores nao estar vazia. */
- while(desempilha(&op_topo, pilha_operadores) && !flag_erro) {
- /* Processa os operadores que restaram na pilha. */
- if(!opera(op_topo, pilha_valores))
- erro("formato incorreto", c - entrada + 1, &flag_erro);
- }
-
- /* Após o processamento, o resultado final da expressao esta no topo da
- pilha de valores. A pilha deve conter apenas esse valor. */
- if(!flag_erro) {
- if(!desempilha(&resultado, pilha_valores) || !pilha_vazia(pilha_valores))
- erro("formato incorreto", c - entrada + 1, &flag_erro);
- else {
- memoria = resultado;
- printf("%.16g\n", resultado);
- }
- }
- }
- /* Libera a entrada e lê uma nova entrada. */
-
- destroi_pilha(pilha_valores);
- destroi_pilha(pilha_operadores);
- free(entrada);
-
- entrada = le_entrada();
- if(!entrada)
- erro("erro de leitura", 0, &flag_erro);
-
- c = entrada;
-
- flag_erro = 0;
- }
-
- free(entrada);
-
- return 0;
+ t_pilha *pilha_valores, *pilha_operadores;
+ t_operador operador, op_topo;
+ double operando, resultado, memoria = 0.0;
+ char *entrada, *c, *prox;
+ int flag_erro = 0;
+
+ entrada = le_entrada();
+ if(!entrada) {
+ erro("erro de leitura", 0, &flag_erro);
+ return 1;
+ }
+
+ c = entrada;
+ /* Loop principal, le valores e realiza operacoes ate ler uma linha
+ que contém "q" na primeira posição */
+ while(*c != 'q') {
+
+ pilha_valores = cria_pilha(TAM_PILHA);
+ if(!pilha_valores) {
+ erro("erro ao criar pilha de valores", 0, &flag_erro);
+ return 1;
+ }
+
+ pilha_operadores = cria_pilha(TAM_PILHA);
+ if(!pilha_operadores) {
+ erro("erro ao criar pilha de operadores", 0, &flag_erro);
+ return 1;
+ }
+
+ if( !(isdigit(*c) || *c == '('))
+ /* Se o primeiro caracter não for nem um dÃgito nem um abre parênteses,
+ o formato está errado. */
+ erro("formato incorreto", c - entrada + 1, &flag_erro);
+
+ while(*c != 'q' && *c != '\n' && !flag_erro) {
+ /* Percorre o ponteiro c pela entrada até achar um q, o final da linha ou um erro. */
+
+ /* Caso 1: separadores */
+ if(*c == ' ' || *c == '\t')
+ /* Se for separador, passa para o proximo caracter. */
+ c++;
+
+ /* Caso 2: operando */
+ else if(isdigit(*c)) {
+ /* Se for [1..9] le um valor e empilha na pilha de valores. */
+ operando = strtod(c, &prox);
+ if(c == prox)
+ erro("operando incorreto", c - entrada + 1, &flag_erro);
+ else if(!empilha(operando, pilha_valores))
+ erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
+ else
+ c = prox;
+ }
+
+ /* Caso 3: abre parenteses */
+ else if(*c == '(') {
+ /* Se for abre parenteses, empilha PAR na pilha de operadores. */
+ if(!empilha(PAR, pilha_operadores))
+ erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
+ else
+ c++;
+ }
+
+ /* Caso 4: fecha parenteses */
+ else if(*c == ')') {
+ /* Se for fecha parenteses, processa a pilha de operadores até
+ encontar um PAR. */
+ while(topo(&op_topo, pilha_operadores) && op_topo != PAR && !flag_erro) {
+ desempilha(&op_topo, pilha_operadores);
+ if(!opera(op_topo, pilha_valores))
+ erro("formato incorreto", c - entrada + 1, &flag_erro);
+ }
+ if(pilha_vazia(pilha_operadores) ||
+ (desempilha(&op_topo, pilha_operadores) && op_topo != PAR))
+ erro("formato incorreto", c - entrada + 1, &flag_erro);
+ else
+ c++;
+ }
+
+ /* Caso 5: operador */
+ else if(converte_operador(&operador, *c)) {
+ /* Se for um operador valido, verifica a precedencia em relacao
+ ao topo da pilha de operadores. */
+ while(topo(&op_topo, pilha_operadores) &&
+ op_topo != PAR &&
+ precedencia_maior_ou_igual(op_topo, operador) &&
+ !flag_erro) {
+ /* Enquando o topo da pilha tiver precedencia, desempilha e
+ processa o operador do topo da pilha. */
+ desempilha(&op_topo, pilha_operadores);
+ if(!opera(op_topo, pilha_valores))
+ erro("formato incorreto", c - entrada + 1, &flag_erro);
+ }
+ if(!empilha(operador, pilha_operadores))
+ /* Empilha o novo operador na pilha de operadores. */
+ erro("pilha de operadores cheia", c - entrada + 1, &flag_erro);
+ else
+ c++;
+ }
+
+ /* Caso 6: memória */
+ else if(*c == 'm') {
+ /* Se for m, empilha o valor guardado na memória na pilha de valores */
+ if(!empilha(memoria, pilha_valores))
+ erro("pilha de valores cheia", c - entrada + 1, &flag_erro);
+ else
+ c++;
+ }
+
+ /* Caso 7: caracter invalido na entrada */
+ else
+ erro("caracter desconhecido", c - entrada + 1, &flag_erro);
+ }
+
+ /* Sai da leitura se encontrar um q em qualquer posição da entrada */
+ if(*c == 'q') break;
+
+ if(!flag_erro) {
+ /* Nesse ponto o processamento da entrada terminou (por enquanto sem erros)
+ e pode ser o caso da pilha de operadores nao estar vazia. */
+ while(desempilha(&op_topo, pilha_operadores) && !flag_erro) {
+ /* Processa os operadores que restaram na pilha. */
+ if(!opera(op_topo, pilha_valores))
+ erro("formato incorreto", c - entrada + 1, &flag_erro);
+ }
+
+ /* Após o processamento, o resultado final da expressao esta no topo da
+ pilha de valores. A pilha deve conter apenas esse valor. */
+ if(!flag_erro) {
+ if(!desempilha(&resultado, pilha_valores) || !pilha_vazia(pilha_valores))
+ erro("formato incorreto", c - entrada + 1, &flag_erro);
+ else {
+ memoria = resultado;
+ printf("%.16g\n", resultado);
+ }
+ }
+ }
+ /* Libera a entrada e lê uma nova entrada. */
+
+ destroi_pilha(pilha_valores);
+ destroi_pilha(pilha_operadores);
+ free(entrada);
+
+ entrada = le_entrada();
+ if(!entrada)
+ erro("erro de leitura", 0, &flag_erro);
+
+ c = entrada;
+
+ flag_erro = 0;
+ }
+
+ free(entrada);
+
+ return 0;
}
diff --git a/calculadora/libpilha.c b/calculadora/libpilha.c
index 9a43842..b744eca 100644
--- a/calculadora/libpilha.c
+++ b/calculadora/libpilha.c
@@ -2,48 +2,48 @@
#include "libpilha.h"
t_pilha* cria_pilha(int n) {
- t_pilha *p;
- if ( !(p = malloc(sizeof(t_pilha) * n)) )
- return NULL;
-
- p->tam = n;
- p->topo = -1;
-
- if ( !(p->v = malloc(sizeof(double) * n)) )
- return NULL;
- return p;
+ t_pilha *p;
+ if ( !(p = malloc(sizeof(t_pilha) * n)) )
+ return NULL;
+
+ p->tam = n;
+ p->topo = -1;
+
+ if ( !(p->v = malloc(sizeof(double) * n)) )
+ return NULL;
+ return p;
}
t_pilha* destroi_pilha(t_pilha *p) {
- free(p->v);
- free(p);
- return NULL;
+ free(p->v);
+ free(p);
+ return NULL;
}
int pilha_vazia(t_pilha *p) {
- return p->topo == -1;
+ return p->topo == -1;
}
int empilha(double x, t_pilha *p) {
- if (p->topo == p->tam)
- return 0;
- p->topo++;
- p->v[p->topo] = x;
+ if (p->topo == p->tam)
+ return 0;
+ p->topo++;
+ p->v[p->topo] = x;
- return 1;
+ return 1;
}
int desempilha(double *t, t_pilha *p) {
- if (pilha_vazia(p))
- return 0;
- *t = p->v[p->topo];
- p->topo--;
- return 1;
+ if (pilha_vazia(p))
+ return 0;
+ *t = p->v[p->topo];
+ p->topo--;
+ return 1;
}
int topo(double *t, t_pilha *p) {
- if (pilha_vazia(p))
- return 0;
- *t = p->v[p->topo];
- return 1;
+ if (pilha_vazia(p))
+ return 0;
+ *t = p->v[p->topo];
+ return 1;
}
diff --git a/t1/libconjunto.c b/t1/libconjunto.c
index daf98e3..833129e 100644
--- a/t1/libconjunto.c
+++ b/t1/libconjunto.c
@@ -6,231 +6,231 @@
* como estamos trabalhando com conjuntos ordenados, eh uma busca binaria.
* se o elemento nao esta no conjunto, retorna -1. */
int busca_cjt(conjunto_t *c, int elemento) {
- int inicio = 0;
- int fim = cardinalidade_cjt(c) - 1;
- int meio = fim / 2;
+ int inicio = 0;
+ int fim = cardinalidade_cjt(c) - 1;
+ int meio = fim / 2;
- while (inicio <= fim && c->v[meio] != elemento) {
- if (elemento > c->v[meio]) {
- inicio = meio + 1;
- } else {
- fim = meio - 1;
- }
- meio = (inicio + fim) / 2;
- }
+ while (inicio <= fim && c->v[meio] != elemento) {
+ if (elemento > c->v[meio]) {
+ inicio = meio + 1;
+ } else {
+ fim = meio - 1;
+ }
+ meio = (inicio + fim) / 2;
+ }
- return inicio > fim ? -1 : meio;
+ return inicio > fim ? -1 : meio;
}
conjunto_t *cria_cjt(int max) {
- conjunto_t *c;
- if ( !(c = malloc(sizeof(conjunto_t))) )
- return NULL;
- c->max = max;
- c->card = 0;
- c->ptr = 0;
- if ( !(c->v = malloc(sizeof(int) * max)) ) {
- free(c);
- return NULL;
- }
- return c;
+ conjunto_t *c;
+ if ( !(c = malloc(sizeof(conjunto_t))) )
+ return NULL;
+ c->max = max;
+ c->card = 0;
+ c->ptr = 0;
+ if ( !(c->v = malloc(sizeof(int) * max)) ) {
+ free(c);
+ return NULL;
+ }
+ return c;
}
conjunto_t *destroi_cjt(conjunto_t *c) {
- free(c->v);
- c->v = NULL;
- free(c);
- return NULL;
+ free(c->v);
+ c->v = NULL;
+ free(c);
+ return NULL;
}
int vazio_cjt(conjunto_t *c) {
- return cardinalidade_cjt(c) == 0;
+ return cardinalidade_cjt(c) == 0;
}
int cardinalidade_cjt(conjunto_t *c) {
- return c->card;
+ return c->card;
}
int insere_cjt(conjunto_t *c, int elemento) {
- if (cardinalidade_cjt(c) == c->max)
- return 0;
+ if (cardinalidade_cjt(c) == c->max)
+ return 0;
- if (pertence_cjt(c, elemento))
- return 1;
+ if (pertence_cjt(c, elemento))
+ return 1;
- int i = cardinalidade_cjt(c);
- while (i > 0 && c->v[i - 1] > elemento) {
- c->v[i] = c->v[i - 1];
- i--;
- }
-
- c->v[i] = elemento;
- c->card++;
- return 1;
+ int i = cardinalidade_cjt(c);
+ while (i > 0 && c->v[i - 1] > elemento) {
+ c->v[i] = c->v[i - 1];
+ i--;
+ }
+
+ c->v[i] = elemento;
+ c->card++;
+ return 1;
}
int retira_cjt(conjunto_t *c, int elemento) {
- if (!(pertence_cjt(c, elemento)))
- return 0;
+ if (!(pertence_cjt(c, elemento)))
+ return 0;
- int i;
- for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
- c->v[i] = c->v[i + 1];
- }
+ int i;
+ for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
+ c->v[i] = c->v[i + 1];
+ }
- c->card--;
- return 1;
+ c->card--;
+ return 1;
}
int pertence_cjt(conjunto_t *c, int elemento) {
- return busca_cjt(c, elemento) != -1;
+ return busca_cjt(c, elemento) != -1;
}
int contido_cjt(conjunto_t *c1, conjunto_t *c2) {
- int i;
- for (i = 0; i < cardinalidade_cjt(c1); i++) {
- if (!(pertence_cjt(c2, c1->v[i])))
- return 0;
- }
- return 1;
+ int i;
+ for (i = 0; i < cardinalidade_cjt(c1); i++) {
+ if (!(pertence_cjt(c2, c1->v[i])))
+ return 0;
+ }
+ return 1;
}
int sao_iguais_cjt(conjunto_t *c1, conjunto_t *c2) {
- return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
+ return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
}
conjunto_t *diferenca_cjt(conjunto_t *c1, conjunto_t *c2) {
- conjunto_t *dif;
- if ( !(dif = cria_cjt(c1->max)) )
- return NULL;
+ conjunto_t *dif;
+ if ( !(dif = cria_cjt(c1->max)) )
+ return NULL;
- int i;
- for (i = 0; i < cardinalidade_cjt(c1); i++) {
- if (!(pertence_cjt(c2, c1->v[i])))
- insere_cjt(dif, c1->v[i]);
- }
+ int i;
+ for (i = 0; i < cardinalidade_cjt(c1); i++) {
+ if (!(pertence_cjt(c2, c1->v[i])))
+ insere_cjt(dif, c1->v[i]);
+ }
- return dif;
+ return dif;
}
conjunto_t *interseccao_cjt(conjunto_t *c1, conjunto_t *c2) {
- conjunto_t *inter;
- if ( !(inter = cria_cjt(c1->max)) )
- return NULL;
-
- conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
- conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
+ conjunto_t *inter;
+ if ( !(inter = cria_cjt(c1->max)) )
+ return NULL;
+
+ conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
+ conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
- int i;
- for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
- if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
- insere_cjt(inter, (*menor_cjt)->v[i]);
- }
+ int i;
+ for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
+ if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
+ insere_cjt(inter, (*menor_cjt)->v[i]);
+ }
- return inter;
+ return inter;
}
conjunto_t *uniao_cjt(conjunto_t *c1, conjunto_t *c2) {
- conjunto_t *uniao;
- if ( !(uniao = cria_cjt(c1->max)) )
- return NULL;
+ conjunto_t *uniao;
+ if ( !(uniao = cria_cjt(c1->max)) )
+ return NULL;
- inicia_iterador_cjt(c1);
- inicia_iterador_cjt(c2);
+ inicia_iterador_cjt(c1);
+ inicia_iterador_cjt(c2);
- while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
- if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
- insere_cjt(uniao, c1->v[c1->ptr]);
- c1->ptr++;
- } else {
- insere_cjt(uniao, c2->v[c2->ptr]);
- c2->ptr++;
- }
- }
+ while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
+ if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
+ insere_cjt(uniao, c1->v[c1->ptr]);
+ c1->ptr++;
+ } else {
+ insere_cjt(uniao, c2->v[c2->ptr]);
+ c2->ptr++;
+ }
+ }
- conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
+ conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
- int i;
- for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
- insere_cjt(uniao, (*ainda_falta)->v[i]);
- }
+ int i;
+ for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
+ insere_cjt(uniao, (*ainda_falta)->v[i]);
+ }
- inicia_iterador_cjt(c1);
- inicia_iterador_cjt(c2);
+ inicia_iterador_cjt(c1);
+ inicia_iterador_cjt(c2);
- return uniao;
+ return uniao;
}
conjunto_t *copia_cjt(conjunto_t *c) {
- conjunto_t *copia;
- if ( !(copia = cria_cjt(c->max)) )
- return NULL;
+ conjunto_t *copia;
+ if ( !(copia = cria_cjt(c->max)) )
+ return NULL;
- int i;
- for (i = 0; i < cardinalidade_cjt(c); i++) {
- insere_cjt(copia, c->v[i]);
- }
+ int i;
+ for (i = 0; i < cardinalidade_cjt(c); i++) {
+ insere_cjt(copia, c->v[i]);
+ }
- return copia;
+ return copia;
}
conjunto_t *cria_subcjt_cjt(conjunto_t *c, int n) {
- if (n >= cardinalidade_cjt(c))
- return copia_cjt(c);
-
- conjunto_t *sub;
- if ( !(sub = cria_cjt(c->max)) )
- return NULL;
-
- conjunto_t *disponiveis;
- if ( !(disponiveis = copia_cjt(c)) ) {
- free(sub);
- return NULL;
- }
-
- int i;
- int aleat;
- for (i = 0; i < n; i++) {
- aleat = rand() % cardinalidade_cjt(disponiveis);
- insere_cjt(sub, disponiveis->v[aleat]);
- retira_cjt(disponiveis, disponiveis->v[aleat]);
- }
-
- destroi_cjt(disponiveis);
- return sub;
+ if (n >= cardinalidade_cjt(c))
+ return copia_cjt(c);
+
+ conjunto_t *sub;
+ if ( !(sub = cria_cjt(c->max)) )
+ return NULL;
+
+ conjunto_t *disponiveis;
+ if ( !(disponiveis = copia_cjt(c)) ) {
+ free(sub);
+ return NULL;
+ }
+
+ int i;
+ int aleat;
+ for (i = 0; i < n; i++) {
+ aleat = rand() % cardinalidade_cjt(disponiveis);
+ insere_cjt(sub, disponiveis->v[aleat]);
+ retira_cjt(disponiveis, disponiveis->v[aleat]);
+ }
+
+ destroi_cjt(disponiveis);
+ return sub;
}
void imprime_cjt(conjunto_t *c) {
- if (vazio_cjt(c)) {
- printf("Conjunto vazio.\n");
- return;
- }
+ if (vazio_cjt(c)) {
+ printf("Conjunto vazio.\n");
+ return;
+ }
- int i;
- printf("%d", c->v[0]);
- for (i = 1; i < cardinalidade_cjt(c); i++)
- printf(" %d", c->v[i]);
- printf("\n");
+ int i;
+ printf("%d", c->v[0]);
+ for (i = 1; i < cardinalidade_cjt(c); i++)
+ printf(" %d", c->v[i]);
+ printf("\n");
}
void inicia_iterador_cjt(conjunto_t *c) {
- c->ptr = 0;
+ c->ptr = 0;
}
int incrementa_iterador_cjt(conjunto_t *c, int *ret_iterador) {
- *ret_iterador = c->v[c->ptr];
- c->ptr++;
- if (c->ptr > cardinalidade_cjt(c))
- return 0;
- return 1;
+ *ret_iterador = c->v[c->ptr];
+ c->ptr++;
+ if (c->ptr > cardinalidade_cjt(c))
+ return 0;
+ return 1;
}
int retira_um_elemento_cjt(conjunto_t *c) {
- int aleat = rand() % cardinalidade_cjt(c);
- int retirar = c->v[aleat];
- int i;
- for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
- c->v[i] = c->v[i + 1];
- c->card--;
- return retirar;
+ int aleat = rand() % cardinalidade_cjt(c);
+ int retirar = c->v[aleat];
+ int i;
+ for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
+ c->v[i] = c->v[i + 1];
+ c->card--;
+ return retirar;
}
diff --git a/t1/libfila.c b/t1/libfila.c
index f6a067a..4a82b64 100644
--- a/t1/libfila.c
+++ b/t1/libfila.c
@@ -3,79 +3,79 @@
#include "libfila.h"
fila_t *cria_fila() {
- fila_t *f;
- if ( !(f = malloc(sizeof(fila_t))) )
- return NULL;
-
- f->tamanho = 0;
- f->ini = NULL;
- f->fim = NULL;
- return f;
+ fila_t *f;
+ if ( !(f = malloc(sizeof(fila_t))) )
+ return NULL;
+
+ f->tamanho = 0;
+ f->ini = NULL;
+ f->fim = NULL;
+ return f;
}
fila_t *destroi_fila(fila_t *f) {
- int e = 0;
+ int e = 0;
- while (f->ini != NULL) {
- retira_fila(f, &e);
- }
+ while (f->ini != NULL) {
+ retira_fila(f, &e);
+ }
- free(f);
- return NULL;
+ free(f);
+ return NULL;
}
int vazia_fila(fila_t *f) {
- return f->tamanho == 0;
+ return f->tamanho == 0;
}
int tamanho_fila(fila_t *f) {
- return f->tamanho;
+ return f->tamanho;
}
int insere_fila(fila_t *f, int elemento) {
- nodo_f_t *novo;
- if ( !(novo = malloc(sizeof(nodo_f_t))) )
- return 0;
- novo->elem = elemento;
- novo->prox = NULL;
+ nodo_f_t *novo;
+ if ( !(novo = malloc(sizeof(nodo_f_t))) )
+ return 0;
+ novo->elem = elemento;
+ novo->prox = NULL;
- (f->tamanho)++;
+ (f->tamanho)++;
- if (tamanho_fila(f) == 1) {
- f->ini = novo;
- f->fim = novo;
- return 1;
- }
+ if (tamanho_fila(f) == 1) {
+ f->ini = novo;
+ f->fim = novo;
+ return 1;
+ }
- f->fim->prox = novo;
- f->fim = novo;
- return 1;
+ f->fim->prox = novo;
+ f->fim = novo;
+ return 1;
}
int retira_fila(fila_t *f, int *elemento) {
- if (vazia_fila(f))
- return 0;
-
- *elemento = f->ini->elem;
- nodo_f_t *temp = f->ini->prox;
- free(f->ini);
- f->ini = temp;
- (f->tamanho)--;
- return 1;
+ if (vazia_fila(f))
+ return 0;
+
+ *elemento = f->ini->elem;
+ nodo_f_t *temp = f->ini->prox;
+ free(f->ini);
+ f->ini = temp;
+ (f->tamanho)--;
+ return 1;
}
void imprime_fila(fila_t *f) {
- if (vazia_fila(f))
- return;
+ if (vazia_fila(f))
+ return;
- nodo_f_t *atual = f->ini;
- printf("%d", atual->elem);
+ nodo_f_t *atual = f->ini;
+ printf("%d", atual->elem);
- int i;
- for (i = 1; i < tamanho_fila(f); i++) {
- atual = atual->prox;
- printf(" %d", atual->elem);
- }
-
- printf("\n");
+ int i;
+ for (i = 1; i < tamanho_fila(f); i++) {
+ atual = atual->prox;
+ printf(" %d", atual->elem);
+ }
+
+ printf("\n");
}
diff --git a/t1/liblef.c b/t1/liblef.c
index aaaf468..0633500 100644
--- a/t1/liblef.c
+++ b/t1/liblef.c
@@ -3,93 +3,93 @@
#include "liblef.h"
lef_t *cria_lef() {
- lef_t *l;
- if ( !(l = malloc(sizeof(lef_t))) )
- return NULL;
+ lef_t *l;
+ if ( !(l = malloc(sizeof(lef_t))) )
+ return NULL;
- l->Primeiro = NULL;
-
- return l;
+ l->Primeiro = NULL;
+
+ return l;
}
lef_t *destroi_lef(lef_t *l) {
- nodo_lef_t *aux;
- while (l->Primeiro != NULL) {
- aux = l->Primeiro;
- l->Primeiro = l->Primeiro->prox;
- free(aux->evento);
- free(aux);
- }
+ nodo_lef_t *aux;
+ while (l->Primeiro != NULL) {
+ aux = l->Primeiro;
+ l->Primeiro = l->Primeiro->prox;
+ free(aux->evento);
+ free(aux);
+ }
- free(l);
+ free(l);
- return NULL;
+ return NULL;
}
int adiciona_inicio_lef(lef_t *l, evento_t *evento) {
- nodo_lef_t *novo_nodo;
- if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
- return 0;
-
- evento_t *novo_evento;
- if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
- free(novo_nodo);
- return 0;
- }
+ nodo_lef_t *novo_nodo;
+ if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
+ return 0;
+
+ evento_t *novo_evento;
+ if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
+ free(novo_nodo);
+ return 0;
+ }
- memcpy(novo_evento, evento, sizeof(evento_t));
+ memcpy(novo_evento, evento, sizeof(evento_t));
- novo_nodo->evento = novo_evento;
+ novo_nodo->evento = novo_evento;
- novo_nodo->prox = l->Primeiro;
- l->Primeiro = novo_nodo;
+ novo_nodo->prox = l->Primeiro;
+ l->Primeiro = novo_nodo;
- return 1;
+ return 1;
}
int adiciona_ordem_lef(lef_t *l, evento_t *evento) {
- nodo_lef_t *novo_nodo;
- if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
- return 0;
-
- evento_t *novo_evento;
- if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
- free(novo_nodo);
- return 0;
- }
-
- memcpy(novo_evento, evento, sizeof(evento_t));
-
- novo_nodo->prox = l->Primeiro;
- novo_nodo->evento = novo_evento;
-
- if (l->Primeiro == NULL || l->Primeiro->evento->tempo > novo_nodo->evento->tempo) {
- l->Primeiro = novo_nodo;
- return 1;
- }
-
- nodo_lef_t *atual = l->Primeiro;
-
- while (atual->prox && atual->prox->evento->tempo < novo_nodo->evento->tempo)
- atual = atual->prox;
-
- novo_nodo->prox = atual->prox;
- atual->prox = novo_nodo;
-
- return 1;
+ nodo_lef_t *novo_nodo;
+ if ( !(novo_nodo = malloc(sizeof(nodo_lef_t))) )
+ return 0;
+
+ evento_t *novo_evento;
+ if ( !(novo_evento = malloc(sizeof(evento_t))) ) {
+ free(novo_nodo);
+ return 0;
+ }
+
+ memcpy(novo_evento, evento, sizeof(evento_t));
+
+ novo_nodo->prox = l->Primeiro;
+ novo_nodo->evento = novo_evento;
+
+ if (l->Primeiro == NULL || l->Primeiro->evento->tempo > novo_nodo->evento->tempo) {
+ l->Primeiro = novo_nodo;
+ return 1;
+ }
+
+ nodo_lef_t *atual = l->Primeiro;
+
+ while (atual->prox && atual->prox->evento->tempo < novo_nodo->evento->tempo)
+ atual = atual->prox;
+
+ novo_nodo->prox = atual->prox;
+ atual->prox = novo_nodo;
+
+ return 1;
}
evento_t *obtem_primeiro_lef(lef_t *l) {
- if (l->Primeiro == NULL)
- return NULL;
-
- nodo_lef_t *aux = l->Primeiro;
-
- evento_t *e = l->Primeiro->evento;
-
- l->Primeiro = l->Primeiro->prox;
-
- free(aux);
-
- return e;
+ if (l->Primeiro == NULL)
+ return NULL;
+
+ nodo_lef_t *aux = l->Primeiro;
+
+ evento_t *e = l->Primeiro->evento;
+
+ l->Primeiro = l->Primeiro->prox;
+
+ free(aux);
+
+ return e;
}
diff --git a/t1/mundo.c b/t1/mundo.c
index 850765a..29d5062 100644
--- a/t1/mundo.c
+++ b/t1/mundo.c
@@ -6,11 +6,11 @@
#include "libfila.h"
#include "liblef.h"
-#define MEM_ERROR_EXIT \
- do { \
- fprintf(stderr, "Erro: não foi possÃvel alocar memória."); \
- exit(1); \
- } while(0)
+#define MEM_ERROR_EXIT \
+ do { \
+ fprintf(stderr, "Erro: não foi possÃvel alocar memória."); \
+ exit(1); \
+ } while(0)
#define CHEGADA 0
#define SAIDA 1
@@ -18,335 +18,335 @@
#define FIM 3
typedef struct {
- int id;
- int paciencia;
- int idade;
- int exp;
- conjunto_t *habilidades_do_heroi;
+ int id;
+ int paciencia;
+ int idade;
+ int exp;
+ conjunto_t *habilidades_do_heroi;
} heroi_t;
typedef struct {
- int id;
- int lotacao_max;
- conjunto_t *publico;
- fila_t *fila;
- int posx;
- int posy;
+ int id;
+ int lotacao_max;
+ conjunto_t *publico;
+ fila_t *fila;
+ int posx;
+ int posy;
} local_t;
typedef struct {
- int tempo_atual;
- int tamanho_mundo; /* o mundo é um quadrado */
- int fim_do_mundo;
- int n_missoes;
- conjunto_t *cj_habilidades;
- int n_herois;
- int n_locais;
- heroi_t *herois;
- local_t *locais;
+ int tempo_atual;
+ int tamanho_mundo; /* o mundo é um quadrado */
+ int fim_do_mundo;
+ int n_missoes;
+ conjunto_t *cj_habilidades;
+ int n_herois;
+ int n_locais;
+ heroi_t *herois;
+ local_t *locais;
} mundo_t;
/* retorna um inteiro aleatório entre a e b (inclusive) */
int aleat(int a, int b) {
- return rand() % b + 1 + a;
+ return rand() % b + 1 + a;
}
/* retorna a distancia euclidiana entre dois locais em double */
double distancia(local_t loc1, local_t loc2) {
- int deltax = loc2.posx - loc1.posx;
- int deltay = loc2.posy - loc1.posy;
- int quadrado_da_distancia = deltax * deltax + deltay * deltay;
- return sqrt((double)quadrado_da_distancia);
+ int deltax = loc2.posx - loc1.posx;
+ int deltay = loc2.posy - loc1.posy;
+ int quadrado_da_distancia = deltax * deltax + deltay * deltay;
+ return sqrt((double)quadrado_da_distancia);
}
int max(int a, int b) {
- return a > b ? a : b;
+ return a > b ? a : b;
}
int vazia_lef(lef_t *l) {
- return l->Primeiro == NULL;
+ return l->Primeiro == NULL;
}
heroi_t inicializa_heroi(int id, conjunto_t *conjunto_de_habilidades) {
- heroi_t h;
-
- h.id = id;
- h.paciencia = aleat(0, 100);
- h.idade = aleat(18, 100);
- h.exp = 0;
+ heroi_t h;
+
+ h.id = id;
+ h.paciencia = aleat(0, 100);
+ h.idade = aleat(18, 100);
+ h.exp = 0;
- if ( !(h.habilidades_do_heroi = cria_subcjt_cjt(conjunto_de_habilidades, aleat(2, 5))) )
- MEM_ERROR_EXIT;
+ if ( !(h.habilidades_do_heroi = cria_subcjt_cjt(conjunto_de_habilidades, aleat(2, 5))) )
+ MEM_ERROR_EXIT;
- return h;
+ return h;
}
local_t inicializa_local(int id, int tamanho_mundo) {
- local_t l;
-
- l.id = id;
- l.lotacao_max = aleat(5, 30);
+ local_t l;
+
+ l.id = id;
+ l.lotacao_max = aleat(5, 30);
- if ( !(l.publico = cria_cjt(l.lotacao_max)) )
- MEM_ERROR_EXIT;
+ if ( !(l.publico = cria_cjt(l.lotacao_max)) )
+ MEM_ERROR_EXIT;
- if ( !(l.fila = cria_fila()) )
- MEM_ERROR_EXIT;
+ if ( !(l.fila = cria_fila()) )
+ MEM_ERROR_EXIT;
- l.posx = aleat(0, tamanho_mundo-1);
- l.posy = aleat(0, tamanho_mundo-1);
+ l.posx = aleat(0, tamanho_mundo-1);
+ l.posy = aleat(0, tamanho_mundo-1);
- return l;
+ return l;
}
mundo_t *cria_mundo(lef_t *lista_de_eventos) {
- mundo_t *m;
- if ( !(m = malloc(sizeof(mundo_t))) )
- MEM_ERROR_EXIT;
-
- m->tempo_atual = 0;
- m->tamanho_mundo = 20000;
- m->fim_do_mundo = 34944;
- m->n_missoes = m->fim_do_mundo / 100;
-
- const int n_habilidades = 10;
- if ( !(m->cj_habilidades = cria_cjt(n_habilidades)) )
- MEM_ERROR_EXIT;
- int i;
- for (i = 0; i < n_habilidades; i++)
- insere_cjt(m->cj_habilidades, i);
-
- m->n_herois = n_habilidades * 5;
- m->n_locais = m->n_herois / 6;
-
- /* cria vetor de heróis e preenche */
- if ( !(m->herois = malloc(m->n_herois * sizeof(heroi_t))) )
- MEM_ERROR_EXIT;
- for (i = 0; i < m->n_herois; i++)
- m->herois[i] = inicializa_heroi(i, m->cj_habilidades);
-
- /* cria vetor de locais e preenche */
- if ( !(m->locais = malloc(m->n_locais * sizeof(local_t))) )
- MEM_ERROR_EXIT;
- for (i = 0; i < m->n_locais; i++)
- m->locais[i] = inicializa_local(i, m->tamanho_mundo);
-
- /* para cada herói, cria evento de chegada e insere na lef */
- /* evento_t *evento_chegada_heroi; */
- for (i = 0; i < m->n_herois; i++) {
- evento_t evento_chegada_heroi = { aleat(0, 96*7), CHEGADA, m->herois[i].id, aleat(0, m->n_locais-1) };
- adiciona_ordem_lef(lista_de_eventos, &evento_chegada_heroi);
- }
-
- /* para cada missao, cria evento e insere na lef */
- for (i = 0; i < m->n_missoes; i++) {
- evento_t evento_missao = { aleat(0, m->fim_do_mundo), MISSAO, i, 0 };
- adiciona_ordem_lef(lista_de_eventos, &evento_missao);
- }
-
- /* cria evento de fim e insere na lef */
- evento_t fim = { m->fim_do_mundo, FIM, 0, 0 };
- adiciona_ordem_lef(lista_de_eventos, &fim);
-
- return m;
+ mundo_t *m;
+ if ( !(m = malloc(sizeof(mundo_t))) )
+ MEM_ERROR_EXIT;
+
+ m->tempo_atual = 0;
+ m->tamanho_mundo = 20000;
+ m->fim_do_mundo = 34944;
+ m->n_missoes = m->fim_do_mundo / 100;
+
+ const int n_habilidades = 10;
+ if ( !(m->cj_habilidades = cria_cjt(n_habilidades)) )
+ MEM_ERROR_EXIT;
+ int i;
+ for (i = 0; i < n_habilidades; i++)
+ insere_cjt(m->cj_habilidades, i);
+
+ m->n_herois = n_habilidades * 5;
+ m->n_locais = m->n_herois / 6;
+
+ /* cria vetor de heróis e preenche */
+ if ( !(m->herois = malloc(m->n_herois * sizeof(heroi_t))) )
+ MEM_ERROR_EXIT;
+ for (i = 0; i < m->n_herois; i++)
+ m->herois[i] = inicializa_heroi(i, m->cj_habilidades);
+
+ /* cria vetor de locais e preenche */
+ if ( !(m->locais = malloc(m->n_locais * sizeof(local_t))) )
+ MEM_ERROR_EXIT;
+ for (i = 0; i < m->n_locais; i++)
+ m->locais[i] = inicializa_local(i, m->tamanho_mundo);
+
+ /* para cada herói, cria evento de chegada e insere na lef */
+ /* evento_t *evento_chegada_heroi; */
+ for (i = 0; i < m->n_herois; i++) {
+ evento_t evento_chegada_heroi = { aleat(0, 96*7), CHEGADA, m->herois[i].id, aleat(0, m->n_locais-1) };
+ adiciona_ordem_lef(lista_de_eventos, &evento_chegada_heroi);
+ }
+
+ /* para cada missao, cria evento e insere na lef */
+ for (i = 0; i < m->n_missoes; i++) {
+ evento_t evento_missao = { aleat(0, m->fim_do_mundo), MISSAO, i, 0 };
+ adiciona_ordem_lef(lista_de_eventos, &evento_missao);
+ }
+
+ /* cria evento de fim e insere na lef */
+ evento_t fim = { m->fim_do_mundo, FIM, 0, 0 };
+ adiciona_ordem_lef(lista_de_eventos, &fim);
+
+ return m;
}
int local_lotado(int id_local, mundo_t *m) {
- return cardinalidade_cjt(m->locais[id_local].publico) >= m->locais[id_local].lotacao_max;
+ return cardinalidade_cjt(m->locais[id_local].publico) >= m->locais[id_local].lotacao_max;
}
int heroi_tem_paciencia(int id_heroi, int id_local, mundo_t *m) {
- return m->herois[id_heroi].paciencia/4 > tamanho_fila(m->locais[id_local].fila);
+ return m->herois[id_heroi].paciencia/4 > tamanho_fila(m->locais[id_local].fila);
}
int velocidade_heroi(heroi_t heroi) {
- return 100 - max(0, heroi.idade - 40);
+ return 100 - max(0, heroi.idade - 40);
}
conjunto_t *escolhe_menor_equipe(conjunto_t *missao, int id_missao, mundo_t *m, local_t *local_encontrado) {
- conjunto_t *menor;
- if ( !(menor = cria_cjt(cardinalidade_cjt(m->cj_habilidades))) )
- MEM_ERROR_EXIT;
- conjunto_t *uniao_old;
- conjunto_t *uniao;
- int i, j, id_heroi_atual;
-
- for (i = 0; i < m->n_locais; i++) {
- if (vazio_cjt(m->locais[i].publico)) continue;
-
- /* copia o conjunto de habilidades do primeiro herói do local atual */
- inicia_iterador_cjt(m->locais[i].publico);
- incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
- if ( !(uniao = copia_cjt(m->herois[id_heroi_atual].habilidades_do_heroi)) )
- MEM_ERROR_EXIT;
-
- /* faz a união entre os conjuntos de habilidades de todos os heróis do local atual */
- for (j = 1; j < cardinalidade_cjt(m->locais[i].publico); j++) {
- uniao_old = uniao;
- incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
- uniao = uniao_cjt(uniao, m->herois[id_heroi_atual].habilidades_do_heroi);
- uniao_old = destroi_cjt(uniao_old);
- }
-
- printf("%6d:MISSAO %3d HAB_EQL %d:", m->tempo_atual, id_missao, m->locais[i].id);
- imprime_cjt(uniao);
-
- /* compara se o conjunto construÃdo contém a missao e é menor que o achado anteriormente */
- if (contido_cjt(missao, uniao)) {
- if (vazio_cjt(menor) || cardinalidade_cjt(uniao) < cardinalidade_cjt(menor)) {
- menor = destroi_cjt(menor);
- if ( !(menor = copia_cjt(uniao)) )
- MEM_ERROR_EXIT;
- *local_encontrado = m->locais[i];
- }
- }
- uniao = destroi_cjt(uniao);
- }
-
- return menor;
+ conjunto_t *menor;
+ if ( !(menor = cria_cjt(cardinalidade_cjt(m->cj_habilidades))) )
+ MEM_ERROR_EXIT;
+ conjunto_t *uniao_old;
+ conjunto_t *uniao;
+ int i, j, id_heroi_atual;
+
+ for (i = 0; i < m->n_locais; i++) {
+ if (vazio_cjt(m->locais[i].publico)) continue;
+
+ /* copia o conjunto de habilidades do primeiro herói do local atual */
+ inicia_iterador_cjt(m->locais[i].publico);
+ incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
+ if ( !(uniao = copia_cjt(m->herois[id_heroi_atual].habilidades_do_heroi)) )
+ MEM_ERROR_EXIT;
+
+ /* faz a união entre os conjuntos de habilidades de todos os heróis do local atual */
+ for (j = 1; j < cardinalidade_cjt(m->locais[i].publico); j++) {
+ uniao_old = uniao;
+ incrementa_iterador_cjt(m->locais[i].publico, &id_heroi_atual);
+ uniao = uniao_cjt(uniao, m->herois[id_heroi_atual].habilidades_do_heroi);
+ uniao_old = destroi_cjt(uniao_old);
+ }
+
+ printf("%6d:MISSAO %3d HAB_EQL %d:", m->tempo_atual, id_missao, m->locais[i].id);
+ imprime_cjt(uniao);
+
+ /* compara se o conjunto construÃdo contém a missao e é menor que o achado anteriormente */
+ if (contido_cjt(missao, uniao)) {
+ if (vazio_cjt(menor) || cardinalidade_cjt(uniao) < cardinalidade_cjt(menor)) {
+ menor = destroi_cjt(menor);
+ if ( !(menor = copia_cjt(uniao)) )
+ MEM_ERROR_EXIT;
+ *local_encontrado = m->locais[i];
+ }
+ }
+ uniao = destroi_cjt(uniao);
+ }
+
+ return menor;
}
void trata_evento_chegada(int id_heroi, int id_local, mundo_t *m, lef_t *lista_de_eventos) {
- printf("%6d:CHEGA HEROI %2d Local %d (%2d/%2d), ",
- m->tempo_atual,
- id_heroi,
- id_local,
- cardinalidade_cjt(m->locais[id_local].publico),
- m->locais[id_local].lotacao_max);
-
- if (local_lotado(id_local, m)) {
- if (heroi_tem_paciencia(id_heroi, id_local, m)) {
- insere_fila(m->locais[id_local].fila, id_heroi);
- printf("FILA %d\n", tamanho_fila(m->locais[id_local].fila));
- return;
- }
-
- printf("DESISTE\n");
- evento_t saida = { m->tempo_atual, SAIDA, id_heroi, id_local };
- adiciona_ordem_lef(lista_de_eventos, &saida);
- return;
- }
-
- printf("ENTRA\n");
- insere_cjt(m->locais[id_local].publico, id_heroi);
- int t_permanencia_local = max(1, m->herois[id_heroi].paciencia/10 + aleat(-2,6));
- evento_t saida = { m->tempo_atual + t_permanencia_local, SAIDA, id_heroi, id_local };
- adiciona_ordem_lef(lista_de_eventos, &saida);
+ printf("%6d:CHEGA HEROI %2d Local %d (%2d/%2d), ",
+ m->tempo_atual,
+ id_heroi,
+ id_local,
+ cardinalidade_cjt(m->locais[id_local].publico),
+ m->locais[id_local].lotacao_max);
+
+ if (local_lotado(id_local, m)) {
+ if (heroi_tem_paciencia(id_heroi, id_local, m)) {
+ insere_fila(m->locais[id_local].fila, id_heroi);
+ printf("FILA %d\n", tamanho_fila(m->locais[id_local].fila));
+ return;
+ }
+
+ printf("DESISTE\n");
+ evento_t saida = { m->tempo_atual, SAIDA, id_heroi, id_local };
+ adiciona_ordem_lef(lista_de_eventos, &saida);
+ return;
+ }
+
+ printf("ENTRA\n");
+ insere_cjt(m->locais[id_local].publico, id_heroi);
+ int t_permanencia_local = max(1, m->herois[id_heroi].paciencia/10 + aleat(-2,6));
+ evento_t saida = { m->tempo_atual + t_permanencia_local, SAIDA, id_heroi, id_local };
+ adiciona_ordem_lef(lista_de_eventos, &saida);
}
void trata_evento_saida(int id_heroi, int id_local, mundo_t *m, lef_t *lista_de_eventos) {
- printf("%6d:SAIDA HEROI %2d Local %d (%2d/%2d)",
- m->tempo_atual,
- id_heroi,
- id_local,
- cardinalidade_cjt(m->locais[id_local].publico),
- m->locais[id_local].lotacao_max);
-
- if (pertence_cjt(m->locais[id_local].publico, id_heroi)) {
- retira_cjt(m->locais[id_local].publico, id_heroi);
- if (!vazia_fila(m->locais[id_local].fila)) {
- int id_heroi_fila;
- retira_fila(m->locais[id_local].fila, &id_heroi_fila);
- printf(", REMOVE FILA HEROI %d", id_heroi_fila);
- evento_t chegada_heroi_fila = { m->tempo_atual, CHEGADA, id_heroi_fila, id_local };
- adiciona_inicio_lef(lista_de_eventos, &chegada_heroi_fila);
- }
- }
- printf("\n");
-
- int id_local_destino = aleat(0, m->n_locais-1);
- int t_deslocamento = distancia(m->locais[id_local], m->locais[id_local_destino]) / velocidade_heroi(m->herois[id_heroi]);
- evento_t chegada_heroi = { m->tempo_atual + t_deslocamento/15, CHEGADA, id_heroi, id_local_destino };
- adiciona_ordem_lef(lista_de_eventos, &chegada_heroi);
+ printf("%6d:SAIDA HEROI %2d Local %d (%2d/%2d)",
+ m->tempo_atual,
+ id_heroi,
+ id_local,
+ cardinalidade_cjt(m->locais[id_local].publico),
+ m->locais[id_local].lotacao_max);
+
+ if (pertence_cjt(m->locais[id_local].publico, id_heroi)) {
+ retira_cjt(m->locais[id_local].publico, id_heroi);
+ if (!vazia_fila(m->locais[id_local].fila)) {
+ int id_heroi_fila;
+ retira_fila(m->locais[id_local].fila, &id_heroi_fila);
+ printf(", REMOVE FILA HEROI %d", id_heroi_fila);
+ evento_t chegada_heroi_fila = { m->tempo_atual, CHEGADA, id_heroi_fila, id_local };
+ adiciona_inicio_lef(lista_de_eventos, &chegada_heroi_fila);
+ }
+ }
+ printf("\n");
+
+ int id_local_destino = aleat(0, m->n_locais-1);
+ int t_deslocamento = distancia(m->locais[id_local], m->locais[id_local_destino]) / velocidade_heroi(m->herois[id_heroi]);
+ evento_t chegada_heroi = { m->tempo_atual + t_deslocamento/15, CHEGADA, id_heroi, id_local_destino };
+ adiciona_ordem_lef(lista_de_eventos, &chegada_heroi);
}
void trata_evento_missao(int id_missao, mundo_t *m, lef_t *lista_de_eventos) {
- conjunto_t *missao;
- if ( !(missao = cria_subcjt_cjt(m->cj_habilidades, aleat(3, 6))) )
- MEM_ERROR_EXIT;
-
- printf("%6d:MISSAO %3d HAB_REQ ", m->tempo_atual, id_missao);
- imprime_cjt(missao);
-
- local_t local_encontrado;
- conjunto_t *equipe_escolhida = escolhe_menor_equipe(missao, id_missao, m, &local_encontrado);
-
- printf("%6d:MISSAO %3d ", m->tempo_atual, id_missao);
- if (vazio_cjt(equipe_escolhida)) {
- printf("IMPOSSIVEL\n");
- evento_t nova_tentativa = { aleat(m->tempo_atual, m->fim_do_mundo), MISSAO, id_missao, 0 };
- adiciona_ordem_lef(lista_de_eventos, &nova_tentativa);
- } else {
- printf("HER_EQS %d:", local_encontrado.id);
- imprime_cjt(local_encontrado.publico);
-
- int id_heroi_encontrado;
- inicia_iterador_cjt(local_encontrado.publico);
- int i;
- for (i = 0; i < cardinalidade_cjt(local_encontrado.publico); i++) {
- incrementa_iterador_cjt(local_encontrado.publico, &id_heroi_encontrado);
- (m->herois[id_heroi_encontrado].exp)++;
- }
- }
- missao = destroi_cjt(missao);
- equipe_escolhida = destroi_cjt(equipe_escolhida);
+ conjunto_t *missao;
+ if ( !(missao = cria_subcjt_cjt(m->cj_habilidades, aleat(3, 6))) )
+ MEM_ERROR_EXIT;
+
+ printf("%6d:MISSAO %3d HAB_REQ ", m->tempo_atual, id_missao);
+ imprime_cjt(missao);
+
+ local_t local_encontrado;
+ conjunto_t *equipe_escolhida = escolhe_menor_equipe(missao, id_missao, m, &local_encontrado);
+
+ printf("%6d:MISSAO %3d ", m->tempo_atual, id_missao);
+ if (vazio_cjt(equipe_escolhida)) {
+ printf("IMPOSSIVEL\n");
+ evento_t nova_tentativa = { aleat(m->tempo_atual, m->fim_do_mundo), MISSAO, id_missao, 0 };
+ adiciona_ordem_lef(lista_de_eventos, &nova_tentativa);
+ } else {
+ printf("HER_EQS %d:", local_encontrado.id);
+ imprime_cjt(local_encontrado.publico);
+
+ int id_heroi_encontrado;
+ inicia_iterador_cjt(local_encontrado.publico);
+ int i;
+ for (i = 0; i < cardinalidade_cjt(local_encontrado.publico); i++) {
+ incrementa_iterador_cjt(local_encontrado.publico, &id_heroi_encontrado);
+ (m->herois[id_heroi_encontrado].exp)++;
+ }
+ }
+ missao = destroi_cjt(missao);
+ equipe_escolhida = destroi_cjt(equipe_escolhida);
}
void trata_evento_fim(mundo_t *m, lef_t **lista_de_eventos) {
- printf("%6d:FIM\n", m->tempo_atual);
- int i;
- for (i = 0; i < m->n_herois; i++) {
- printf("HEROI %2d EXPERIENCIA %2d\n", m->herois[i].id, m->herois[i].exp);
- m->herois[i].habilidades_do_heroi = destroi_cjt(m->herois[i].habilidades_do_heroi);
- }
-
- for (i = 0; i < m->n_locais; i++) {
- m->locais[i].publico = destroi_cjt(m->locais[i].publico);
- m->locais[i].fila = destroi_fila(m->locais[i].fila);
- }
-
- free(m->herois);
- free(m->locais);
- m->cj_habilidades = destroi_cjt(m->cj_habilidades);
- free(m);
- *lista_de_eventos = destroi_lef(*lista_de_eventos);
+ printf("%6d:FIM\n", m->tempo_atual);
+ int i;
+ for (i = 0; i < m->n_herois; i++) {
+ printf("HEROI %2d EXPERIENCIA %2d\n", m->herois[i].id, m->herois[i].exp);
+ m->herois[i].habilidades_do_heroi = destroi_cjt(m->herois[i].habilidades_do_heroi);
+ }
+
+ for (i = 0; i < m->n_locais; i++) {
+ m->locais[i].publico = destroi_cjt(m->locais[i].publico);
+ m->locais[i].fila = destroi_fila(m->locais[i].fila);
+ }
+
+ free(m->herois);
+ free(m->locais);
+ m->cj_habilidades = destroi_cjt(m->cj_habilidades);
+ free(m);
+ *lista_de_eventos = destroi_lef(*lista_de_eventos);
}
int main() {
- srand(time(0));
-
- lef_t *lista_de_eventos;
- if ( !(lista_de_eventos = cria_lef()) )
- MEM_ERROR_EXIT;
-
- mundo_t *mundo = cria_mundo(lista_de_eventos);
-
- evento_t *evento_atual;
- /* ciclo da simulação */
- while ( lista_de_eventos && (evento_atual = obtem_primeiro_lef(lista_de_eventos)) ) {
- mundo->tempo_atual = evento_atual->tempo;
-
- /* trata o evento e atualiza estado do sistema */
- switch (evento_atual->tipo) {
- case CHEGADA:
- trata_evento_chegada(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
- break;
-
- case SAIDA:
- trata_evento_saida(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
- break;
-
- case MISSAO:
- trata_evento_missao(evento_atual->dado1, mundo, lista_de_eventos);
- break;
-
- case FIM:
- trata_evento_fim(mundo, &lista_de_eventos);
- break;
- }
-
- free(evento_atual);
- }
-
- return 0;
+ srand(time(0));
+
+ lef_t *lista_de_eventos;
+ if ( !(lista_de_eventos = cria_lef()) )
+ MEM_ERROR_EXIT;
+
+ mundo_t *mundo = cria_mundo(lista_de_eventos);
+
+ evento_t *evento_atual;
+ /* ciclo da simulação */
+ while ( lista_de_eventos && (evento_atual = obtem_primeiro_lef(lista_de_eventos)) ) {
+ mundo->tempo_atual = evento_atual->tempo;
+
+ /* trata o evento e atualiza estado do sistema */
+ switch (evento_atual->tipo) {
+ case CHEGADA:
+ trata_evento_chegada(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
+ break;
+
+ case SAIDA:
+ trata_evento_saida(evento_atual->dado1, evento_atual->dado2, mundo, lista_de_eventos);
+ break;
+
+ case MISSAO:
+ trata_evento_missao(evento_atual->dado1, mundo, lista_de_eventos);
+ break;
+
+ case FIM:
+ trata_evento_fim(mundo, &lista_de_eventos);
+ break;
+ }
+
+ free(evento_atual);
+ }
+
+ return 0;
}
diff --git a/tp1/racionais b/tp1/racionais
deleted file mode 100755
index fade14e44c4c6ed2ce5398a66f99b87aa28bff97..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 20864
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
TwD!xdzif*kvD>0xLD_!-SqV^J
diff --git a/tp1/racionais.c b/tp1/racionais.c
index 8b097f1..a9de61e 100644
--- a/tp1/racionais.c
+++ b/tp1/racionais.c
@@ -1,106 +1,106 @@
#include <stdio.h>
typedef struct rac {
- int num;
- int den;
+ int num;
+ int den;
} racional;
int mdc(int a, int b) {
- int resto;
- if (a != 0 && b != 0) {
- resto = a % b;
- while (resto) {
- a = b;
- b = resto;
- resto = a % b;
- }
- return b;
- }
- return 0;
+ int resto;
+ if (a != 0 && b != 0) {
+ resto = a % b;
+ while (resto) {
+ a = b;
+ b = resto;
+ resto = a % b;
+ }
+ return b;
+ }
+ return 0;
}
racional le_racional() {
- racional r;
- scanf("%d %d", &r.num, &r.den);
-
- return r;
+ racional r;
+ scanf("%d %d", &r.num, &r.den);
+
+ return r;
}
racional multiplica_rs(racional r, racional s) {
- racional p;
- p.num = r.num * s.num;
- p.den = r.den * s.den;
+ racional p;
+ p.num = r.num * s.num;
+ p.den = r.den * s.den;
- return p;
+ return p;
}
racional divide_rs(racional r, racional s) {
- racional p;
- p.num = r.num * s.den;
- p.den = r.den * s.num;
+ racional p;
+ p.num = r.num * s.den;
+ p.den = r.den * s.num;
- return p;
+ return p;
}
racional soma_rs(racional r, racional s) {
- racional p;
- p.den = r.den * s.den;
- p.num = r.num * s.den + s.num * r.den;
+ racional p;
+ p.den = r.den * s.den;
+ p.num = r.num * s.den + s.num * r.den;
- return p;
+ return p;
}
racional subtrai_rs(racional r, racional s) {
- racional p;
- p.den = r.den * s.den;
- p.num = r.num * s.den - s.num * r.den;
-
- return p;
+ racional p;
+ p.den = r.den * s.den;
+ p.num = r.num * s.den - s.num * r.den;
+
+ return p;
}
void formata_racional(racional r) {
- int fator = mdc(r.num, r.den);
-
- if (fator) {
- r.num /= fator;
- r.den /= fator;
- }
-
- if (!r.num) {
- printf("0\n");
- } else {
- if (r.den == 1) {
- printf("%d\n", r.num);
- } else {
- printf("%d/%d\n", r.num, r.den);
- }
- }
- return;
+ int fator = mdc(r.num, r.den);
+
+ if (fator) {
+ r.num /= fator;
+ r.den /= fator;
+ }
+
+ if (!r.num) {
+ printf("0\n");
+ } else {
+ if (r.den == 1) {
+ printf("%d\n", r.num);
+ } else {
+ printf("%d/%d\n", r.num, r.den);
+ }
+ }
+ return;
}
int valida_racional(racional r) {
- if (!r.den) return 0;
- return 1;
+ if (!r.den) return 0;
+ return 1;
}
int main() {
- racional r = le_racional();
- racional s = le_racional();
- while(valida_racional(s) && valida_racional(r)) {
- racional soma = soma_rs(r, s);
- formata_racional(soma);
-
- racional subtracao = subtrai_rs(r, s);
- formata_racional(subtracao);
-
- racional multiplicacao = multiplica_rs(r, s);
- formata_racional(multiplicacao);
-
- racional divisao = divide_rs(r, s);
- formata_racional(divisao);
-
- r = le_racional();
- if (r.den) { s = le_racional(); }
- }
- return 0;
+ racional r = le_racional();
+ racional s = le_racional();
+ while(valida_racional(s) && valida_racional(r)) {
+ racional soma = soma_rs(r, s);
+ formata_racional(soma);
+
+ racional subtracao = subtrai_rs(r, s);
+ formata_racional(subtracao);
+
+ racional multiplicacao = multiplica_rs(r, s);
+ formata_racional(multiplicacao);
+
+ racional divisao = divide_rs(r, s);
+ formata_racional(divisao);
+
+ r = le_racional();
+ if (r.den) { s = le_racional(); }
+ }
+ return 0;
}
diff --git a/tp2/lib_racionais.c b/tp2/lib_racionais.c
index c963f12..01aeefa 100644
--- a/tp2/lib_racionais.c
+++ b/tp2/lib_racionais.c
@@ -2,82 +2,82 @@
#include "lib_racionais.h"
int mdc(int a, int b) {
- int resto;
- if (a != 0 && b != 0) { resto = a % b;
- while (resto) {
- a = b;
- b = resto;
- resto = a % b;
- }
- return b;
- }
- return 0;
+ int resto;
+ if (a != 0 && b != 0) { resto = a % b;
+ while (resto) {
+ a = b;
+ b = resto;
+ resto = a % b;
+ }
+ return b;
+ }
+ return 0;
}
racional le_racional() {
- racional r;
- scanf("%d %d", &r.num, &r.den);
-
- return r;
+ racional r;
+ scanf("%d %d", &r.num, &r.den);
+
+ return r;
}
racional multiplica_rs(racional r, racional s) {
- racional p;
- p.num = r.num * s.num;
- p.den = r.den * s.den;
+ racional p;
+ p.num = r.num * s.num;
+ p.den = r.den * s.den;
- return p;
+ return p;
}
racional divide_rs(racional r, racional s) {
- racional p;
- p.num = r.num * s.den;
- p.den = r.den * s.num;
+ racional p;
+ p.num = r.num * s.den;
+ p.den = r.den * s.num;
- return p;
+ return p;
}
racional soma_rs(racional r, racional s) {
- racional p;
- p.den = r.den * s.den;
- p.num = r.num * s.den + s.num * r.den;
+ racional p;
+ p.den = r.den * s.den;
+ p.num = r.num * s.den + s.num * r.den;
- return p;
+ return p;
}
racional subtrai_rs(racional r, racional s) {
- racional p;
- p.den = r.den * s.den;
- p.num = r.num * s.den - s.num * r.den;
-
- return p;
+ racional p;
+ p.den = r.den * s.den;
+ p.num = r.num * s.den - s.num * r.den;
+
+ return p;
}
void formata_racional(racional r) {
- int fator = mdc(r.num, r.den);
-
- if (fator) {
- r.num /= fator;
- r.den /= fator;
- }
-
- if (!r.den) {
- printf("Erro: divisao por 0\n");
- } else {
- if (!r.num) {
- printf("0\n");
- } else {
- if (r.den == 1) {
- printf("%d\n", r.num);
- } else {
- printf("%d/%d\n", r.num, r.den);
- }
- }
- }
- return;
+ int fator = mdc(r.num, r.den);
+
+ if (fator) {
+ r.num /= fator;
+ r.den /= fator;
+ }
+
+ if (!r.den) {
+ printf("Erro: divisao por 0\n");
+ } else {
+ if (!r.num) {
+ printf("0\n");
+ } else {
+ if (r.den == 1) {
+ printf("%d\n", r.num);
+ } else {
+ printf("%d/%d\n", r.num, r.den);
+ }
+ }
+ }
+ return;
}
int valida_racional(racional r) {
- if (!r.den) return 0;
- return 1;
+ if (!r.den) return 0;
+ return 1;
}
diff --git a/tp2/lib_racionais.h b/tp2/lib_racionais.h
index 25a5008..d9d952d 100644
--- a/tp2/lib_racionais.h
+++ b/tp2/lib_racionais.h
@@ -1,6 +1,6 @@
typedef struct {
- int num;
- int den;
+ int num;
+ int den;
} racional;
/* le um numero racional (dois inteiros) */
diff --git a/tp2/makefile b/tp2/makefile
index 469a707..0ef8fa4 100644
--- a/tp2/makefile
+++ b/tp2/makefile
@@ -13,4 +13,4 @@ lib_racionais.o: lib_racionais.c
$(CC) -c $(OPCOES) lib_racionais.c
clean:
- rm -f ./*.o
+ rm -f ./*.o tp2
diff --git a/tp2/tp2 b/tp2/tp2
deleted file mode 100755
index a4ec5df262670455c83caa0ee4715d1f517c43b0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 20008
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
K9WDbGEB+V#4$9F0
diff --git a/tp2/tp2.c b/tp2/tp2.c
index f9206db..8e204fe 100644
--- a/tp2/tp2.c
+++ b/tp2/tp2.c
@@ -2,26 +2,26 @@
#include "lib_racionais.h"
int main() {
- racional r, s;
- r = le_racional();
- if (r.den) { s = le_racional(); }
- while(valida_racional(s) && valida_racional(r)) {
- racional soma = soma_rs(r, s);
- formata_racional(soma);
+ racional r, s;
+ r = le_racional();
+ if (r.den) { s = le_racional(); }
+ while(valida_racional(s) && valida_racional(r)) {
+ racional soma = soma_rs(r, s);
+ formata_racional(soma);
- racional subtracao = subtrai_rs(r, s);
- formata_racional(subtracao);
+ racional subtracao = subtrai_rs(r, s);
+ formata_racional(subtracao);
- racional multiplicacao = multiplica_rs(r, s);
- formata_racional(multiplicacao);
+ racional multiplicacao = multiplica_rs(r, s);
+ formata_racional(multiplicacao);
- racional divisao = divide_rs(r, s);
- formata_racional(divisao);
-
- printf("\n");
+ racional divisao = divide_rs(r, s);
+ formata_racional(divisao);
+
+ printf("\n");
- r = le_racional();
- if (r.den) { s = le_racional(); }
- }
- return 0;
+ r = le_racional();
+ if (r.den) { s = le_racional(); }
+ }
+ return 0;
}
diff --git a/tp3/lib_racionais.c b/tp3/lib_racionais.c
index 256f18d..cac1700 100644
--- a/tp3/lib_racionais.c
+++ b/tp3/lib_racionais.c
@@ -3,134 +3,134 @@
#include "lib_racionais.h"
int aleat(int min, int max) {
- return (rand() % (max - min + 1) + min);
+ return (rand() % (max - min + 1) + min);
}
racional *criar_r() {
- racional *r;
- if ( !(r = malloc(sizeof(racional))) )
- return NULL;
- return r;
+ racional *r;
+ if ( !(r = malloc(sizeof(racional))) )
+ return NULL;
+ return r;
}
racional *liberar_r(racional *r) {
- free(r);
- r = NULL;
- return r;
+ free(r);
+ r = NULL;
+ return r;
}
racional *sortear_r() {
- racional *r;
- r = criar_r();
- r->num = aleat(0, 100);
- r->den = aleat(1, 100);
- simplifica_r(r);
- return r;
+ racional *r;
+ r = criar_r();
+ r->num = aleat(0, 100);
+ r->den = aleat(1, 100);
+ simplifica_r(r);
+ return r;
}
int ler_r(racional *r) {
- if (!scanf("%d %d", &r->num, &r->den))
- return 0;
- if (!r->den)
- return 0;
- return 1;
+ if (!scanf("%d %d", &r->num, &r->den))
+ return 0;
+ if (!r->den)
+ return 0;
+ return 1;
}
void imprimir_r(racional *r) {
- if (!r->num) {
- printf("0");
- return;
- }
- if (r->den == 1) {
- printf("%d", r->num);
- return;
- }
- printf("%d/%d", r->num, r->den);
- return;
+ if (!r->num) {
+ printf("0");
+ return;
+ }
+ if (r->den == 1) {
+ printf("%d", r->num);
+ return;
+ }
+ printf("%d/%d", r->num, r->den);
+ return;
}
int mdc(int a, int b) {
- int r;
- while (b) {
- r = a % b;
- a = b;
- b = r;
- }
- return a;
+ int r;
+ while (b) {
+ r = a % b;
+ a = b;
+ b = r;
+ }
+ return a;
}
int mmc(int a, int b) {
- if (a && b)
- return ((a * b) / mdc(a, b));
- return 0;
+ if (a && b)
+ return ((a * b) / mdc(a, b));
+ return 0;
}
int valido_r(racional *r) {
- if (r->den)
- return 1;
- return 0;
+ if (r->den)
+ return 1;
+ return 0;
}
void simplifica_r(racional *r) {
- int fator = mdc(r->num, r->den);
- if (fator) {
- r->num /= fator;
- r->den /= fator;
- }
+ int fator = mdc(r->num, r->den);
+ if (fator) {
+ r->num /= fator;
+ r->den /= fator;
+ }
}
int menor_r(racional *r1, racional *r2) {
- int a = r1->num * r2->den;
- int b = r1->den * r2->num;
- if (a < b)
- return 1;
- return 0;
+ int a = r1->num * r2->den;
+ int b = r1->den * r2->num;
+ if (a < b)
+ return 1;
+ return 0;
}
int iguais_r(racional *r1, racional *r2) {
- int a = r1->num * r2->den;
- int b = r1->den * r2->num;
- if (a == b)
- return 1;
- return 0;
+ int a = r1->num * r2->den;
+ int b = r1->den * r2->num;
+ if (a == b)
+ return 1;
+ return 0;
}
racional *somar_r(racional *r1, racional *r2) {
- racional *soma;
- soma = criar_r();
+ racional *soma;
+ soma = criar_r();
- soma->den = r1->den * r2->den;
- soma->num = r1->num * r2->den + r2->num * r1->den;
- simplifica_r(soma);
- return soma;
+ soma->den = r1->den * r2->den;
+ soma->num = r1->num * r2->den + r2->num * r1->den;
+ simplifica_r(soma);
+ return soma;
}
racional *subtrair_r(racional *r1, racional *r2) {
- racional *dif;
- dif = criar_r();
+ racional *dif;
+ dif = criar_r();
- dif->den = r1->den * r2->den;
- dif->num = r1->num * r2->den - r2->num * r1->den;
- simplifica_r(dif);
- return dif;
+ dif->den = r1->den * r2->den;
+ dif->num = r1->num * r2->den - r2->num * r1->den;
+ simplifica_r(dif);
+ return dif;
}
racional *multiplicar_r(racional *r1, racional *r2) {
- racional *mult;
- mult = criar_r();
+ racional *mult;
+ mult = criar_r();
- mult->den = r1->den * r2->den;
- mult->num = r1->num * r2->num;
- simplifica_r(mult);
- return mult;
+ mult->den = r1->den * r2->den;
+ mult->num = r1->num * r2->num;
+ simplifica_r(mult);
+ return mult;
}
racional *dividir_r(racional *r1, racional *r2) {
- racional *div;
- div = criar_r();
+ racional *div;
+ div = criar_r();
- div->den = r1->den * r2->num;
- div->num = r1->num * r2->den;
- simplifica_r(div);
- return div;
+ div->den = r1->den * r2->num;
+ div->num = r1->num * r2->den;
+ simplifica_r(div);
+ return div;
}
diff --git a/tp3/makefile b/tp3/makefile
index 15fd51f..cf6df46 100644
--- a/tp3/makefile
+++ b/tp3/makefile
@@ -13,4 +13,4 @@ tp3.o: tp3.c
$(CC) -c $(CFLAGS) tp3.c
clean:
- rm -f *.o
+ rm -f *.o tp3
diff --git a/tp3/tp3 b/tp3/tp3
deleted file mode 100755
index fc1b47b817382d93324d309d114179727e25dc02..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 24864
zcmeHv4|H6`dGFj^jdb;IwX!5zwjo}?4t9uEvJu9{vMt$Ov$6$NjFlQNtXI1$Y0GL?
z*}W^<#12jb9JWG@NmF8qo0y#Z>1lwHzH$x;w1_}3eQ8q2X^5LYt=pPbE`C%oCMb!M
zeZOz+%-y?JE0UA+yz}09nxoxszQ6O$H{YF|x%X=B3G{4tX&O_-%{DQ@_Sc(~PRa1?
zl@)+awvN@}dpWy`l>;vmG?U+H0&vZ8+Eom7Np}O1UNconz{^ZBQ&4$Gko4v(ssRPP
zrX=Zcs!H4mzgKO_DX92Xdp?uT9B`d5%9w(7J&Mi27E|xw#$tF}#^t1hN{>*|dqC<v
zAoUcSCWlZIRNbVQ&}W^DrxW_Xqv8|aj5+o8N<AmsCgl~RHmKb4h7tX3+Uu2ihEJGb
zPI%EIGX+(9AA%mm<u@&An0L$e<{F0wWc(GB;bpCfc>mh=)<m==5l?0hwj5lywq<R*
zKa=vW5iXEl)CLXzjW_o(n3*J+45Ju}Mu`(Y^`{T)TD*DDORjewe|nMyw_JYDUv?-P
z)F#PLA$^q+gj3yv56PJQ|2S$Ujo@ps?+g>1s}OTR3Fg{4=$``JS3-Wp9P*pypx-_R
zoi4Ld{yYh~4<Bdoflx|5FbAEcty1!T4Z05>XQ=_9lzb29S2~3WM_xoI4c4+uI-HEM
zP$-^BMb@tmWg_9^05jslG0-wbIC57gGIUpHARJGyk*pCJ3a8mfI-WEJ*l;+JNJStP
zIT#KN#FODf{BF`B+oYN{Lc`&Bk`1I|F?M55_m-`pHU8_ZTDw(S<G+rDy7$}^ipJ8h
z!Fa}qrT5&lHIYij_JsQrWO8sgm6Rq!rf5k)bj&4k%`G5h9pRLrCS5~jYQWTWwJ091
zr5PtJX^jGRv%?b4E{Ru??)|{2sQFLLJDoD<N9Fvc=xQ+ZPN8PaQwl%5*`(98psqEd
zoUzgE^Td>mZnXjVX&aq#K$RIAovu4oj!Ak22owiZj@#(=>-MCLPEl0l&un!0(;-+-
z+33`UD$m&H2&h#iZS*RO%GfJ5y8KBK+*fUM4BUK~kHCBc<|8m4f%yo`N8tbC2)teQ
zzMluj&g;Q({*SGU1@D_QT=`dnV=w71im2qTyA9+E`4zVV)GcEqKSZ1h=l&(1&mR*w
zEr>3hd(FaWA#~x~3l>fbwF~FIYT>jXx^V6>3#Wz9g>w&CI4$5Vocp+i(}L*2xsO;l
zE#xko3o9JnwFvLFG2tKZr~Tw@0e`}Qf6;;esRRFG2R`Az?{nZs9C+4_ul`@%x!3Lt
z=KeJ}c6PdVPtOG3jwM@gqW15xq6<!J>_$BDO}n9T@fgrUs01f?n!x%QqX|Rfr#gnF
zGJmFS*-`YKy(l563;FA|5LorAU~W42!dshzFU+`u+RMS$eq}Vm0G9^z{Fwm}7o|_*
zcXT7MS@xQ~;Mm50Z9z4dd&8&+j&J;TAXAV0DxaT<BG@nU9|PC!fUea(>7P3QCRO^N
zhh*|bgX3i@Rth_Tnbnhj6QSzF#^YFcK7%Tox*sNk6M>7t+{>VU#iBn6`kVgQ@*gge
z|EMMZG0?{Y7w?-q_$`33naDja0tUzXW}?As8-)u7pVA@qw=dcp^aXQArgGV{rvjJA
zoi|&?1DArwgA<M4Bs4f4m<npI2FDSGQ&R>8=XoE<Q(ygMK0g+?q>Ts8j!kLn1D6iJ
zf-3Z0IO7gZ^v)FP(eD0vTA5EBg5I%0`?nxMD|1JFG#>bo)I}>_giJ7pcE^rPv22Bi
z(wiGj1<t|%d-MHfJ9hsjE_0coT!o7(m~)Q>&XQvr0zW$ZUE#>sODk``qtIz|IGD?x
z5iIIhfZPS@6_gwSV0|;eocEYbZS1^?RiUeJ_otVHyEAZihGnaSC+EsA4V(&03y-fI
z4@}RB=y>0BF!J5tM9ud|Mzp5=PZ4I<SYR6NPj3jEJ^am6fr~Vuocj{KP$yYw_S{j_
zot9_BSb0tI*rW#gY8b(KMc99xMzRqjf@^3)2?O7lQ#&VApGF3a!7bBGbNHw09;6v*
zZ1}7;cH|<fyRR1*!Z=eHYK*iBpGvh&?~!Vqzo2X`k%^}$2F%R8OBAE8o1=DWsun82
zQ-LYs6Ro)I=ZQSE9x~|ul>lbSd<dhL3!EQ2a^6a{{_((h$m})KaC*G&JgiNdo&PVB
zIAaoLOyZNUQ6!~P?{gS+M1Z25`ML0HhFlQM7P;ol9l4at&P;t9Qpmb%`YuiE&>ngB
zXXw86YO&<=G}}+zOXetRMaIbsq>LIXmd2G$nJrwH{#n6=*^*`~K4rQ+^EXknV#cda
zjAP$S&SerQ8K*iGaf@h_dYAxXwpq)8iC!s5Q{2zc3A4d(!KwQu)g``&42*Y{6)5}}
zYOi#s#*x3-n&;cdp{ro$&7f2to6)jMMV*Nm^_bP%Wh8cmV441mn-U+fBz`_qG(F{x
zoX=&a-du=;c;sEol6{wuR>&5N4CW^>J)H%wFh|gQrss}a%w?zPIxwytJ2K6TD=-h&
z{RL9!MO^i$=Uzv|jw6V<7jmaD&~I`P4q9jwPg7#_L_~}V5eg|;Xb|l+Bg#|g)YQ1>
z)D${J_Scd9z@@PxmzeQ>!Di^grQA2DF6Ou?ShkUR%WM;~uqo$AF)yBhaNS>g!<;K+
zQ)kARAR#I<8v>V(%;lqPzWq&YAtz|)OZ8XGA~b)SIrL*S{aO()UBz!!U?wL+BBpfF
z10tUp#}W_mq8`1VQ9x!yK*WXedHQ(;r6}thZN`7cHdi^?^#2BJzC*K{BmC5X68*%e
zm{jVv=+w7q+WIw}`gDl~EK4QhXp36HYGA-$x9naF9b;lW-1U1s6C0P}?s3<LyK}F1
z^>ydo>DtqkyVMt)XsH4DmY!9=q>E<io{Mntg<rajWvhQE*K<9&3q85Fw&nh#E8qCf
z!Lb*$;QAkD|I@roy7qP5(RF86=*59TgS4ull{!JPSy;IXf9AjDBQPI<`3TGz0S(V+
zsB|YY@pRai@)_abaB?W+i>7>|F(Z}st&Am&bj;W0i}_YWSKUy>R?t$Z7o36cXe#|d
zU))s94x?to;^~ynt|1hlNop&it)#3ib#I_;!sYlp{$Kh0a{TP|Oy~1GfcpTWfad{g
z0KfN>eEu-t=!Ja#1mI5rp98$>?R@?W;O7CU3;%+t)CYLSJNbMk;0$0C@XDX&^Y;Sw
z0)7GTZoroSUjsY~xZ>S>z6@KaKL%V5_%h%&zy(+pMFFn|ych73fL{RoA>d1ZS7Tju
z7VuHPvNGIk!1{DK;0WM0z#jq91M(jH!aNR0&w{CFckgD}L9e#7rb0gk|A|iTIGjct
za1VpAZ584X+j3Of@j3cdK7SIBdA!>_%{%I<59mkP<|Q|L;M(O^5}EY(;WGm{p-4m&
zq8s>3gMN$%vQS$O;`1TI_c5XcJl^|VTWiZ*$KjFb%i|z_7yP3|`~!mT1MTndS%Y!O
z+WCPow`)*{i2l&{jzQ*nyG*jc_oDBA0{&(|%Ln&bjU>p&HqgI@u|90qcV#RedckkP
z*gsmt|CHGPXk^2H%!82mfL$hB@Zr<oKMX$I{IGn875IMz{ukau{~y4A68zt@>$`3i
z2B`gu;J*R>o+AEEi{FU+Ta3INDdL+!B>i^q<KVBh^M?xl?E(L8@O$ihjKjwuBKi;h
zm%v|P=kF`%e;WL+fWOzyckQzL`z!GO&1v7Y)#CpH_;t9>irTmFFM_`Te9A*BzOK70
z{YJX3-h<x`{=b1AF4Es?>F)u5Ij-YU{B6)Nz#joWM*7=5-cP!^J<WgU4tRVMWdYC1
z2l+Nn+x_K1&$_XS8$F##&$=#8TbF0$7LRX>r+JIVyTzl6=iSf2&T-h`WM{t2M_@hz
z^AVVjz<dPeBQPI<-!cN~{WtZ#8<vWqC|INH%0)dMd5QAMQWGwgxO%TnlCAgUmPo#O
zzmC>}RItPs<(*&UQ&c&LwG9=uwrP_U^$y)DlCRz|`@Sj8)VpQP5^s`F0jb6g%J<H&
z6cpvOgtR}QqTY2|WTI@PBq;ijbVT_*Ddp6=aH{?HNxG85woCL6@f0N7Z4~%QX%Bab
z6<=s#yCZO2^0BQGxax;A|KA4G``k{0ZF0OjCG3@Ozl0+a9+mKzgeN6@N<ydIUx(|R
zro@d~x8C4e+1H;<8d=|Zf4je}Wp!3yt3S4;&EMAUU%kqtvkyYU99A>v-SU;rtFYZI
zRZRJ7kzl5LVxcMZk8{YkLegaE8g2PCx+drmO{s=lH-O=KZP9uFw_Xv4WA3twBtV(&
z*7Oa~ce^Ua2x#RS1;*PT%gZ?KT0n(gAOn9yddC+hsGg(xBTK1Xu0MotXl{dM#TtB_
zE?ccHgMdz(r?P7+VgO7Z1*dFn<v7)K+8&o(FA%T(1M*~@K$`VCNo>79eEJR&yFnl;
z^^cO+27$EcA>wohWSt0E*+zkM>hF?Rr$B=GQ-pL0q*tfwplpjk_Uhz%*|vr2Ah2J5
zl*G0-ZUPw6Ir6$JD7+rg|Bg7_0x@(N#IhaL8GwWOF9^A5K`+2jeTu|xuA|-VC-gnk
zg<bkK(8lzyk=Tdo_5gW6r%^4twe}u>WBPv5xqVRx;JE%pLiR2GeSnktm&w2#!ks_U
zKS4ToR^ABkl>RhvLRBq5p3!NKS+-yJHmMI2r(Yid?Iq?~3yfDRJ`TCcE!3ZDJXPJG
zmFw3+pj;<LHH{njRYQqE)N6oL-5~^Sqw42HHHL2?dlVHR+rVlkiIwv_C?sgGYd4^o
z@;?xi+Aov2aZ#_P0sp$v)L3m7@QTlQ{+x7n<E!Fi4JAnJlSF^4p2nqO6<pPI-CGWu
zo@92I>6Miti#*X-lIc|fDPt}nSMB~Mn5p|bbhN#k#9os#uDAgLTsv_m40%VHw$Dp7
z*F*cg2Y@u0$dDH|_LvqDR$UM6LnNZq8J(K1Uyd*BrWz9MlXefoCKc_(GoUWOy+BC#
zO=Ei(2xB*0PmZ`A+T)Eg?dEb5NwE4_vequFEtK=TxXmN1(M>YbT6?jzcFS5S9c9{e
zwaRfAUnh<4Z+IDD&^Agm${H&uBG;7va|8K`+jS;@*GXz8y&BA`l+)=oz}A>pZ^JbZ
z)jn85QE)vp#OfE5C7<y6_oX$uf~jaHo+E3b)4o+^KYP3)Bv(i`_fia&OTYH8rcaVu
zWBGro*W862vQ*Ah{~K2+$Asa=HMVFrS<zhhF!`m6F;^4cW0o~<l4(^|G}yo6*Q<=t
zEF`DQr_no_GM#hnw-LtqDU&YS`6(0G@_&BHG^f7`-TPf+qL}_F?9*RG(ezhQ?WU=;
zZi*(Bqtzb-I4c*pVe3*Ls+TVKqsyr3dT6hgF8HG@Ce~XYjbn2Bc#Vk;q0iKG-8k7C
z6*k9a**vOjj$UQAIl5ZfTyQ^WAFyoJB?(UmYjx6^xcdn&wG-b_))GFuwS-?<gNFl5
z8!lM8iLCVtYmdqWf5F;in36<)`!Ba!>%T_%_ASzmSk@XIC;T=sk?fMzdaUSWm9^WN
z?bdF4zqD2#X4>s?q8Y01#}A7&Lp7Ws!@GrH_bkKTQHFOfvK!vL!e;muyWu^S;l@K`
zct`nH<RYJzT2!<Xm6$}mY4B9n7kraMcUr0qw-dfi_;kNiUtwxPeZ5rQCi^<XnudoX
zOxq;nZ;<kZ;Ea+y0<ftz1{<!2qFw}GQ=^IOXA6g;P;M8>l~P&UvlqTjO67K`ypNRI
zrSjf-^x`_p?Z!vQ?W@Zlk=vmW%jNTA1+rH!HRCqK>V817%S5XIDZj^(zYM<wB)_al
z$uD}9<QIx;dP^?7X)Q-ZJJADq@@0{gFLm_GsCk9_OHy7uNfGjgrG2lw*oN4mFOYnt
zkbhXpizh2W{&8u)%Cg_wNAg_wuYR5i_PxXS|2K`-nK4dyhr<VfHk;@W6zjDWo`!0-
zXQ`)NTTtOe09*^1+jB$phU)dz-S`1_FK5-&n;?Oo#5z>5Sd<j3rOSyzQWXuF+f!X_
zs%aqTwKgm3pjBBgi{)YixE)CHYEA2IAo-drSa(A!<Z9b(iklackO#JO<q_Gc^J|+I
z7n~%|JDVTgvX~5cp>GMhkVf@(;j0&SHx!94;12Nyd;6r{Sgdbqf5vRAsT5B-ve3@6
zwMygo|9;eG1=8ybWW94B7C0l@V2@D2pp0$FxXaj@ahJnf&@77lEUvV>$lj`LTqt>(
z?Yttp7`4B}@0^>xOXH{g0y(Ln5Q4wfY$i?r>fAaQiL~N>oI`8d<v%<RCbO;UTjR+{
zA{&h{At#a9a{X~5^Bah?8iz(=#e#T9H*&2%0&iHxh(==r{vq;92%-wdGe$ZaF+$tB
zdjcR}$|%&J5l?}LUl{tgTeF7Fgwo+iJe3T`Gaymn4Xo0o7SD^n&RuWlw{dLHxw}=r
zl~?O&u6OW8<|@;6@Hzq=ymBAcHuCHB+j*tl#$ASByIZkuc9psH4*GtAFClP(H<8K?
zj(?Ob(*}6MKHhwcyB>dnYoFu(PF{DBbA1P|%JRxlGE_-Qt=vlhbPvJL@@4`XOdC6R
z<-J_n$=4p>HE(nM30`hwx%LF_=;C#7Mp-*a))t!9gi&;&$ZChfYWe*feXhKfd~q9m
z`K^dS2VdL)VDO69`Kq0qzrvRpXkh`b(y!o4Vcd12XaoJDuA_hD4|Cmp5I(xAK1*J9
ztWhBnU9m!BcJv9egJ?(eFfDs{KQDilSB{Z>O&iyr<F3#0`j2w`6<#&SD-ZktF5Jw^
z^(OApck;4lc?|+`tILJdJ^z1mG8ZS`@1EAh_GB_&j$~Fpm<z=?HSgu`8{qXF{HhLw
zi8r<J+UGcbUE~}xXD7cBDf~9Y(G2;bHeUW5ul_!-Jj<&Q@3Y*6ym*!*o7;HB+lc;I
zUbU05g&S0<gq2(Q`!G`A4RH6)&+!T*qQTv_>SNs1roX|pD>%&Rr#Wx^+#uH@yz(x(
zf<WVXE7#53@eJ~&W4r<BWm;T1$}65NYQxvYJ=Fdf5&;>g>6`efO>`M7MCKX1W{@v5
zc=-V5gS=`?TKPcRuMuc%LyB(V-qU;ut{7Osg_7k<2B^NggZl^g2Mq4(;5B~kLO4Vq
z)}S-csXNUV8@$Qj)g8Pp%NGw&9bs-6;HwP2tb<qEbgrATodIgovc0;<_CS$sw4>xi
zzK6PZh5EAtp%~5@Fz3opDiIB(1_m;?B}3dycr<3RW5XjXGn7gj^d=U|;81}OL_)^h
z$uONt0NDfSxDgAD7-<$7NQ4J7f=K53!x=~nhtqe((k3+>3rB_75FJC1j%COV79YkL
z2E*}mNW2`TX4(YJ-mx^ShG-_f8wU`u5RN#wi?t4=hGVTGv1mHg+PA%Tck7zAHEUYd
zwD#`ab>r$*BOUG!Cx%j)mXUO7umyyXYZ;C&7!(}{MY8EoB$dbxCs{l>8cUPwDf1n(
z3=1b>VZ5IfPdQzoe$tNw%i_hf!DKAz6K5|F+3X(+i6BvT3NbMQkWFSYvFI8>7XhG9
znIW~TQEU^jbO?8C=uJ7C=76QD6{G}CVL%v0!qMv(4)ySDUANx6U+!xeHnPds#=%%J
zmX1e&hSQOujpo53zLr5>3u3r2vcApNG7!!jN=Am#sbngfX~`xJ#FNn$gHCkFfGN(F
zpnw^%2m$~#2tr*lB8hNjNU`xV2u5VUhQqmN_)sD~IAo?zBo&QCM$siQQq;*pa47jg
zlyhs_MMj}U5OJlhQ(ncRF_<;NW<ufci|mM*Q}iR9WSIlu5u}yKIYf6DZ5Co|hJI9Z
za8_cQ%z=0!mP|3+8H^>vvyu<fWGp?KjHXjrvy+sI@Hmq~&_ii6ci1S--H4`uDt!!f
zwjVi(^hOn_o`?^`BVi!J*@Pj!;-E!@4eLrsvq(B_k_NL_beIO!rGZ6Agbh%piq`Rk
zG#1j7L$Hi~5yahzcvLhjmMrh}MJI7IV<qG)bauzOl5{sy=la-n+*mmsE-BBg=YqxZ
z<xD*fET&g5_1v(St~2#Kt(acP)N{CEdKDYOKG9j+c-p9*3)*>ZR)cMmonqGAIGxH@
zlI~%XCFynS)sl3tbq<!j6*sGA>N#vN9d~<uc8Xbdvj*#&BRkiPw={>Yuv3(LlXYH-
zo$F=`nR=dEOkc!GJx_GAX6yNDu{`#sopy>@ce5qTTavDxE*I;##aoueG{W5C&E8UU
z^^~@l=Vr@_2@-Rc2qrcM$l9OeoeIbVWWSdkt1sqY_b=#^4myRM<kj<crFA_jnk^30
z9+mC*XeHu53_97dp68P=${~C-HhUb8gI>!2&(1-gtH1OlNkjg$uRz67O4)x-$TZE$
zpKpV%vDx|ax|CP%7pNxAiOTGJz9j6-&bMc=Tz8eYP8XnK3lO(SnOeBLCCZhO?tE~x
zUeKkG4eXqQz8`d-O-@xez#ku*o&Sf09k2DEMBRz{grqwki#;Og&U=$zl62<-Df-tg
zFWPlpU(ZW<=N+@li0+y_&zzF-&YP6q5_Hwe0{o9T=)aJ5)UNn3sZxRX$Y)jsBdEQ9
z4*Gh~sb8$KNStj4-B(N!Sf8-tWzI)z^rXJtwV3Ih#Y*%*yq-MrnRM*+Mfn3^M<O<G
zLfUuU;rx=MJMXN1RnmK99?}g)Dlg1o{}u4Om>-%uNvcpbOFQb^#8%1ro}@ePxYOfY
z%75pbReH!ybmtx2w?L<Mo%!=~Dert7oR@Ux4fzWE-jjXj(}@L=?tIR$MADr%(XWzp
z=L1f9LS8C==w>gq>wLx%0iDL(*{>AnzCw7dT29(=KL7b6Nq63V{|x9?TH1xm)gnFx
z+^R*=M#jkEKkOo`aHv|y7!F0~ST(F+Ls&8nCQ{h9grZp0WkTWXK^942u^2OAQUAKO
zwW~`D(MfOdP&l0qAHu%MNFT!aZrGQFqS@i$Lr}3{AxIiUqUP4G_<jJLAh&&Y*G+*?
z;O1>19Pd`Fh9	TW{{Vse5ZNM;tH*5_Tt{Ku}r;Zrja5H}>q>($y2%wSD_7fjyx;
zU0ZqrWEHJOLXk{XbYQMEIBgO;JJn%zbTFMf^sborUZ>TG9i6opcWyB4%kkN}!B9->
zKGaH_9_Khu;VU@OE)U`>P{?2Vo^IAze8r;T=)YnT?W&BhdDI@7E;@H_?yYJlnn{I*
zaE>4y)`xwR*e!)<4=QeH7B^AYI@tCew&9_qk!K4QE5>d660uRjmPc$pLZSXlM*1wa
zv1&JB-v`M(leJs28h4CP@kxjU53YA?oI)X-QK(Xu4lgWuB4J@aL{Ha>k4h}qrg3Bb
z%%Ndy9s!NC35QgT{v$0t!u&~Wmi@S;?Z>ux1UC{6*+~7_IF9*@M<uCiOE>n~gG`7I
zVK2@6(L+fzVM5#w5FFf&$Y6I}gkT%zPsb8rQjoO~>>K@JVEm~12U9?)l8Hr_--sOq
zO49<QQzC)=u^~AT3`Jp0VWtgpMldy09ZiLY<1l8bV?3E3vk?XorlYa`>>wn=$w5qA
z5{)MZQmP*A?@z}@6^5fuW2%k_T65y>P@$hy4IfOmqNshVg6h3g$riGzPVg#x=v`2y
zulBbJ`oOanJliWOYk}GI_u}_}ih|2c)cRKI3q|Ng#jdaR%L@9GpoC6+dcul-9ZD(x
zPs;WcRPC#6uhai9^zq=(>c855D>y{KMIj%ls`TY!Xch;JnpEwpeY%3*2hU!lIg9iW
z)aYGVrLXq$3aTBQ@?Xg*_%Z0yySEBg`+fyGWlK)~C7Dg2LNQhPL$V<SC#9fj-`W4q
zNc}BRPTfaP@U%^zV&>F;3^a;~vX3Q<StNAsjGg0u!lCbzdJ3MD<`i(4XJ2;cPf7s=
zmHb@#PdW6}eGUbWDMbmDJq5q!&{ykQ1!Gmk29%zn(#vP|_^JCQ3f3w?37zr#rqoyC
z&wNr)!i+=}P~)d?bAMaNA4BRXcu@&T=xqOopp*ZqeRaP^L3*jeUYzZ}0VdspP-1F7
zt<Ix%$}3#KpFp?Hrmyb*9Bly+Mah|10ax^2f<d{f+E@39)cNAm)HxKo{-`KDHI82a
zjYO2bdY}KG+~7PwO17f(6)cCcU7vMI;WiVhc9aRFr*QfoaH6U9)jq*1^_}w6mc7)=
z_NBPRQu^0e6tklA6<i|q9b#;QG`QcvP<o0?Z|^#3#CufgUrsl!Y{e;i-5mPQbeKx?
zc8|R{^|#KUe|EE}_1Eggi!|cY-zD{(@p~*_DqNVOePxHBx^`p}0vx9wR+NL4CcF}$
q9UnEG>i3J-jwXbH_Z9)z|8Ou>yC#?J9hBC8@x!LXZ4Lzo%KkSa=`rm9
diff --git a/tp3/tp3.c b/tp3/tp3.c
index da2d13f..c50baab 100644
--- a/tp3/tp3.c
+++ b/tp3/tp3.c
@@ -6,88 +6,88 @@
/* le um inteiro na faixa [0..MAX-1] */
int ler_tamanho() {
- printf("Insira o tamanho do vetor (entre 0 e %d):\n", MAX-1);
- int n;
- scanf("%d", &n);
- while (n < 0 || n > MAX-1) {
- printf("Por favor, insira um inteiro entre 0 e %d:\n", MAX-1);
- scanf("%d", &n);
- }
- return n;
+ printf("Insira o tamanho do vetor (entre 0 e %d):\n", MAX-1);
+ int n;
+ scanf("%d", &n);
+ while (n < 0 || n > MAX-1) {
+ printf("Por favor, insira um inteiro entre 0 e %d:\n", MAX-1);
+ scanf("%d", &n);
+ }
+ return n;
}
/* imprime os racionais apontados pelo vetor de ponteiros para racionais */
void imprimir_vetor_racional(racional **vet, int tam) {
- int i;
- for (i = 0; i < tam-1; i++) {
- imprimir_r(*(vet + i));
- printf(" ");
- }
- imprimir_r(*(vet + tam-1)); /* por motivos de formatacao da saida, */
- printf("\n"); /* imprime o ultimo numero separadamente */
+ int i;
+ for (i = 0; i < tam-1; i++) {
+ imprimir_r(*(vet + i));
+ printf(" ");
+ }
+ imprimir_r(*(vet + tam-1)); /* por motivos de formatacao da saida, */
+ printf("\n"); /* imprime o ultimo numero separadamente */
}
/* retorna um vetor de tam ponteiros para numeros racionais validos gerados aleatoriamente */
/* retorna NULL em caso de falha */
racional **aleatorio_vetor_racional(int tam) {
- racional **vet;
- if ( !(vet = malloc(tam * sizeof(racional*))) )
- return NULL;
- int i;
- for (i = 0; i < tam; i++)
- *(vet + i) = sortear_r();
- return vet;
+ racional **vet;
+ if ( !(vet = malloc(tam * sizeof(racional*))) )
+ return NULL;
+ int i;
+ for (i = 0; i < tam; i++)
+ *(vet + i) = sortear_r();
+ return vet;
}
/* inverte dois ponteiros para racional */
void inverte_ponteiros(racional **r1, racional **r2) {
- racional *temp = *r1;
- *r1 = *r2;
- *r2 = temp;
+ racional *temp = *r1;
+ *r1 = *r2;
+ *r2 = temp;
}
/* retorna um vetor de tam ponteiros para numeros racionais que apontam em ordem crescente para os
* racionais apontados pelo vetor recebido no parametro. */
/* essa funcao eh uma implementacao do bubble sort */
racional **ordenar_vetor_racional(racional **vet, int tam) {
- racional **ord;
- if ( !(ord = malloc(tam * sizeof(racional*))) )
- return NULL;
- int i;
- for (i = 0; i < tam; i++) {
- *(ord + i) = *(vet + i);
- }
+ racional **ord;
+ if ( !(ord = malloc(tam * sizeof(racional*))) )
+ return NULL;
+ int i;
+ for (i = 0; i < tam; i++) {
+ *(ord + i) = *(vet + i);
+ }
- int swaps = 1;
- while (swaps) {
- swaps = 0;
- for (i = 0; i < tam-1; i++) {
- if (menor_r(*(ord + i+1), *(ord + i))) {
- inverte_ponteiros((ord + i+1), (ord + i));
- swaps++;
- }
- }
- tam--;
- }
- return ord;
+ int swaps = 1;
+ while (swaps) {
+ swaps = 0;
+ for (i = 0; i < tam-1; i++) {
+ if (menor_r(*(ord + i+1), *(ord + i))) {
+ inverte_ponteiros((ord + i+1), (ord + i));
+ swaps++;
+ }
+ }
+ tam--;
+ }
+ return ord;
}
/* libera a memoria alocada em um vetor vet de tam ponteiros para numeros racionais,
* e libera todos os ponteiros dentro dele */
racional **liberar_vetor_racional(racional **vet, int tam) {
- int i;
- for (i = 0; i < tam; i++) {
- free(*(vet + i));
- *(vet + i) = NULL;
- }
- free(vet);
- vet = NULL;
- return vet;
+ int i;
+ for (i = 0; i < tam; i++) {
+ free(*(vet + i));
+ *(vet + i) = NULL;
+ }
+ free(vet);
+ vet = NULL;
+ return vet;
}
int main() {
- /* inicializa semente randomica */
- srand(time(0));
+ /* inicializa semente randomica */
+ srand(time(0));
racional **v, **w;
/* v e w são vetores de ponteiros para racionais (racional *) */
@@ -95,8 +95,8 @@ int main() {
int tam;
/* ler o tamanho do vetor de racionais */
if (!(tam = ler_tamanho()))
- return 0; /* impede de passar 0 como um parametro para malloc */
-
+ return 0; /* impede de passar 0 como um parametro para malloc */
+
/* aloca v com tam ponteiros para racional */
v = aleatorio_vetor_racional(tam);
/* a funcao acima retorna NULL em caso de falha */
@@ -109,9 +109,9 @@ int main() {
imprimir_vetor_racional(w, tam);
/* libera toda memoria alocada dinamicamente */
- v = liberar_vetor_racional(v, tam);
- free(w); /* o vetor w pode ser liberado normalmente, porque os ponteiros que apontam para numeros */
- w = NULL; /* racionais ja foram liberados na chamada de liberar_vetor_racional para v. */
+ v = liberar_vetor_racional(v, tam);
+ free(w); /* o vetor w pode ser liberado normalmente, porque os ponteiros que apontam para numeros */
+ w = NULL; /* racionais ja foram liberados na chamada de liberar_vetor_racional para v. */
return 0;
}
diff --git a/tp4/lib_conjunto.c b/tp4/lib_conjunto.c
index b88f1db..9b3b8e5 100644
--- a/tp4/lib_conjunto.c
+++ b/tp4/lib_conjunto.c
@@ -6,228 +6,228 @@
* como estamos trabalhando com conjuntos ordenados, eh uma busca binaria.
* se o elemento nao esta no conjunto, retorna -1. */
int busca_cjt(conjunto_t *c, int elemento) {
- int inicio = 0;
- int fim = cardinalidade_cjt(c) - 1;
- int meio = fim / 2;
+ int inicio = 0;
+ int fim = cardinalidade_cjt(c) - 1;
+ int meio = fim / 2;
- while (inicio <= fim && c->v[meio] != elemento) {
- if (elemento > c->v[meio]) {
- inicio = meio + 1;
- } else {
- fim = meio - 1;
- }
- meio = (inicio + fim) / 2;
- }
+ while (inicio <= fim && c->v[meio] != elemento) {
+ if (elemento > c->v[meio]) {
+ inicio = meio + 1;
+ } else {
+ fim = meio - 1;
+ }
+ meio = (inicio + fim) / 2;
+ }
- return inicio > fim ? -1 : meio;
+ return inicio > fim ? -1 : meio;
}
conjunto_t *cria_cjt(int max) {
- conjunto_t *c;
- if ( !(c = malloc(sizeof(conjunto_t))) )
- return NULL;
- c->max = max;
- c->card = 0;
- c->ptr = 0;
- if ( !(c->v = malloc(sizeof(int) * max)) ) {
- free(c);
- return NULL;
- }
- return c;
+ conjunto_t *c;
+ if ( !(c = malloc(sizeof(conjunto_t))) )
+ return NULL;
+ c->max = max;
+ c->card = 0;
+ c->ptr = 0;
+ if ( !(c->v = malloc(sizeof(int) * max)) ) {
+ free(c);
+ return NULL;
+ }
+ return c;
}
conjunto_t *destroi_cjt(conjunto_t *c) {
- free(c->v);
- c->v = NULL;
- free(c);
- return NULL;
+ free(c->v);
+ c->v = NULL;
+ free(c);
+ return NULL;
}
int vazio_cjt(conjunto_t *c) {
- return cardinalidade_cjt(c) == 0;
+ return cardinalidade_cjt(c) == 0;
}
int cardinalidade_cjt(conjunto_t *c) {
- return c->card;
+ return c->card;
}
int insere_cjt(conjunto_t *c, int elemento) {
- if (cardinalidade_cjt(c) == c->max)
- return 0;
+ if (cardinalidade_cjt(c) == c->max)
+ return 0;
- if (pertence_cjt(c, elemento))
- return 1;
+ if (pertence_cjt(c, elemento))
+ return 1;
- int i = cardinalidade_cjt(c);
- while (i > 0 && c->v[i - 1] > elemento) {
- c->v[i] = c->v[i - 1];
- i--;
- }
-
- c->v[i] = elemento;
- c->card++;
- return 1;
+ int i = cardinalidade_cjt(c);
+ while (i > 0 && c->v[i - 1] > elemento) {
+ c->v[i] = c->v[i - 1];
+ i--;
+ }
+
+ c->v[i] = elemento;
+ c->card++;
+ return 1;
}
int retira_cjt(conjunto_t *c, int elemento) {
- if (!(pertence_cjt(c, elemento)))
- return 0;
+ if (!(pertence_cjt(c, elemento)))
+ return 0;
- int i;
- for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
- c->v[i] = c->v[i + 1];
- }
+ int i;
+ for(i = busca_cjt(c, elemento); i < cardinalidade_cjt(c)-1; i++) {
+ c->v[i] = c->v[i + 1];
+ }
- c->card--;
- return 1;
+ c->card--;
+ return 1;
}
int pertence_cjt(conjunto_t *c, int elemento) {
- return busca_cjt(c, elemento) != -1;
+ return busca_cjt(c, elemento) != -1;
}
int contido_cjt(conjunto_t *c1, conjunto_t *c2) {
- int i;
- for (i = 0; i < cardinalidade_cjt(c1); i++) {
- if (!(pertence_cjt(c2, c1->v[i])))
- return 0;
- }
- return 1;
+ int i;
+ for (i = 0; i < cardinalidade_cjt(c1); i++) {
+ if (!(pertence_cjt(c2, c1->v[i])))
+ return 0;
+ }
+ return 1;
}
int sao_iguais_cjt(conjunto_t *c1, conjunto_t *c2) {
- return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
+ return cardinalidade_cjt(c1) == cardinalidade_cjt(c2) && contido_cjt(c1, c2);
}
conjunto_t *diferenca_cjt(conjunto_t *c1, conjunto_t *c2) {
- conjunto_t *dif;
- if ( !(dif = cria_cjt(c1->max)) )
- return NULL;
+ conjunto_t *dif;
+ if ( !(dif = cria_cjt(c1->max)) )
+ return NULL;
- int i;
- for (i = 0; i < cardinalidade_cjt(c1); i++) {
- if (!(pertence_cjt(c2, c1->v[i])))
- insere_cjt(dif, c1->v[i]);
- }
+ int i;
+ for (i = 0; i < cardinalidade_cjt(c1); i++) {
+ if (!(pertence_cjt(c2, c1->v[i])))
+ insere_cjt(dif, c1->v[i]);
+ }
- return dif;
+ return dif;
}
conjunto_t *interseccao_cjt(conjunto_t *c1, conjunto_t *c2) {
- conjunto_t *inter;
- if ( !(inter = cria_cjt(c1->max)) )
- return NULL;
-
- conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
- conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
+ conjunto_t *inter;
+ if ( !(inter = cria_cjt(c1->max)) )
+ return NULL;
+
+ conjunto_t **menor_cjt = cardinalidade_cjt(c1) < cardinalidade_cjt(c2) ? &c1 : &c2;
+ conjunto_t **maior_cjt = cardinalidade_cjt(c1) > cardinalidade_cjt(c2) ? &c1 : &c2;
- int i;
- for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
- if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
- insere_cjt(inter, (*menor_cjt)->v[i]);
- }
+ int i;
+ for (i = 0; i < cardinalidade_cjt(*menor_cjt); i++) {
+ if (pertence_cjt(*maior_cjt, (*menor_cjt)->v[i]))
+ insere_cjt(inter, (*menor_cjt)->v[i]);
+ }
- return inter;
+ return inter;
}
conjunto_t *uniao_cjt(conjunto_t *c1, conjunto_t *c2) {
- conjunto_t *uniao;
- if ( !(uniao = cria_cjt(c1->max)) )
- return NULL;
+ conjunto_t *uniao;
+ if ( !(uniao = cria_cjt(c1->max)) )
+ return NULL;
- inicia_iterador_cjt(c1);
- inicia_iterador_cjt(c2);
+ inicia_iterador_cjt(c1);
+ inicia_iterador_cjt(c2);
- while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
- if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
- insere_cjt(uniao, c1->v[c1->ptr]);
- c1->ptr++;
- } else {
- insere_cjt(uniao, c2->v[c2->ptr]);
- c2->ptr++;
- }
- }
+ while (c1->ptr < cardinalidade_cjt(c1) && c2->ptr < cardinalidade_cjt(c2)) {
+ if (c1->v[c1->ptr] < c2->v[c2->ptr]) {
+ insere_cjt(uniao, c1->v[c1->ptr]);
+ c1->ptr++;
+ } else {
+ insere_cjt(uniao, c2->v[c2->ptr]);
+ c2->ptr++;
+ }
+ }
- conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
+ conjunto_t **ainda_falta = c1->ptr == cardinalidade_cjt(c1) ? &c2 : &c1;
- int i;
- for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
- insere_cjt(uniao, (*ainda_falta)->v[i]);
- }
+ int i;
+ for (i = (*ainda_falta)->ptr; i < cardinalidade_cjt(*ainda_falta); i++) {
+ insere_cjt(uniao, (*ainda_falta)->v[i]);
+ }
- inicia_iterador_cjt(c1);
- inicia_iterador_cjt(c2);
+ inicia_iterador_cjt(c1);
+ inicia_iterador_cjt(c2);
- return uniao;
+ return uniao;
}
conjunto_t *copia_cjt(conjunto_t *c) {
- conjunto_t *copia;
- if ( !(copia = cria_cjt(c->max)) )
- return NULL;
+ conjunto_t *copia;
+ if ( !(copia = cria_cjt(c->max)) )
+ return NULL;
- int i;
- for (i = 0; i < cardinalidade_cjt(c); i++) {
- insere_cjt(copia, c->v[i]);
- }
+ int i;
+ for (i = 0; i < cardinalidade_cjt(c); i++) {
+ insere_cjt(copia, c->v[i]);
+ }
- return copia;
+ return copia;
}
conjunto_t *cria_subcjt_cjt(conjunto_t *c, int n) {
- if (n >= cardinalidade_cjt(c))
- return copia_cjt(c);
+ if (n >= cardinalidade_cjt(c))
+ return copia_cjt(c);
- conjunto_t *sub;
- if ( !(sub = cria_cjt(c->max)) )
- return NULL;
+ conjunto_t *sub;
+ if ( !(sub = cria_cjt(c->max)) )
+ return NULL;
- conjunto_t *disponiveis;
- if ( !(disponiveis = copia_cjt(c)) )
- return NULL;
+ conjunto_t *disponiveis;
+ if ( !(disponiveis = copia_cjt(c)) )
+ return NULL;
- int i;
- int aleat;
- for (i = 0; i < n; i++) {
- aleat = rand() % cardinalidade_cjt(disponiveis);
- insere_cjt(sub, disponiveis->v[aleat]);
- retira_cjt(disponiveis, disponiveis->v[aleat]);
- }
-
- destroi_cjt(disponiveis);
- return sub;
+ int i;
+ int aleat;
+ for (i = 0; i < n; i++) {
+ aleat = rand() % cardinalidade_cjt(disponiveis);
+ insere_cjt(sub, disponiveis->v[aleat]);
+ retira_cjt(disponiveis, disponiveis->v[aleat]);
+ }
+
+ destroi_cjt(disponiveis);
+ return sub;
}
void imprime_cjt(conjunto_t *c) {
- if (vazio_cjt(c)) {
- printf("Conjunto vazio.\n");
- return;
- }
+ if (vazio_cjt(c)) {
+ printf("Conjunto vazio.\n");
+ return;
+ }
- int i;
- for (i = 0; i < cardinalidade_cjt(c)-1; i++)
- printf("%d ", c->v[i]);
- printf("%d\n", c->v[cardinalidade_cjt(c)-1]);
+ int i;
+ for (i = 0; i < cardinalidade_cjt(c)-1; i++)
+ printf("%d ", c->v[i]);
+ printf("%d\n", c->v[cardinalidade_cjt(c)-1]);
}
void inicia_iterador_cjt(conjunto_t *c) {
- c->ptr = 0;
+ c->ptr = 0;
}
int incrementa_iterador_cjt(conjunto_t *c, int *ret_iterador) {
- *ret_iterador = c->v[c->ptr];
- c->ptr++;
- if (c->ptr > cardinalidade_cjt(c))
- return 0;
- return 1;
+ *ret_iterador = c->v[c->ptr];
+ c->ptr++;
+ if (c->ptr > cardinalidade_cjt(c))
+ return 0;
+ return 1;
}
int retira_um_elemento_cjt(conjunto_t *c) {
- int aleat = rand() % cardinalidade_cjt(c);
- int retirar = c->v[aleat];
- int i;
- for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
- c->v[i] = c->v[i + 1];
- c->card--;
- return retirar;
+ int aleat = rand() % cardinalidade_cjt(c);
+ int retirar = c->v[aleat];
+ int i;
+ for (i = aleat; i < cardinalidade_cjt(c)-1; i++)
+ c->v[i] = c->v[i + 1];
+ c->card--;
+ return retirar;
}
diff --git a/tp4/makefile b/tp4/makefile
index e8d1210..9ea2d67 100644
--- a/tp4/makefile
+++ b/tp4/makefile
@@ -18,4 +18,4 @@ tp4.o: tp4.c
$(CC) -c $(CFLAGS) tp4.c
clean:
- rm -f $(objects)
+ rm -f $(objects) tp4
diff --git a/tp4/tp4 b/tp4/tp4
deleted file mode 100755
index 20a040c28befaad663997ebf45fbef3595571709..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 30504
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
Km+>&6+W!EflkaN)
diff --git a/tp4/tp4.c b/tp4/tp4.c
index 9f4e3ec..83470dd 100644
--- a/tp4/tp4.c
+++ b/tp4/tp4.c
@@ -4,105 +4,105 @@
#define MAX 100
conjunto_t *le_conjunto_simples(int max) {
- conjunto_t *leitura;
- if ( !(leitura = cria_cjt(max)) )
- return NULL;
- int n;
- scanf("%d", &n);
- while (n) {
- insere_cjt(leitura, n);
- scanf("%d", &n);
- }
- return leitura;
+ conjunto_t *leitura;
+ if ( !(leitura = cria_cjt(max)) )
+ return NULL;
+ int n;
+ scanf("%d", &n);
+ while (n) {
+ insere_cjt(leitura, n);
+ scanf("%d", &n);
+ }
+ return leitura;
}
conjunto_t **le_vetor_conjuntos(int *tam, int max) {
- conjunto_t **vetor_c;
- if ( !(vetor_c = malloc(sizeof(conjunto_t *) * max)) )
- return NULL;
- int n, m;
- scanf("%d", &n);
- while (n) {
- if ( !(vetor_c[*tam] = cria_cjt(15)) )
- return NULL;
- insere_cjt(vetor_c[*tam], n);
- scanf("%d", &m);
- while (m) {
- insere_cjt(vetor_c[*tam], m);
- scanf("%d", &m);
- }
- *tam = *tam + 1;
- scanf("%d", &n);
- }
- return vetor_c;
+ conjunto_t **vetor_c;
+ if ( !(vetor_c = malloc(sizeof(conjunto_t *) * max)) )
+ return NULL;
+ int n, m;
+ scanf("%d", &n);
+ while (n) {
+ if ( !(vetor_c[*tam] = cria_cjt(15)) )
+ return NULL;
+ insere_cjt(vetor_c[*tam], n);
+ scanf("%d", &m);
+ while (m) {
+ insere_cjt(vetor_c[*tam], m);
+ scanf("%d", &m);
+ }
+ *tam = *tam + 1;
+ scanf("%d", &n);
+ }
+ return vetor_c;
}
conjunto_t **libera_vetor_conjuntos(conjunto_t **vetor_c, int tam) {
- int i;
- for (i = 0; i < tam; i++)
- vetor_c[i] = destroi_cjt(vetor_c[i]);
- free(vetor_c);
- return NULL;
+ int i;
+ for (i = 0; i < tam; i++)
+ vetor_c[i] = destroi_cjt(vetor_c[i]);
+ free(vetor_c);
+ return NULL;
}
conjunto_t *acha_solucao(conjunto_t **herois, conjunto_t *missao, conjunto_t **equipes, int tam_equipes) {
- conjunto_t *menor;
- menor = cria_cjt(15);
- conjunto_t *uniao_old;
- conjunto_t *uniao;
- int i, j;
-
- for (i = 0; i < tam_equipes; i++) {
- uniao = copia_cjt(herois[equipes[i]->v[0] - 1]);
- /* copia o conjunto de habilidades de heroi correspondente ao primeiro elemento do conjunto equipe da posicao atual do vetor de equipes. ex: se a equipe atual é [5 6 7], copia o quinto conjunto de habilidades de heroi (de indice 4). */
- for (j = 1; j < cardinalidade_cjt(equipes[i]); j++) {
- uniao_old = uniao;
- uniao = uniao_cjt(uniao, herois[equipes[i]->v[j] - 1]);
- uniao_old = destroi_cjt(uniao_old);
- /* realiza a uniao de todos os conjuntos de habilidades de heroi referenciados no conjunto equipe da posicao atual do vetor de equipes. */
- }
- if (contido_cjt(missao, uniao)) {
- if (vazio_cjt(menor) || cardinalidade_cjt(equipes[i]) < cardinalidade_cjt(menor)) {
- menor = destroi_cjt(menor);
- menor = copia_cjt(equipes[i]);
- }
- }
- uniao = destroi_cjt(uniao);
- }
-
- return menor;
+ conjunto_t *menor;
+ menor = cria_cjt(15);
+ conjunto_t *uniao_old;
+ conjunto_t *uniao;
+ int i, j;
+
+ for (i = 0; i < tam_equipes; i++) {
+ uniao = copia_cjt(herois[equipes[i]->v[0] - 1]);
+ /* copia o conjunto de habilidades de heroi correspondente ao primeiro elemento do conjunto equipe da posicao atual do vetor de equipes. ex: se a equipe atual é [5 6 7], copia o quinto conjunto de habilidades de heroi (de indice 4). */
+ for (j = 1; j < cardinalidade_cjt(equipes[i]); j++) {
+ uniao_old = uniao;
+ uniao = uniao_cjt(uniao, herois[equipes[i]->v[j] - 1]);
+ uniao_old = destroi_cjt(uniao_old);
+ /* realiza a uniao de todos os conjuntos de habilidades de heroi referenciados no conjunto equipe da posicao atual do vetor de equipes. */
+ }
+ if (contido_cjt(missao, uniao)) {
+ if (vazio_cjt(menor) || cardinalidade_cjt(equipes[i]) < cardinalidade_cjt(menor)) {
+ menor = destroi_cjt(menor);
+ menor = copia_cjt(equipes[i]);
+ }
+ }
+ uniao = destroi_cjt(uniao);
+ }
+
+ return menor;
}
int main() {
/* ler os herois e suas habilidades */
- int tam_herois = 0;
- conjunto_t **vetor_herois;
- vetor_herois = le_vetor_conjuntos(&tam_herois, MAX);
-
+ int tam_herois = 0;
+ conjunto_t **vetor_herois;
+ vetor_herois = le_vetor_conjuntos(&tam_herois, MAX);
+
/* ler a missao */
- conjunto_t *missao;
- missao = le_conjunto_simples(20);
-
+ conjunto_t *missao;
+ missao = le_conjunto_simples(20);
+
/* ler as equipes de herois */
- int tam_equipes = 0;
- conjunto_t **vetor_equipes;
- vetor_equipes = le_vetor_conjuntos(&tam_equipes, MAX);
+ int tam_equipes = 0;
+ conjunto_t **vetor_equipes;
+ vetor_equipes = le_vetor_conjuntos(&tam_equipes, MAX);
/* a solucao eh encontrada se a missao esta contido na uniao das
* habilidades de uma equipe, mas tomando-se aquela de menor tamanho. */
- conjunto_t *solucao;
- solucao = acha_solucao(vetor_herois, missao, vetor_equipes, tam_equipes);
- if (vazio_cjt(solucao)) {
- printf("NENHUMA\n");
- } else {
- imprime_cjt(solucao);
- }
+ conjunto_t *solucao;
+ solucao = acha_solucao(vetor_herois, missao, vetor_equipes, tam_equipes);
+ if (vazio_cjt(solucao)) {
+ printf("NENHUMA\n");
+ } else {
+ imprime_cjt(solucao);
+ }
/* libera toda a memoria alocada dinamicamente */
- vetor_herois = libera_vetor_conjuntos(vetor_herois, tam_herois);
- missao = destroi_cjt(missao);
- vetor_equipes = libera_vetor_conjuntos(vetor_equipes, tam_equipes);
- solucao = destroi_cjt(solucao);
+ vetor_herois = libera_vetor_conjuntos(vetor_herois, tam_herois);
+ missao = destroi_cjt(missao);
+ vetor_equipes = libera_vetor_conjuntos(vetor_equipes, tam_equipes);
+ solucao = destroi_cjt(solucao);
return 0;
}
--
GitLab