Commits

Francisco Souza  committed a359c31

Adicao do terceiro trabalho de Tecnicas de Programacao.

Disciplina cursada no curso tecnico em informatica do IFES.

Trabalho desenvolvido por Francisco Antonio da Silva Souza e Bruna Arruda Contarine.

  • Participants
  • Parent commits fab69bd

Comments (0)

Files changed (54)

File linguagem_c/trabalho_tp_ifes_3/enunciado.doc

Binary file added.

File linguagem_c/trabalho_tp_ifes_3/resolucao/ListaDuplaNo/ListaDuplaNo.cpp

+#include "stdafx.h"
+#include <stdlib.h>
+#include "ListaDuplaNo.h"
+
+void InicLista(Lista *ls)
+{
+	ls->tamanho = 0;
+	ls->prim = NULL;
+	ls->ult = NULL;
+	ls->marc = NULL;
+}
+
+void AnexLista(Lista *ls, tipo Elem)
+{
+	no *p;
+	p = (no *)malloc(1*sizeof(no));
+	p->info = Elem;
+	if (ls->tamanho == 0)
+	{
+		ls->marc = p;
+		ls->prim = p;
+		ls->ult = p;
+		p->prox = NULL;
+		p->ant = NULL;
+	}
+	else if (ls->ult == ls->marc)
+	{
+		ls->ult->prox = p;
+		p->ant = ls->ult;
+		p->prox = NULL;
+		ls->ult = p;
+		ls->marc = p;
+	}
+	else
+	{
+		p->prox = ls->marc->prox;
+		p->ant = ls->marc;
+		p->prox->ant =p;
+		ls->marc->prox = p;
+		ls->marc = p;
+	}
+	ls->tamanho++;
+}
+
+
+void InsLista(Lista *ls, tipo Elem)
+{
+	no *p;
+	p = (no *)malloc(1*sizeof(no));
+	p->info = Elem;
+	if (ls->tamanho == 0)
+	{
+		ls->marc = p;
+		ls->prim = p;
+		ls->ult = p;
+		p->prox = NULL;
+		p->ant = NULL;
+	}
+	else if(ls->marc == ls->prim)
+	{
+		p->ant = NULL;
+		p->prox = ls->prim;
+		ls->prim->ant = p;
+		ls->marc = p;
+		ls->prim = p;
+	}
+	else
+	{
+		p->ant = ls->marc->ant;
+		p->prox = ls->marc;
+		ls->marc->ant->prox = p;
+		ls->marc->ant = p;
+		ls->marc = p;
+	}
+	ls->tamanho++;
+}
+
+
+void ElimLista(Lista *ls)
+{
+	no *p;
+	p = ls->marc;
+	if (ls->tamanho == 1)
+	{
+		ls->prim = NULL;
+		ls->ult = NULL;
+		ls->marc = NULL;
+	}
+	else if (ls->marc == ls->prim)
+	{
+		ls->prim = ls->prim->prox;
+		ls->marc = ls->prim;
+		ls->marc->ant = NULL;
+	}
+	else if(ls->marc == ls->ult)
+	{
+		ls->marc = ls->marc->ant;
+		ls->ult = ls->marc;
+		ls->ult->prox = NULL;
+	}
+	else
+	{
+		p->ant->prox = p->prox;
+		p->prox->ant = p->ant;
+		ls->marc = p->prox;
+	}
+	ls->tamanho--;
+	free(p);
+}
+
+tipo InfoLista(Lista *ls)   
+{
+	return (ls->marc->info);
+}
+
+int LongLista(Lista *ls)
+{
+	return ls->tamanho;
+}
+
+void PosLista(Lista *ls)
+{
+	ls->marc = ls->marc->prox;
+}
+
+void AntLista(Lista *ls)
+{
+	ls->marc = ls->marc->ant;
+}
+
+void PrimLista(Lista *ls)
+{
+	ls->marc = ls->prim;
+}
+
+void UltLista(Lista *ls)
+{
+	ls->marc = ls->ult;
+}
+
+int MarcDef(Lista *ls)
+{
+	return (ls->marc != NULL);
+}
+
+void LiberaLista (Lista* ls)
+{
+	PrimLista(ls);
+	while (MarcDef(ls))
+		ElimLista(ls);
+
+}
+
+

File linguagem_c/trabalho_tp_ifes_3/resolucao/ListaDuplaNo/ListaDuplaNo.h

+#ifndef lista_h
+#define lista_h
+
+typedef void* tipo;
+
+//Defini��o de lista
+typedef struct no
+{
+	tipo info;
+	struct no *prox, *ant;
+} no;
+
+typedef struct Lista
+{
+	int tamanho;
+	no *prim, *ult, *marc;
+} Lista;
+
+
+
+void InicLista(Lista *ls);
+void AnexLista(Lista *ls, tipo elem);
+void InsLista(Lista *ls, tipo elem);
+void ElimLista(Lista *ls);
+tipo InfoLista(Lista *ls);
+int LongLista(Lista *ls);
+void PosLista(Lista *ls);
+void AntLista(Lista *ls);
+void PrimLista(Lista *ls);
+void UltLista(Lista *ls);
+int MarcDef(Lista *ls);
+void LiberaLista (Lista* ls);
+
+
+#endif

File linguagem_c/trabalho_tp_ifes_3/resolucao/ListaFunc/ListaFunc.cpp

