ED - Exame 2015

//PARTE I
//a
char *my_strrchr(char *str,char c)
{
    if(!str)
        return NULL;
    char *aux=NULL;
    while(*str != '\0')
    {
        if(*str == c)
            aux = str;
        str++;
    }
    return aux;
}
//b
int ContarPalavras(char *n_ficheiro, char *pal)
{
    int x = strlen(pal), tot=0;
    char *pal_inv = (char*)malloc(sizeof(char)*x+1);
    char *buf = (char*)malloc(sizeof(char)*150);
    char *buffer = (char*)malloc(sizeof(char)*150);
    FILE *f = fopen(n_ficheiro,"r");
    if(!f)
        return 0;
    for(int i=0; i<x; i++)
        pal_inv[x-i-1] = pal[i];
    pal_inv[x] = '\0';

    while(fgets(buf,150,f))
    {
        buffer=buf;
        buffer = strstr(buffer,pal);
        while(buffer != NULL)
        {
            tot++;
            buffer+=x;
            buffer = strstr(buffer,pal);
        }
        buffer=buf;
        buffer = strstr(buffer,pal_inv);
        while(buffer != NULL)
        {
            tot++;
            buffer+=x;
            buffer = strstr(buffer,pal_inv);
        }
    }

    fclose(f);
    return tot;
}
//PARTE II
#define MAXNOTAS 20
//a
typedef struct dados
{
    int num;
    char *nome_disciplina;
    float nota;
}DADOS;
typedef struct listano
{
    DADOS *info;
    struct listano *prox;
}ListaNO;
typedef struct lista
{
    ListaNO *Hash[MAXNOTAS];
    int nel;
}Hashing;

int FHashing(float nota)
{
    return (int)nota;
}

//b
void AddHashing(Hashing *H, int n_aluno, char *disciplina, float nota)
{
    int indice = FHashing(nota);
    DADOS *Nal = (DADOS *)malloc(sizeof(DADOS));
    Nal->nome_disciplina = (char *)malloc(sizeof(char) * strlen(disciplina)+1);
    strcpy(Nal->nome_disciplina,disciplina);
    Nal->nota = nota;
    Nal->num = n_aluno;
    ListaNO *novo = (ListaNO *)malloc(sizeof(ListaNO));
    novo->info = Nal;
    novo->prox = NULL;
    ListaNO *ax = H->Hash[indice];

    if(!ax)
    {
        H->Hash[indice] = novo;
        H->nel++;
        return;
    }

    while(ax->prox)
        ax = ax->prox;
    ax->prox = novo;
    H->nel++;
}
//c
float MediaAluno(Hashing *H, int n_aluno)
{
    float sum=0;
    int count=0;
    ListaNO *ax;
    for(int i=0; i<MAXNOTAS; i++)
    {
        ax = H->Hash[i];
        while(ax)
        {
            if(ax->info->num == n_aluno)
            {
                sum+=ax->info->nota;
                count++;
            }
            ax = ax->prox;
        }
    }
    if(count == 0)
        return -1;
    return sum/count;
}
//d
int AprovadosNaDisciplina(Hashing *H, char *disciplina)
{
    int quant=0;
    bool encontrada=false;
    ListaNO *ax;

    for(int i=0; i<MAXNOTAS; i++)
    {
        ax = H->Hash[i];
        while(ax)
        {
            if(stricmp(ax->info->nome_disciplina,disciplina) == 0)
            {
                if(!encontrada)
                    encontrada = true;
                if(i>=10)
                    quant++;
                if(i<10 && encontrada)
                {
                    i=10;
                    break;
                }
            }
            ax = ax->prox;
        }
    }
    if(!encontrada)
        return -1;
    return quant;
}

//PARTE III
typedef struct no
{
    ListaAlunos *Lista;
    char *nome_disciplina;
    struct no *esq, *dir;
}NO;
typedef struct arv_bin
{
    int NElementos;
    NO *Ramo;
}Arv_Bin;
//a
struct aux
{
    int nel;
    char *c;
};
struct aux *ProcuraMaisAlunos(NO *n, struct aux *a = NULL)
{
    if(!a)
    {
        a = (struct aux *)malloc(sizeof(struct aux));
        a->c = n->nome_disciplina;
        a->nel = n->Lista->nelem;
    }
    else if(n->Lista->nelem > a->nel)
    {
        a->c = n->nome_disciplina;
        a->nel = n->Lista->nelem;
    }
    if(n->esq)
        a=ProcuraMaisAlunos(n->esq,a);
    if(n->dir)
        a=ProcuraMaisAlunos(n->dir,a);
    return a;
}
char *MaisAlunos(Arv_Bin *A)
{
    struct aux *ax = ProcuraMaisAlunos(A->Ramo);
    if(ax)
        return ax->c;
    return NULL;
}
//b
//contar o numero de avaliaçoes? O numero de folhas é isso? Nao da para perceber bem
int ContarAvalNO(NO *r, int count=0)
{
    count+=r->Lista->nelem;
    if(r->esq)
        count=ContarAvalNO(r->esq,count);
    if(r->dir)
        count=ContarAvalNO(r->dir,count);
    return count;
}
int ContarAval(Arv_Bin *a)
{
    return ContarAvalNO(a->Ramo);
}
//c
void MultiPonto(NO *n, float perc)
{
    ListaNO *ax = n->Lista->prim;
    while(ax)
    {
        ax->info->nota *= perc;
        ax = ax->prox;
    }
    if(n->esq)
        MultiPonto(n->esq, perc);
    if(n->dir)
        MultiPonto(n->dir,perc);
}
void AumentarPonto(Arv_Bin *A, float perc)
{
    MultiPonto(A->Ramo,perc+1); //perc+1 para ser por exemplo 1.05 para fazer apenas a multiplicação
}
//d
struct med
{
    float sum;
    int quant;
};
struct med *Media(NO *n, int n_aluno, struct med *m = NULL)
{
    if(!m)
    {
        m = (struct med *)malloc(sizeof(struct med));
        m->sum = 0;
        m->quant = 0;
    }
    ListaNO *ax = n->Lista->prim;
    while(ax)
    {
        if(ax->info->num == n_aluno)
        {
            m->sum+=ax->info->nota;
            m->quant++;
            break;
        }
        ax = ax->prox;
    }
    if(n->esq)
        m=Media(n->esq, n_aluno,m);
    if(n->dir)
        m=Media(n->dir, n_aluno,m);
    return m;
}
float MAluno(Arv_Bin *A, int n_aluno)
{
    struct med *ax = Media(A->Ramo,n_aluno);
    if(ax->quant == 0)
        return -1;
    return ax->sum/ax->quant;
}