ED - 2014/07/18

/*
        APENAS TESTEI A PARTE I POR QUESTOES ÓBVIAS...

        O RESTO ESTÁ COMO EU FARIA DURANTE O EXAME.

        MESMO QUE HAJA ERROS OU ELES IGNORAM OU DESCONTAM APENAS UMAS DECIMAS
        HÁ ERROS QUE SÓ SE DÃO CONTA DURANTE TESTES.
        NAO VOU ESTAR A CRIAR UM FICHEIRO NOVO PARA TESTAR AS FUNÇOES DAS LISTAS
        NEM A CRIAR UMA ARVORE PARA TESTAR ISTO...

        TODAS AS SOLUÇÕES NAO SAO UNICAS. HÁ VARIAS FORMAS DE FAZER A MESMA TRETA
*/

#include <stdio.h>
#include <ctype.h>
#include <malloc.h>
#include <string.h>

//PARTE I
//1
void escreveVectorInt(int *vector, int n)
{
    if(vector == NULL)
        return;

    for(int i=0; i<n; i++)
        printf("Indice %d = %d\n", i, vector[i]);
}

//2 - Recursivo
float SumRec(int n, int x, int i=1, int fact = 1)
{
    fact *= (x-1);
    if(i == n)
        return fact/i;
    return fact/i + SumRec(n,x,i+1,fact);
}

//2 - Iterativo
float SumIt(int n, int x)
{
    int fact=1;
    float sum = 0;

    for(int i=1; i<=n; i++)
    {
        fact *= (x-1);
        sum+=fact/i;
    }

    return sum;
}

//3
char *MinMaiu(char *src)
{
    int i=0;
    bool mai = true;
    char *t = (char*)malloc(sizeof(char) * strlen(src)+1);
    while(src[i] != '\0')
    {
        if(src[i] < 'A' || (src[i] > 'Z' && src[i] < 'a') || src[i] > 'z')
            t[i] = src[i];
        else if(mai)
        {
            t[i] = toupper(src[i]);
            mai = false;
        }
        else
        {
            t[i] = tolower(src[i]);
            mai = true;
        }
        i++;
    }
    t[i] = '\0';
    return t;
}
//3 - Sem tolower/toupper
char *MinMaiuS(char *src)
{
    int i=0;
    bool mai = true;
    char *t = (char*)malloc(sizeof(char) * strlen(src)+1);

    while(src[i] != '\0')
    {
        if(mai && src[i] >= 'a' && src[i] <= 'z')
        {
            t[i] = src[i] + 'A'-'a';
            mai = false;
        }
        else if(!mai && src[i] >= 'A' && src[i] <= 'Z')
        {

            t[i] = src[i] + 'a'-'A';
            mai = true;
        }
        else if(src[i] < 'A' || (src[i] > 'Z' && src[i] < 'a') || src[i] > 'z')
            t[i] = src[i];
        else
        {
            t[i] = src[i];
            mai = !mai;
        }
        i++;
    }
    t[i] = '\0';
    return t;
}

//PARTE II - NAO TESTADA (Basicamente era isto que faria no teste...)
typedef struct nozito
{
    Funcionario *Info;
    struct nozito *Prox;
}NO;
typedef struct lista
{
    char Nome[100];
    NO *Inicio;
}Lista;
//a
typedef struct
{
    char Nome[100];
    char cod[5];
    char especialidade[150];
    char morada[200];
    int idade;
}Funcionario;

Funcionario *CriarFunc(char *nome, char *codint, char *espec, char *mor, int idade)
{
    Funcionario *aux = (Funcionario *)malloc(sizeof(Funcionario));
    strcpy(aux->Nome, nome);
    strcpy(aux->cod, codint);
    strcpy(aux->especialidade, espec);
    strcpy(aux->morada, mor);
    aux->idade = idade;
    return aux;
}

//b
void LerFicheiroFunc(Lista *L, char *nficheiro)
{
    if(L == NULL)
    {
        L = (Lista *)malloc(sizeof(Lista));
        strcpy(L->Nome, "Funcionários");
        L->Inicio = NULL;
    }
    NO *no = L->Inicio;
    NO *noaux = NULL;
    Funcionario *func = NULL;
    char nome[100];
    char cod[5];
    char esp[150];
    char morada[200];
    int idade;
    FILE *f = fopen(nficheiro,"r");

    //Ha varias formas de fazer o seguinte...

    char buffer[500];
    while(fgets(buffer,sizeof buffer, f))
    {
        sscanf(buffer, "%s%s%s%s%d",nome,cod,esp,morada,&idade);
        func = CriarFunc(nome,cod,esp,morada,idade);
        noaux = (NO *)malloc(sizeof(NO));
        noaux->Prox = NULL;
        noaux->Info = func;

        if(no == NULL)
        {
            L->Inicio = noaux;
            no = L->Inicio;
            continue;
        }

        while(no->Prox != NULL)
            no=no->Prox;

        no->Prox = noaux;
        no = no->Prox;
    }
    fclose(f);
}

//c
int ContarMaioresIdade(Lista *L)
{
    NO *aux = L->Inicio;
    int count = 0;
    while(aux)
    {
        if(aux->Info->idade >= 18) // ou > 18 nao sei...
            count++;
        aux=aux->Prox;
    }
    return count;
}

//d
void Inverter(Lista *L)
{
    NO *aux = L->Inicio;
    NO *aux2 = NULL;
    NO *aux3;

    while(aux)
    {
        aux3 = aux->Prox;
        aux->Prox = aux2;
        aux2 = aux;
        aux = aux3;
    }
}

//PARTE III
//a
typedef struct folha
{
    struct folha *esq;
    struct folha *dir;
    Funcionario *info;
}FOLHA;
typedef struct
{
    FOLHA *Topo;
}ArvoreBin;

//b
void ColFolLis(Lista *L, FOLHA *f)
{
    if(f->esq)
        ColFolLis(L,f->esq);
    if(f->dir)
        ColFolLis(L,f->dir);
    NO *aux = (NO *)malloc(sizeof(NO));
    aux->Prox = NULL;
    aux->Info = f->info;

    if(L == NULL)
    {
        L = (Lista *)malloc(sizeof(Lista));
        L->Inicio = NULL;
        strcpy(L->Nome,"Funcionários");
    }

    if(L->Inicio == NULL)
    {
        L->Inicio = aux;
        return;
    }

    aux->Prox = L->Inicio;
    L->Inicio = aux;
}
void ColocarFolhasLista(Lista *L, ArvoreBin *A)
{
    ColFolLis(L,A->Topo);
}

//c
void TrocarFolhas(FOLHA *f)
{
    if(!f)
        return;

    TrocarFolhas(f->esq);
    TrocarFolhas(f->dir);

    FOLHA *aux = f->esq;
    f->esq = f->dir;
    f->dir = aux;
}
void TrocarArvore(ArvoreBin *A)
{
    TrocarFolhas(A->Topo);
}

void main()
{
    int vector[] = {1,2,4,8,16};
    escreveVectorInt(vector,5);
    printf("\n\nSumatorio:\nRecursivo: %f\nIterativo: %f",SumRec(5,10),SumIt(5,10));
    printf("\nNova frase: %s\n", MinMaiuS("ola PESSOAL"));
}