+#include "stdafx.h"
+#include "ListaFunc.h"
+#include <stdlib.h>
+
+/*===============================================================================
+Fun��o: InicReparticao
+	Inicia uma reparti��o (lista de funcion�rios).
+Par�metros: O ponteiro para a reparti��o.
+================================================================================*/
+void InicReparticao (Rep *reparticao)
+{
+	reparticao->ls = (Lista *)malloc(sizeof(Lista));
+	InicLista(reparticao->ls);
+}
+
+/*===============================================================================
+Fun��o: AddFuncionario
+	Adiciona um funcion�rio em uma reparti��o.
+Par�metros: O ponteiro para a reparti��o e um ponteiro para um funcion�rio.
+================================================================================*/
+void AddFuncionario (Rep *reparticao, Func *funcionario)
+{
+	tipo funcionario_pv;
+	funcionario_pv = funcionario;
+	AnexLista(reparticao->ls, funcionario);
+}
+
+/*===============================================================================
+Fun��o: InfoFuncionario
+	Retorna o funcion�rio para onde o marcador da lista aponta.
+Par�metros: O ponteiro para a reparti��o.
+Retorno: Um ponteiro para um funcion�rio.
+================================================================================*/
+Func *InfoFuncionario (Rep *reparticao)
+{
+	return ((Func *)InfoLista(reparticao->ls));
+}
+
+/*===============================================================================
+Fun��o: NomeFuncionario
+	Retorna o nome do funcion�rio para onde o marcador da lista aponta.
+Par�metros: O ponteiro para a reparti��o.
+Retorno: O nome do funcion�rio.
+================================================================================*/
+char *NomeFuncionario (Rep *reparticao)
+{
+	return (InfoFuncionario(reparticao)->nome);
+}
+
+/*===============================================================================
+Fun��o: SalarioFuncionario
+	Retorna o sal�rio do funcion�rio para onde o marcador da lista aponta.
+Par�metros: O ponteiro para a reparti��o.
+Retorno: O sal�rio do funcion�rio.
+================================================================================*/
+float SalarioFuncionario (Rep *reparticao)
+{
+	return (InfoFuncionario(reparticao)->salario);
+}
+
+/*===============================================================================
+Fun��o: IdadeFuncionario
+	Retorna a idade do funcion�rio para onde o marcador da lista aponta.
+Par�metros: O ponteiro para a reparti��o.
+Retorno: A idade do funcion�rio.
+================================================================================*/
+int IdadeFuncionario (Rep *reparticao)
+{
+	return (InfoFuncionario(reparticao)->idade);
+}
+
+/*===============================================================================
+Fun��o: SexoFuncionario
+	Retorna o sexo do funcion�rio para onde o marcador da lista aponta.
+Par�metros: O ponteiro para a reparti��o.
+Retorno: O sexo do funcion�rio.
+================================================================================*/
+char SexoFuncionario (Rep *reparticao)
+{
+	return (InfoFuncionario(reparticao)->sexo[0]);
+}
+
+/*===============================================================================
+Fun��o: LiberaReparticao
+	Libera uma reparti��o
+Par�metros: O ponteiro para a reparti��o.
+================================================================================*/
+void LiberaReparticao (Rep *reparticao)
+{
+	if (reparticao == NULL)
+		exit(1);
+	LiberaLista(reparticao->ls);
+}
+
+/*===============================================================================
+Fun��o: ReparticaoVazia
+	Indica se uma reparti��o est� vazia.
+Par�metros: O ponteiro para a reparti��o.
+Retorno: 1 se a reparti��o estiver vazia, 0 se n�o estiver.
+================================================================================*/
+int ReparticaoVazia(Rep *reparticao)
+{
+	return (LongLista(reparticao->ls) == 0);
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/ListaFunc/ListaFunc.h

+#include "../ListaDuplaNo/ListaDuplaNo.h"
+
+/*==================================================================================
+Biblioteca: ListaFunc.h
+	Possui fun��es �teis que definem uma lista de funcion�rios.
+===================================================================================*/
+
+typedef struct Funcionario {
+	char nome[20];
+	float salario;
+	int idade;
+	char sexo[2];
+} Func;
+
+typedef struct Reparticao {
+	Lista *ls;
+} Rep;
+
+void InicReparticao (Rep *reparticao);
+void LiberaReparticao (Rep *reparticao);
+void AddFuncionario (Rep *reparticao, Func *funcionario);
+Func *InfoFuncionario (Rep *reparticao);
+char *NomeFuncionario (Rep *reparticao);
+float SalarioFuncionario (Rep *reparticao);
+int IdadeFuncionario (Rep *reparticao);
+char SexoFuncionario (Rep *reparticao);
+int ReparticaoVazia(Rep *reparticao);

File linguagem_c/trabalho_tp_ifes_3/resolucao/ListaReparts/ListaReparts.cpp

+#include "stdafx.h"
+#include "ListaReparts.h"
+#include <stdlib.h>
+
+/*===============================================================================
+Fun��o: InicReparticoes
+	Inicia uma lista de reparti��es, definida pelo tipo Reps.
+Par�metros: O ponteiro para as reparti��es.
+================================================================================*/
+void InicReparticoes(Reps *reparticoes)
+{
+	reparticoes->l_repart = (Lista *)malloc(sizeof(Lista));
+	InicLista(reparticoes->l_repart);
+}
+
+/*===============================================================================
+Fun��o: AddReparticao
+	Adiciona uma reparti��o na lista de reparti��es
+Par�metros: O ponteiro para todas as reparti��es e um ponteiro para uma reparti��o.
+================================================================================*/
+void AddReparticao(Reps *reparticoes, Rep *reparticao)
+{
+	void *reparticao_pv;
+	reparticao_pv = reparticao;
+	AnexLista(reparticoes->l_repart, reparticao_pv);
+}
+/*===============================================================================
+Fun��o: InfoReparticoes
+	Retorna o funcion�rio para onde o marcador da lista aponta.
+Par�metros: O ponteiro para a reparti��o.
+Retorno: Um ponteiro para um funcion�rio.
+================================================================================*/
+Rep *InfoReparticao(Reps *reparticoes)
+{
+	return ((Rep *)InfoLista(reparticoes->l_repart));
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/ListaReparts/ListaReparts.h

+#ifndef lista_r
+#define lista_r
+
+#include "../ListaFunc/ListaFunc.h"
+
+/*==================================================================================
+Biblioteca: ListaReparts.h
+	Possui fun��es �teis que definem uma lista de reparti��es.
+===================================================================================*/
+
+typedef struct Reparticoes {
+	Lista *l_repart;
+} Reps;
+
+void InicReparticoes(Reps *reparticoes);
+void AddReparticao(Reps *reparticoes, Rep *reparticao);
+Rep *InfoReparticao(Reps *reparticoes);
+
+#endif

File linguagem_c/trabalho_tp_ifes_3/resolucao/Ordenacao/lista/lista.cpp

+#include "stdafx.h"
+#include <stdlib.h>
+#include "lista.h"
+
+void InicLista(ListaOrdenar *ls)
+{
+	ls->tamanho = 0;
+	ls->prim = NULL;
+	ls->ult = NULL;
+	ls->marc1 = NULL;
+	ls->marc2 = NULL;
+}
+
+void AnexLista(ListaOrdenar *ls, tipo Elem)
+{
+	no *p;
+	p = (no *)malloc(1*sizeof(no));
+	p->info = Elem;
+	if (ls->tamanho == 0)
+	{
+		ls->marc1 = p;
+		ls->marc2 = p;
+		ls->prim = p;
+		ls->ult = p;
+		p->prox = NULL;
+		p->ant = NULL;
+	}
+	else if (ls->ult == ls->marc1)
+	{
+		ls->ult->prox = p;
+		p->ant = ls->ult;
+		p->prox = NULL;
+		ls->ult = p;
+		ls->marc1 = p;
+		ls->marc2 = p;
+	}
+	else
+	{
+		p->prox = ls->marc1->prox;
+		p->ant = ls->marc1;
+		p->prox->ant =p;
+		ls->marc1->prox = p;
+		ls->marc1 = p;
+		ls->marc2 = ls->marc1;
+	}
+	ls->tamanho++;
+}
+
+
+void InsLista(ListaOrdenar *ls, tipo Elem)
+{
+	no *p;
+	p = (no *)malloc(1*sizeof(no));
+	p->info = Elem;
+	if (ls->tamanho == 0)
+	{
+		ls->marc1 = p;
+		ls->prim = p;
+		ls->ult = p;
+		p->prox = NULL;
+		p->ant = NULL;
+		ls->marc2 = ls->marc1;
+	}
+	else if(ls->marc1 == ls->prim)
+	{
+		p->ant = NULL;
+		p->prox = ls->prim;
+		ls->prim->ant = p;
+		ls->marc1 = p;
+		ls->prim = p;
+		ls->marc2 = ls->marc1;
+	}
+	else
+	{
+		p->ant = ls->marc1->ant;
+		p->prox = ls->marc1;
+		ls->marc1->ant->prox = p;
+		ls->marc1->ant = p;
+		ls->marc1 = p;
+		ls->marc2 = ls->marc1;
+	}
+	ls->tamanho++;
+}
+
+
+void ElimLista(ListaOrdenar *ls)
+{
+	no *p;
+	p = ls->marc1;
+	if (ls->tamanho == 1)
+	{
+		ls->prim = NULL;
+		ls->ult = NULL;
+		ls->marc1 = NULL;
+		ls->marc2 = ls->marc1;
+	}
+	else if (ls->marc1 == ls->prim)
+	{
+		ls->prim = ls->prim->prox;
+		ls->marc1 = ls->prim;
+		ls->marc1->ant = NULL;
+		ls->marc2 = ls->marc1;
+	}
+	else if(ls->marc1 == ls->ult)
+	{
+		ls->marc1 = ls->marc1->ant;
+		ls->ult = ls->marc1;
+		ls->ult->prox = NULL;
+		ls->marc2 = ls->marc1;
+	}
+	else
+	{
+		p->ant->prox = p->prox;
+		p->prox->ant = p->ant;
+		ls->marc1 = p->prox;
+		ls->marc2 = ls->marc1;
+	}
+	ls->tamanho--;
+	free(p);
+}
+
+tipo InfoLista1(ListaOrdenar *ls)
+{
+	return (ls->marc1->info);
+}
+
+tipo InfoLista2(ListaOrdenar *ls)
+{
+	return (ls->marc2->info);
+}
+
+int LongLista(ListaOrdenar *ls)
+{
+	return ls->tamanho;
+}
+
+void PosLista1(ListaOrdenar *ls)
+{
+	ls->marc1 = ls->marc1->prox;
+}
+
+void PosLista2(ListaOrdenar *ls)
+{
+	ls->marc2 = ls->marc2->prox;
+}
+
+void AntLista1(ListaOrdenar *ls)
+{
+	ls->marc1 = ls->marc1->ant;
+}
+
+void AntLista2(ListaOrdenar *ls)
+{
+	ls->marc2 = ls->marc2->ant;
+}
+
+void PrimLista(ListaOrdenar *ls)
+{
+	ls->marc1 = ls->prim;
+}
+
+void UltLista(ListaOrdenar *ls)
+{
+	ls->marc1 = ls->ult;
+}
+
+int MarcDef1(ListaOrdenar *ls)
+{
+	return (ls->marc1 != NULL);
+}
+
+int MarcDef2(ListaOrdenar *ls)
+{
+	return (ls->marc2 != NULL);
+}
+
+void Marc2RecMarc1(ListaOrdenar *ls)
+{
+	ls->marc2 = ls->marc1;
+}
+
+void Marc1RecMarc2(ListaOrdenar *ls)
+{
+	ls->marc1 = ls->marc2;
+}
+
+void LiberaLista (ListaOrdenar* ls)
+{
+	PrimLista(ls);
+	while (MarcDef1(ls))
+		ElimLista(ls);
+}
+
+

File linguagem_c/trabalho_tp_ifes_3/resolucao/Ordenacao/lista/lista.h

+#include "../ListaDuplaNo/ListaDuplaNo.h"
+
+typedef struct ListaOrdenar
+{
+	int tamanho;
+	no *prim, *ult, *marc1, *marc2;
+} ListaOrdenar;
+
+void InicLista(ListaOrdenar *ls);
+void AnexLista(ListaOrdenar *ls, tipo elem);
+void InsLista(ListaOrdenar *ls, tipo elem);
+void ElimLista(ListaOrdenar *ls);
+tipo InfoLista1(ListaOrdenar *ls);
+tipo InfoLista2(ListaOrdenar *ls);
+int LongLista(ListaOrdenar *ls);
+void PosLista1(ListaOrdenar *ls);
+void PosLista2(ListaOrdenar *ls);
+void AntLista1(ListaOrdenar *ls);
+void AntLista2(ListaOrdenar *ls);
+void PrimLista(ListaOrdenar *ls);
+void UltLista(ListaOrdenar *ls);
+int MarcDef1(ListaOrdenar *ls);
+int MarcDef2(ListaOrdenar *ls);
+void Marc2RecMarc1(ListaOrdenar *ls);
+void Marc1RecMarc2(ListaOrdenar *ls);
+void LiberaLista (ListaOrdenar *ls);

File linguagem_c/trabalho_tp_ifes_3/resolucao/Ordenacao/ordena.cpp

+#include "stdafx.h"
+#include "ordena.h"
+#include "../chars/chars.h"
+#include <stdlib.h>
+#include <string.h>
+
+void InicRepOrdenar(RepOrdenar *reparticao)
+{
+	reparticao->ls = (ListaOrdenar *)malloc(sizeof(ListaOrdenar));
+	InicLista(reparticao->ls);
+}
+
+void TransfereLista(RepOrdenar *destino, Rep *origem)
+{
+	PrimLista(origem->ls);
+	while(MarcDef(origem->ls))
+	{
+		AnexLista((destino->ls), (InfoLista(origem->ls)));
+		PosLista(origem->ls);
+	}
+}
+
+void Trocar(tipo *v1, tipo *v2)
+{
+	tipo t = *v1;
+	*v1 = *v2;
+	*v2 = t;
+}
+
+void OrdenarElementos(RepOrdenar *reparticao)
+{
+	PrimLista(reparticao->ls);
+	PosLista1(reparticao->ls);
+	Func *funcionario; 
+	funcionario = (Func *)malloc(sizeof(Func));
+	char *nome1, *nome2;
+	int i, tam_nome1, tam_nome2, tam_menor;
+	while (MarcDef1(reparticao->ls))
+	{
+		funcionario = (Func *)InfoLista1(reparticao->ls);
+		Marc2RecMarc1(reparticao->ls);
+		PosLista2(reparticao->ls);
+		nome1 = funcionario->nome;
+		tam_nome1 = strlen(nome1);
+		while (MarcDef2(reparticao->ls))
+		{
+			nome2 = ((Func *)InfoLista2(reparticao->ls))->nome;
+			tam_nome2 = strlen(nome2);
+			if (tam_nome1 > tam_nome2)
+				tam_menor = tam_nome2;
+			else
+				tam_menor = tam_nome1;
+			for (i = 0; i < tam_menor; i++)
+			{
+				if((ParaMinusculo(nome1[i])) > (ParaMinusculo(nome2[i])))
+				{
+					tipo v1 = InfoLista1(reparticao->ls);
+					tipo v2 = InfoLista2(reparticao->ls);
+					Trocar(&(reparticao->ls->marc1->info), &(reparticao->ls->marc2->info));
+				}
+			}
+			AntLista2(reparticao->ls);
+		}
+		PosLista1(reparticao->ls);
+	}
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/Ordenacao/ordena.h

+#include "lista/lista.h"
+#include "../ListaReparts/ListaReparts.h"
+
+typedef struct RepOrdenar {
+	ListaOrdenar *ls;
+} RepOrdenar;
+
+void InicRepOrdenar(RepOrdenar *reparticao);
+void TransfereLista(RepOrdenar *destino, Rep *origem);
+void OrdenarElementos(RepOrdenar *reparticao);
+void Trocar(tipo *v1, tipo *v2);

File linguagem_c/trabalho_tp_ifes_3/resolucao/VetorInteiro/VetorInteiro.cpp

+#include "stdafx.h"
+
+/*===============================================================================
+Fun��o: MaiorDoVetor
+	Percorre um vetor de inteiros e determina o seu maior valor.
+Par�metros: O vetor e seu tamanho.
+Retorno: O maior valor do vetor. Se o vetor for NULL, retorna 0.
+================================================================================*/
+int MaiorDoVetor(int *vet, int tam)
+{
+	if (vet == NULL)
+		return 0;
+	int i;
+	int maior = vet[0];
+	for (i = 1; i < tam; i++)
+		if (vet[i] > maior)
+			maior = vet[i];
+
+	return maior;
+}
+
+/*===============================================================================
+Fun��o: BuscaNoVetor
+	Busca um valor informado em um vetor de inteiros.
+Par�metros: O vetor, seu tamanho e o valor a ser pesquisado.
+Retorno: A posi��o do valor no vetor.
+		 Se o valor n�o for encontrado ou o vetor for NULL, retorna NULL.
+================================================================================*/
+int BuscaNoVetor(int *vet, int tam, int val)
+{
+	if (vet == NULL)
+		return NULL;
+	int i;
+	for (i = 0; i < tam; i++)
+		if (vet[i] == val)
+			return i;
+
+	return NULL;
+}
+
+/*===============================================================================
+Fun��o: BuscaNoVetor ("Sobrecarregada")
+	Busca um valor informado em um vetor de inteiros a partir de uma posi��o.
+Par�metros: O vetor, seu tamanho, o valor a ser pesquisado e de qual posi��o
+			a pesquisa deve ser iniciada.
+Retorno: A posi��o do valor no vetor a partir da posi��o indicada por inicio.
+		 Se o valor n�o for encontrado ou o vetor for NULL, retorna NULL.
+================================================================================*/
+int BuscaNoVetor(int *vet, int tam, int val, int inicio)
+{
+	if (vet == NULL)
+		return NULL;
+	int i;
+	for (i = inicio; i < tam; i++)
+		if (vet[i] == val)
+			return i;
+
+	return NULL;
+}
+/*===============================================================================
+Fun��o: ContaNoVetor
+	Conta quantas vezes um valor aparece em um vetor de inteiros
+Par�metros: O vetor, seu tamanho e o valor a ser pesquisado.
+Retorno: A quantidade de vezes que o valor apareceu no vetor, se o vetor for NULL
+		 retorna NULL.
+================================================================================*/
+int ContaNoVetor(int *vet, int tam, int val)
+{
+	if (vet == NULL)
+		return NULL;
+	int i, cont = 0;
+	for (i = 0; i < tam; i++)
+		if (vet[i] == val)
+			cont++;
+
+	return cont;
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/VetorInteiro/VetorInteiro.h

+/*===============================================================================
+Biblioteca: VetorInteiro
+	Possui algumas fun��es para manipula��o de vetores inteiros.
+================================================================================*/
+
+int MaiorDoVetor(int *vet, int tam);
+int BuscaNoVetor(int *vet, int tam, int val);
+int BuscaNoVetor(int *vet, int tam, int val, int inicio);
+int ContaNoVetor(int *vet, int tam, int val);

File linguagem_c/trabalho_tp_ifes_3/resolucao/aloca/aloca.cpp

+#include "stdafx.h"
+#include <stdlib.h>
+
+/*==============================================================
+   Fun��o alocaVetChar = Aloca uma string
+   Tamanho: tamanho
+==============================================================*/
+char *alocaVetChar (int tamanho)
+{
+	char *vet;
+	vet = (char *)malloc(tamanho * sizeof(char));
+	return vet;
+}
+/*==============================================================
+   Fun��o alocaVetFloat = Aloca um vetor de reais
+   Tamanho: tamanho
+==============================================================*/
+float *alocaVetFloat (int tamanho)
+{
+	float *vet;
+	vet = (float *)malloc(tamanho * sizeof(float));
+	return vet;
+}
+/*==============================================================
+   Fun��o alocaVetInt = Aloca um vetor de inteiros
+   Tamanho: tamanho
+==============================================================*/
+int *alocaVetInt (int tamanho)
+{
+	int *vet;
+	vet = (int *)malloc(tamanho * sizeof(int));
+	return vet;
+}
+/*==============================================================
+   Fun��o alocaMatInt = Aloca uma matriz de inteiros
+   Tamanho: linhas x colunas
+==============================================================*/
+int **alocaMatInt (int linhas, int colunas)
+{
+	int **mat;
+    int i;
+	mat = (int **)malloc(linhas * sizeof(int *));
+	for (i = 0;i < colunas;i++)
+		mat[i] = (int *)malloc(colunas * sizeof(int));
+
+	return mat;
+} 
+/*==============================================================
+   Fun��o alocaMatStr = Aloca um vetor de strings
+   Tamanho: linhas x colunas
+==============================================================*/
+char **alocaMatStr (int linhas, int colunas)
+{
+	char **mat;
+    int i;
+	mat = (char **)malloc(linhas * sizeof(char *));
+	for (i = 0;i < colunas;i++)
+		mat[i] = (char *)malloc(colunas * sizeof(char));
+
+	return mat;
+} 
+/*==============================================================
+   Fun��o alocaMatFloat = Aloca uma matriz de rais
+   Tamanho: linhas x colunas
+==============================================================*/
+float **alocaMatFloat (int linhas, int colunas)
+{
+	float **mat;
+    int i;
+	mat = (float **)malloc(linhas * sizeof(float *));
+	for (i = 0;i < colunas;i++)
+		mat[i] = (float *)malloc(colunas * sizeof(float));
+
+	return mat;
+} 

File linguagem_c/trabalho_tp_ifes_3/resolucao/aloca/aloca.h

+/*===========================================================================
+    Biblioteca aloca: Possui fun��es para alocar matrizes e vetores
+===========================================================================*/
+
+char *alocaVetChar (int tamanho);
+float *alocaVetFloat (int tamanho);
+int *alocaVetInt (int tamanho);
+
+char **alocaMatStr (int linhas, int colunas);
+float **alocaMatFloat (int linhas, int colunas);
+int **alocaMatInt (int linhas, int colunas);

File linguagem_c/trabalho_tp_ifes_3/resolucao/arquivo/arquivo.cpp

+#include "stdafx.h"
+
+/*===============================================================================
+Fun��o: AbreArquivoLeitura
+	Abre um arquivo no modo de leitura.
+Par�metros: O ponteiro do arquivo (passado por refer�ncia) e o nome do arquivo.
+================================================================================*/
+void AbreArquivoLeitura(FILE **arq, char *nomearquivo)
+{
+	*arq = fopen(nomearquivo, "r");
+	if (!(*arq))
+		printf("Erro ao abrir arquivo %s!\n",nomearquivo);
+	else
+		printf("\n\t\tArquivo %s aberto com sucesso!\n\n",nomearquivo);
+}
+/*===============================================================================
+Fun��o: AbreArquivoGravacao
+	Abre um arquivo no modo de grava��o.
+Par�metros: O ponteiro do arquivo (passado por refer�ncia) e o nome do arquivo.
+================================================================================*/
+void AbreArquivoGravacao(FILE **arq, char *nomearquivo)
+{
+	*arq = fopen(nomearquivo, "w");
+	if (!(*arq))
+		printf("Erro ao abrir/criar arquivo %s!\n",nomearquivo);
+}
+/*===============================================================================
+Fun��o: AbreArquivoAdicao
+	Abre um arquivo no modo de adi��o (append).
+Par�metros: O ponteiro do arquivo (passado por refer�ncia) e o nome do arquivo.
+================================================================================*/
+void AbreArquivoAdicao(FILE **arq, char *nomearquivo)
+{
+	*arq = fopen(nomearquivo, "a");
+	if (!(*arq))
+		printf("Erro ao abrir/criar arquivo %s!\n",nomearquivo);
+}
+/*===============================================================================
+Fun��o: FechaArquivo
+	Fecha um arquivo.
+Par�metros: O ponteiro e o nome do arquivo.
+================================================================================*/
+void FechaArquivo(FILE *arq, char *nomearquivo)
+{
+	fclose(arq);
+	printf("\n\t\tArquivo %s fechado/salvo com sucesso!\n\n",nomearquivo);
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/arquivo/arquivo.h

+/*====================================================================================
+Biblioteca arquivo.h
+	Possui fun��es para abertura de arquivo em modos diferentes.
+====================================================================================*/
+
+void AbreArquivoLeitura(FILE **arq, char *nomearquivo);
+void AbreArquivoGravacao(FILE **arq, char *nomearquivo);
+void AbreArquivoAdicao(FILE **arq, char *nomearquivo);
+void FechaArquivo(FILE *arq, char *nomearquivo);

File linguagem_c/trabalho_tp_ifes_3/resolucao/auxiliar/auxiliar.cpp

+#include "stdafx.h"
+#include <stdlib.h>
+
+/*===============================================================================
+Fun��o: ArquivoExiste
+	Verifica se um arquivo existe.
+Par�metros: O nome do arquivo
+Retorno: Caso o arquivo exista, retorna 1, caso contr�rio, retorna 0.
+================================================================================*/
+int ArquivoExiste(char nome_arquivo[30])
+{
+	FILE *fp;
+	fp = fopen(nome_arquivo,"r");
+	if(!fp)
+		return 0;
+	else
+	{
+		fclose(fp);
+		return 1;
+	}
+}
+/*===============================================================================
+Fun��o: GeraNomeArquivos
+	Gera o nome dos arquivos entrada_xx.txt e saida_xx.txt
+Par�metros: As vari�veis que receber�o o nome do arquivo de entrada e do arquivo
+			de sa�da, utilizando "passagem por refer�ncia".
+================================================================================*/
+void GeraNomeArquivos(char **entrada, char **saida)
+{
+	int n_entrada;
+	do {
+		printf ("\n\nDigite o numero do arquivo de entrada (1 a 999, 0 para cancelar): ");
+		scanf("%d", &n_entrada);
+	} while ((n_entrada < 1) && (n_entrada > 999));
+
+	if (!n_entrada)
+		exit(1);
+
+	if (n_entrada < 10)
+	{
+		sprintf(*entrada,"entrada_0%d.txt",n_entrada);
+		sprintf(*saida,"saida_0%d.txt",n_entrada);
+	}
+	else
+	{
+		sprintf(*entrada,"entrada_%d.txt",n_entrada);
+		sprintf(*saida,"saida_%d.txt",n_entrada);
+	}
+	
+	/* Verificando se o arquivo de entrada existe */
+	if (!ArquivoExiste(*entrada))
+	{
+		printf("Erro! Arquivo %s nao existe, digite uma entrada valida!\n",*entrada);
+		GeraNomeArquivos(&(*entrada), &(*saida));
+	}
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/auxiliar/auxiliar.h

+/*===============================================================================
+Biblioteca: auxiliar.h
+	Possui fun��es que auxiliam no tratamento dos nomes dos arquivos de
+	entrada e de sa�da.
+================================================================================*/
+
+int ArquivoExiste(char nome_arquivo[30]);
+void GeraNomeArquivos(char **entrada, char **saida);

File linguagem_c/trabalho_tp_ifes_3/resolucao/chars/chars.cpp

+#include "stdafx.h"
+
+/*===============================================================================
+Função: ParaMinusculo
+	Converte um caracter informado para seu correspondente em minúsculo.
+	Caso não haja nenhum correspondente, retorna o caracter informado.
+Parâmetros: O caracter de origem
+Retorno: O caracter em caixa baixa correspondente ao caracter de origem
+================================================================================*/
+char ParaMinusculo(char origem)
+{
+	if ((origem < 'A') || (origem > 'Z'))
+		return origem;
+	
+	return (origem + 32);
+}
+
+/*===============================================================================
+Função: ParaMaiusculo
+	Converte um caracter informado para seu correspondente em maiúsculo.
+	Caso não haja nenhum correspondente, retorna o caracter informado.
+Parâmetros: O caracter de origem
+Retorno: O caracter em caixa alta correspondente ao caracter de origem
+================================================================================*/
+char ParaMaiusculo(char origem)
+{
+	if ((origem < 'a') || (origem > 'z'))
+		return origem;
+
+	return (origem - 32);
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/chars/chars.h

+/*==========================================================================
+    Biblioteca chars.h:
+		Possui fun��es para convers�o de caracteres.
+==========================================================================*/
+
+char ParaMinusculo(char origem);
+char ParaMaiusculo(char origem);

File linguagem_c/trabalho_tp_ifes_3/resolucao/definições.txt

+typedef struct Funcionario {
+    char nome[20];
+    float salario;
+    int idade;
+    char sexo[2];
+} Func;
+
+typedef struct Reparticao {
+    Lista *ls;
+} Rep;
+
+void AddFuncionario (Rep *reparticao, Func *funcionario)
+{
+    tipo funcionario_pv;
+    funcionario_pv = (Func *)malloc(sizeof(Func));
+    funcionario_pv = funcionario;
+    AnexLista(reparticao->ls, funcionario);
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/desaloca/desaloca.cpp

+#include "stdafx.h"
+#include <stdlib.h>
+
+/*==============================================================
+   Fun��o liberaVetChar = Libera a mem�ria alocada para uma string
+==============================================================*/
+char *liberaVetChar (char *vet)
+{
+	if (vet == NULL)
+		return NULL;
+	free(vet);
+	return NULL;
+}
+/*==============================================================
+   Fun��o liberaVetFloat = Libera a mem�ria alocada para um
+						   vetor de reais
+==============================================================*/
+float *liberaVetFloat (float *vet)
+{
+	if (vet == NULL)
+		return NULL;
+	free(vet);
+	return NULL;
+}
+/*==============================================================
+   Fun��o liberaVetInt = Libera a mem�ria alocada para um
+						 vetor de inteiros
+==============================================================*/
+int *liberaVetInt (int *vet)
+{
+	if (vet == NULL)
+		return NULL;
+	free(vet);
+	return NULL;
+}
+/*==============================================================
+   Fun��o liberaMatChar = Libera a mem�ria alocada para uma
+						  matriz de strings
+==============================================================*/
+char **liberaMatChar (char **mat, int linhas, int colunas)
+{
+	int j;
+	if (mat == NULL)
+		return NULL;
+	if (linhas < 1 || colunas < 1)
+	{
+		return mat;
+	}
+	for (j=0; j<linhas; j++) 
+		free (mat[j]);
+	free (mat);
+	return NULL; 
+}
+/*==============================================================
+   Fun��o liberaMatFloat = Libera a mem�ria alocada para uma
+						   matriz de reais
+==============================================================*/
+float **liberaMatFloat (float **mat, int linhas, int colunas)
+{
+	int j;
+	if (mat == NULL)
+		return NULL;
+	if (linhas < 1 || colunas < 1)
+	{
+		return mat;
+	}
+	for (j=0; j<linhas; j++) 
+		free (mat[j]);
+	free (mat);
+	return NULL; 
+}
+/*==============================================================
+   Fun��o liberaMatInt = Libera a mem�ria alocada para uma
+						 matriz de inteiros
+==============================================================*/
+int **liberaMatInt (int **mat, int linhas, int colunas)
+{
+	int j;
+	if (mat == NULL)
+		return NULL;
+	if (linhas < 1 || colunas < 1)
+	{
+		return mat;
+	}
+	for (j=0; j<linhas; j++) 
+		free (mat[j]);
+	free (mat);
+	return NULL; 
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/desaloca/desaloca.h

+/*==========================================================================
+    Biblioteca desaloca: Possui fun��es para desalocar matrizes e vetores
+==========================================================================*/
+
+char *liberaVetChar (char *vet);
+float *liberaVetFloat (float *vet);
+int *liberaVetInt (int *vet);
+
+char **liberaMatChar (char **mat, int linhas, int colunas);
+float **liberaMatFloat (float **mat, int linhas, int colunas);
+int **liberaMatInt (int **mat, int linhas, int colunas);

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_01.txt

+Pedro	1500	18	M
+Luiza	800	17	F
+Carlos	600	48	M
+Bruna	3500	30	F
+Lavinia	600	25	F
+Lucas	250	32	M
+Julio	5023	19	M
+Julia	2500	40	F
+Fernando	30000	50	M
+Laize	520	36	F
+Jorge	1500	18	M
+Marcos	600	17	M
+Breno	800	26	M
+Leonardo	650	35	M
+Diego	350	40	M
+Paula	1500	14	F
+Georgia	630	42	F
+Viviane	1500	23	F
+Lauriane	600	36	F
+Karla	630	48	F
+Altivo	3500	24	M
+Ameriana	3500	21	F
+Joquebeyde	3562	20	F
+Bruna	2500	65	F
+Alexandre	6320	45	M
+Edgard	650	23	M
+Francisco	4520	18	M
+Francis	3620	19	M
+Mayla	4500	18	F
+Vanessa	360	18	F
+Udison	625	20	M
+Marcelo	985	21	M
+Jose	1500	20	M
+Carlos	985	35	M
+Lara	5000	90	F
+Lia	6950	85	F
+Jefferson	635	35	M
+Eduardo	450	50	M
+Jonathan	650	36	M
+Douglas	1500	98	M
+Penha	1500	54	F
+Camila	650	20	F
+Juliana	1685	36	F
+Gilmar	25600	21	M
+Josiane	69500	32	F
+Mayara	520	80	F
+Natasha	350	95	F
+Igor	950	45	M
+Higor	650	40	M
+Andre	950	45	M
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_02.txt

+Maria	500	18	F
+Carlos	800	45	M
+Alexandre	1500	12	M
+fim
+Caroline	650	45	F
+fim
+Francisco	1200	15	M
+Franceyla	658	56	F
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_03.txt

+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_04.txt

+Amanda	4510	41	F
+Luciana	200	18	F
+Patrician	450	18	F
+Matheusn	200	16	M
+Leonardo	3200	58	M
+Camilan	160	16	F	
+Bianca	400	19	F
+fim
+Laisn	250	18	F
+Juliano	450	17	M
+Andren	7800	21	M
+Carlan	490	25	F
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_05.txt

+Alexandre	1500	12	M
+fim
+Caroline	650	45	F
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_06.txt

+Lucas	10	15	M
+Luciana	10	21	F
+Leticia	10	16	F
+Altivo	10	17	M
+fim
+Luana	10	20	F
+Alice	10	15	F
+Alan	10	40	M
+fim
+Leonardo	10	24	M
+Luan	10	25	M
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_07.txt

+Breno	800	26	M
+Leonardo	650	35	M
+Diego	350	40	M
+Paula	1500	14	F
+Georgia	630	42	F
+fim
+Viviane	1500	23	F
+Lauriane	600	36	F
+Karla	630	48	F
+Altivo	3500	24	M
+Ameriana	3500	21	F
+fim
+Joquebeyde	3562	20	F
+Bruna	2500	65	F
+Alexandre	6320	45	M
+Edgard	650	23	M
+Francisco	4520	18	M
+Francis	3620	19	M
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_08.txt

+Caio	200	12	M
+Alicia	450	12	F
+Marcela	500	17	F
+Camila	120	13	F
+fim
+Lucia	450	18	F
+Leticia	400	19	F
+Cecilia	5000	20	F
+Celina	100	19	F
+Luco	200	25	M
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_09.txt

+Joque	3562	20	F
+Brunaq	2500	65	F
+Alexandreq	6320	45	M
+Edgardq	650	23	M
+Franciscoq	4520	18	M
+Francisq	3620	19	M
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_10.txt

+Altivos	400	17	M
+Amerianats	500	12	F
+tFranciscos	500	16	M
+Brunsat	200	15	F
+fim
+tttttDiogots	200	18	M
+Joquets	500	20	F
+fim
+Mastticont	500	17	M
+Agtnusm	100	19	M
+Vanetssa	200	16	F
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_11.txt

+sTais	200	15	F
+Btnas	100	17	F
+Sisast	250	18	M
+fim
+Taisssssssssss	200	15	F
+Bttttttnass	100	17	F
+Ssssssssssssitatttttt	250	18	M
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_12.txt

+m	40	12	F
+km	20	15	M
+am	55	80	F
+wnm	70	19	m
+fim
+e	100	40	f
+x	100	45	m
+t	45	20	f
+p	20	12	f
+fim
+j	40	17	f
+g	60	40	m
+f	120	38	f
+fim
+fimreparticoes

File linguagem_c/trabalho_tp_ifes_3/resolucao/entrada_ordenada_02.txt

+Maria	500.00	18	F
+Carlos	800.00	45	M
+Alexandre	1500.00	12	M
+fim
+Caroline	650.00	45	F
+fim
+Francisco	1200.00	15	M
+Franceyla	658.00	56	F
+fim

File linguagem_c/trabalho_tp_ifes_3/resolucao/funcoes/funcoes.cpp

+#include "stdafx.h"
+#include "funcoes.h"
+#include "../chars/chars.h"
+#include <string.h>
+#include <stdlib.h>
+
+/*===============================================================================
+Fun��o: LerDados
+	L� os dados de todos os funcion�rios de uma reparti��o
+Par�metros: O ponteiro para o arquivo e a reparti��o.
+================================================================================*/
+void LerDados (FILE *arq, Rep *reparticao)
+{
+	Func *funcionario;
+	funcionario = (Func *)malloc(sizeof(Func));
+	fscanf(arq, "%s", funcionario->nome);
+	while ((strcmp(funcionario->nome, "fim")) && (strcmp(funcionario->nome, "fimreparticoes")))
+	{
+		fscanf(arq, "%f", &funcionario->salario);
+		fscanf(arq, "%i", &funcionario->idade);
+		fscanf(arq, "%s", funcionario->sexo);
+		AddFuncionario(reparticao, funcionario);
+		funcionario = (Func *)malloc(sizeof(Func));
+		fscanf(arq, "%s", funcionario->nome);
+	}
+}
+
+/*===============================================================================
+Fun��o: EhVogal
+	Verifica se um caracter � vogal
+Par�metros: O caracter a ser verificado.
+Retorno: 1 Se o carcter for vogal, 0 se n�o for.
+================================================================================*/
+int EhVogal(char letra)
+{
+	letra = ParaMinusculo(letra);
+	return ((letra == 'a') || (letra == 'e') || (letra == 'i') || (letra == 'o') || (letra == 'u'));
+}
+
+/*===============================================================================
+Fun��o: contaLetra
+	Conta em uma lista de funcion�rios quantas vezes uma letra informada aparece
+	nos nomes dos funcion�rios. Caso a letra n�o apare�a em algum dos nomes, a
+	fun��o para de contar.
+Par�metros: A lista de funcion�rios e a letra a ser buscada
+Retorno: Se a letra aparecer em todos os nomes, retorna a quantidade de vezes
+		 que a letra apareceu. Caso contr�rio, retorna 0.
+================================================================================*/
+int contaLetra(Rep *reparticao, char letra)
+{
+	int cont, total = 0;
+	int j=0, tam_nome;
+	char *nome;
+	PrimLista(reparticao->ls);
+	while (MarcDef(reparticao->ls))
+	{
+		cont = 0;
+		nome = NomeFuncionario(reparticao);
+		tam_nome = strlen(nome);
+		for (j = 0; j < tam_nome; j++)	
+			if (!EhVogal(nome[j]))
+				if (ParaMinusculo(nome[j]) == ParaMinusculo(letra))
+					cont++;
+		if (!cont)
+			return 0;
+		total += cont;
+		PosLista(reparticao->ls);
+	}
+	return total;
+}
+
+/*===============================================================================
+Fun��o: asciiMaisComum
+	Determina qual caracter ascii n�o-vogal mais aparece em uma lista de
+	reparti��es, ou seja, todos os funcion�rios.
+Par�metros: A lista de reparti��es
+Retorno: O caracter ascii n�o-vogal que mais aparecer (desde que apare�a em todos
+		 os nomes), caso a condi��o de aparecer n�o seja satisfeita, a fun��o
+		 retorna 'a'
+================================================================================*/
+char asciiMaisComum(Reps *reparticoes)
+{
+	char *nome;
+	char resposta = 'a';
+	int quant, quant_Total;
+	int i, tam_nome, parar;
+	int maior = 0;
+	Rep *lista_funcionario;
+
+	PrimLista(reparticoes->l_repart);
+	lista_funcionario = InfoReparticao(reparticoes);
+	PrimLista(lista_funcionario->ls);
+	nome = NomeFuncionario(lista_funcionario);
+	tam_nome = strlen(nome);
+	for (i = 0; i < tam_nome; i++)
+	{
+		quant_Total = 0;
+		parar = 0;
+		if (!EhVogal(nome[i]))
+		{
+			PrimLista(reparticoes->l_repart);
+			while ((MarcDef(reparticoes->l_repart)) && (!(parar)))
+			{
+				lista_funcionario = InfoReparticao(reparticoes);
+				quant = contaLetra(lista_funcionario, nome[i]);
+				if (quant)
+					quant_Total += quant;
+				else
+				{
+					quant_Total = 0;
+					parar = 1;
+				}
+				PosLista(reparticoes->l_repart);
+			}
+		}
+		if (quant_Total > maior)
+		{
+			maior = quant_Total;
+			resposta = nome[i];
+		}
+	}
+
+	return (ParaMinusculo(resposta));
+}
+
+/*===============================================================================
+Fun��o: MaiorSalario
+	Percorre uma reparti��o e determina o maior sal�rio
+Par�metros: A reparti��o
+Retorno: O maior sal�rio encontrado.
+================================================================================*/
+float MaiorSalario (Rep *reparticao)
+{
+	if (reparticao == NULL)
+		return 0.0;
+	float maior = 0;
+	PrimLista(reparticao->ls);
+	while (MarcDef(reparticao->ls))
+	{
+		if (SalarioFuncionario(reparticao) > maior)
+			maior = SalarioFuncionario(reparticao);
+		PosLista(reparticao->ls);
+	}
+
+	return maior;
+}
+
+/*===============================================================================
+Fun��o: MenorSalario
+	Percorre uma reparti��o e determina o menor sal�rio
+Par�metros: A reparti��o.
+Retorno: O menor sal�rio encontrado.
+================================================================================*/
+float MenorSalario (Rep *reparticao)
+{
+	if (reparticao == NULL)
+		return 0.0;
+	PrimLista(reparticao->ls);
+	float menor = SalarioFuncionario(reparticao);
+	PosLista(reparticao->ls);
+	while(MarcDef(reparticao->ls))
+	{
+		if (SalarioFuncionario(reparticao) < menor)
+			menor = SalarioFuncionario(reparticao);
+		PosLista(reparticao->ls);
+	}
+
+	return menor;
+}
+/*===============================================================================
+Fun��o: SomaSalarios
+	Percorre uma reparti��o somando todos os sal�rios.
+Par�metros: A reparti��o.
+Retorno: A soma de todos os sal�rios.
+================================================================================*/
+float SomaSalarios (Rep *reparticao)
+{
+	if (reparticao == NULL)
+		return 0.0;
+	float soma = 0;
+	PrimLista(reparticao->ls);
+	while(MarcDef(reparticao->ls))
+	{
+		soma += SalarioFuncionario(reparticao);
+		PosLista(reparticao->ls);
+	}
+	
+	return soma;
+}
+/*===============================================================================
+Fun��o: DeMenor
+	Percorre uma reparticao e informa quantos funcion�rios do sexo
+	informado s�o menores de idade
+Par�metros: Uma reparti��o e o sexo a comparar
+Retorno: A quantidade de funcion�rios do sexo 'sexo' com menos de 18 anos
+================================================================================*/
+int DeMenor (Rep *reparticao, char sexo)
+{
+	if (reparticao == NULL)
+		return 0;
+	if ((sexo != 'M') && (sexo != 'F'))
+		return 0;
+	int cont = 0;
+	PrimLista(reparticao->ls);
+	while (MarcDef(reparticao->ls))
+	{
+		if ((SexoFuncionario(reparticao) == sexo) && (IdadeFuncionario(reparticao) < 18))
+			cont++;
+		PosLista(reparticao->ls);
+	}
+
+	return cont;
+}
+
+
+/*===============================================================================
+Fun��o: QuantFuncMaiorSalario
+	Percorre uma reparti��o comparando e contando quantos sal�rios s�o maiores
+	do que um sal�rio informado (por par�metro)
+Par�metros: Uma reparti��o e o sal�rio a comparar
+Retorno: A quantidade de funcion�rios que tem o sal�rio maior do que o informado
+================================================================================*/
+int QuantFuncMaiorSalario(Rep *reparticao, float sal)
+{
+	if (reparticao == NULL)
+		return 0;
+	int cont = 0;
+	PrimLista(reparticao->ls);
+	while (MarcDef(reparticao->ls))
+	{
+		if (SalarioFuncionario(reparticao) > sal)
+			cont++;
+		PosLista(reparticao->ls);
+	}
+
+	return cont;
+}

File linguagem_c/trabalho_tp_ifes_3/resolucao/funcoes/funcoes.h

+#include "../ListaReparts/ListaReparts.h"
+
+void LerDados (FILE *arq, Rep *reparticao);
+int EhVogal(char letra);
+int contaLetra(Rep *reparticao, char letra);
+char asciiMaisComum(Reps *reparticoes);
+float MaiorSalario (Rep *reparticao);
+float MenorSalario (Rep *reparticao);
+float SomaSalarios (Rep *reparticao);
+int DeMenor (Rep *reparticao, char sexo);
+int QuantFuncMaiorSalario(Rep *reparticao, float sal);

File linguagem_c/trabalho_tp_ifes_3/resolucao/main.cpp

+	/* 
+		CEFETES
+		T�cnicas de Programa��o, trabalho 3.
+			Bruna Arruda Contarine
+			Francisco Ant�nio da Silva Souza
+	*/
+
+#include "stdafx.h"
+#include "funcoes/funcoes.h"
+#include "arquivo/arquivo.h"
+#include "aloca/aloca.h"
+#include "auxiliar/auxiliar.h"
+#include "arquivo/arquivo.h"
+#include "desaloca/desaloca.h"
+#include "chars/chars.h"
+#include <string.h>
+#include <stdlib.h>
+
+
+int main(void)
+{
+	/* Gerando o nome de arquivo a ser aberto para leitura
+	   e do arquivo a ser criado ao fim de algoritmo */
+
+	char *nm_arq_entrada, *nm_arq_saida;
+	nm_arq_entrada = alocaVetChar(16);
+	nm_arq_saida = alocaVetChar(14);
+	printf ("\t\t\tTRABALHO 3 DE TECNICAS\n");
+	printf ("\t\t      Autores: Bruna e Francisco.\n");
+	GeraNomeArquivos(&nm_arq_entrada, &nm_arq_saida);
+
+	/* Abrindo arquivo de entrada para leitura */
+	FILE *arquivoEntrada;
+	AbreArquivoLeitura(&arquivoEntrada, nm_arq_entrada);
+
+	/* Abrindo o arquivo de sa�da para escrita do resultado */
+	FILE *arquivoSaida;
+	AbreArquivoGravacao(&arquivoSaida, nm_arq_saida);
+
+	/* Fazendo a leitura de todas as parti��es. */
+	char nome[20];
+	int fim = 0;
+
+	Reps *reparticoes;
+	reparticoes = (Reps *)malloc(sizeof(Reps));
+	InicReparticoes(reparticoes);
+	
+	Rep *reparticao;
+	do
+	{
+		reparticao = (Rep *)malloc(sizeof(Rep));
+		InicReparticao(reparticao);
+		LerDados(arquivoEntrada, reparticao);
+		if (ReparticaoVazia(reparticao))
+		{
+			fprintf(arquivoSaida, "Dados insuficientes, verifique o conte�do do seu arquivo \"%s\"", nm_arq_entrada);
+			exit(1);
+		}
+
+		AddReparticao(reparticoes, reparticao);
+		fscanf(arquivoEntrada, "%s", nome);
+		if (!strcmp(nome, "fimreparticoes"))
+			fim = 1;
+		else
+			fseek(arquivoEntrada, -(strlen(nome)), SEEK_CUR);
+	} while (!fim);
+
+	/* Gerando e escrevendo os dados do arquivo de sa�da */
+	float maiorSal, maiorTotal;
+	float menorSal, menorTotal;
+	/* Letra A e B */
+	PrimLista (reparticoes->l_repart);
+	reparticao = InfoReparticao(reparticoes);
+	maiorTotal = MaiorSalario(reparticao);
+	menorTotal = MenorSalario(reparticao);
+	PosLista(reparticoes->l_repart);
+	while (MarcDef(reparticoes->l_repart))
+	{
+		reparticao = InfoReparticao(reparticoes);
+		maiorSal = MaiorSalario(reparticao);	
+		if (maiorSal > maiorTotal)
+			maiorTotal = maiorSal;
+
+		menorSal = MenorSalario(reparticao);
+		if (menorSal < menorTotal)
+			menorTotal = menorSal;		
+