diff --git a/t1/libconjunto.c b/t1/libconjunto.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce75e6b16fb937bec185553fa10be3a6fe39c243
--- /dev/null
+++ b/t1/libconjunto.c
@@ -0,0 +1,233 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "libconjunto.h"
+
+/* retorna a posicao de um elemento em um conjunto ([0..card-1]).
+ * 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;
+
+ 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;
+}
+
+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 *destroi_cjt(conjunto_t *c) {
+ free(c->v);
+ c->v = NULL;
+ free(c);
+ return NULL;
+}
+
+int vazio_cjt(conjunto_t *c) {
+ return cardinalidade_cjt(c) == 0;
+}
+
+int cardinalidade_cjt(conjunto_t *c) {
+ return c->card;
+}
+
+int insere_cjt(conjunto_t *c, int elemento) {
+ if (cardinalidade_cjt(c) == c->max)
+ return 0;
+
+ 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 retira_cjt(conjunto_t *c, int elemento) {
+ 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];
+ }
+
+ c->card--;
+ return 1;
+}
+
+int pertence_cjt(conjunto_t *c, int elemento) {
+ 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 sao_iguais_cjt(conjunto_t *c1, conjunto_t *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;
+
+ 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;
+}
+
+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;
+
+ 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;
+}
+
+conjunto_t *uniao_cjt(conjunto_t *c1, conjunto_t *c2) {
+ conjunto_t *uniao;
+ if ( !(uniao = cria_cjt(c1->max)) )
+ return NULL;
+
+ 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++;
+ }
+ }
+
+ 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]);
+ }
+
+ inicia_iterador_cjt(c1);
+ inicia_iterador_cjt(c2);
+
+ return uniao;
+}
+
+conjunto_t *copia_cjt(conjunto_t *c) {
+ 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]);
+ }
+
+ 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)) )
+ 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;
+ }
+
+ 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;
+}
+
+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;
+}
+
+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;
+}
diff --git a/t1/libfila.c b/t1/libfila.c
new file mode 100644
index 0000000000000000000000000000000000000000..0341819ea38ca14cd3f5b7a87bf09b112fc102c0
--- /dev/null
+++ b/t1/libfila.c
@@ -0,0 +1,80 @@
+#include <stdio.h>
+#include <stdlib.h>
+#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 *destroi_fila(fila_t *f) {
+ int i, e = 0, tamanho = tamanho_fila(f);
+ for (i = 0; i < tamanho; i++) {
+ retira_fila(f, &e);
+ }
+
+ free(f);
+ return NULL;
+}
+
+int vazia_fila(fila_t *f) {
+ return f->tamanho == 0;
+}
+
+int tamanho_fila(fila_t *f) {
+ 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;
+
+ (f->tamanho)++;
+
+ if (tamanho_fila(f) == 1) {
+ f->ini = 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;
+}
+
+void imprime_fila(fila_t *f) {
+ if (vazia_fila(f))
+ return;
+
+ 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");
+}
diff --git a/t1/libfila.o b/t1/libfila.o
new file mode 100644
index 0000000000000000000000000000000000000000..63a7a6ae05d9a72d25341029a9ebaeafde5b2e92
Binary files /dev/null and b/t1/libfila.o differ
diff --git a/t1/liblef.c b/t1/liblef.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d53fd0b3c280f28fce47e3d6740c92fa7210e57
--- /dev/null
+++ b/t1/liblef.c
@@ -0,0 +1,26 @@
+#include <stdlib.h>
+
+lef_t *cria_lef() {
+ /*TODO: não implementado*/
+ return NULL;
+}
+
+lef_t *destroi_lef(lef_t *l) {
+ /*TODO: não implementado*/
+ return NULL;
+}
+
+int adiciona_inicio_lef (lef_t *l, evento_t *evento) {
+ /*TODO: não implementado*/
+ return 0;
+}
+
+int adiciona_ordem_lef (lef_t *l, evento_t *evento) {
+ /*TODO: não implementado*/
+ return 0;
+}
+
+evento_t *obtem_primeiro_lef (lef_t *l) {
+ /*TODO: não implementado*/
+ return NULL;
+}
diff --git a/t1/makefile b/t1/makefile
index 52c38d35a9c811657c10dddab2712d76106fdfdb..e210452796018bd7073c8b37a44bd0eb2e899e15 100644
--- a/t1/makefile
+++ b/t1/makefile
@@ -6,10 +6,13 @@ LDFLAGS = -lm
CC = gcc
# arquivos-objeto
- objects = mundo.o libconjunto.o liblef.o libfila.o
+ objects = mundo.o libconjunto.o liblef.o libfila.o
-mundo: mundo.o libconjunto.o liblef.o libfila.o
- $(CC) -o mundo mundo.o libconjunto.o liblef.o libfila.o $(LDFLAGS)
+mundo: mundo.o libconjunto.o liblef.o libfila.o
+ $(CC) -o mundo mundo.o libconjunto.o liblef.o libfila.o $(LDFLAGS)
+
+teste: teste.o liblef.o
+ $(CC) -o teste teste.o liblef.o $(LDFLAGS)
libconjunto.o: libconjunto.c
$(CC) -c $(CFLAGS) libconjunto.c
@@ -23,7 +26,8 @@ libfila.o: libfila.c
mundo.o: mundo.c
$(CC) -c $(CFLAGS) mundo.c
+teste.o: teste.c
+ $(CC) -c $(CFLAGS) teste.c
+
clean:
rm -f $(objects) mundo
-
-
diff --git a/t1/mundo.c b/t1/mundo.c
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/t1/teste b/t1/teste
new file mode 100755
index 0000000000000000000000000000000000000000..381c674840818c707f985538d6e15643b0e32691
Binary files /dev/null and b/t1/teste differ
diff --git a/t1/teste.c b/t1/teste.c
new file mode 100644
index 0000000000000000000000000000000000000000..764bb1605bd2b57ab5c8ff2c3dee9293a91a20d9
--- /dev/null
+++ b/t1/teste.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+#include <stdlib.h>
+/* #include "libconjunto.h" */
+/* #include "libfila.h" */
+#include "liblef.h"
+
+int main() {
+
+ return 0;
+}
diff --git a/t1/teste.o b/t1/teste.o
new file mode 100644
index 0000000000000000000000000000000000000000..fcb4c8d3b7a3c97c529677263b89f452179bc9df
Binary files /dev/null and b/t1/teste.o differ