Settembre 2016

/*
ESAME DI PROGRAMMAZIONE 1
16-09-2016

Il seguente codice crea un file ("archivio") costituito da una sequenza di strutture
che hanno un campo stringa "nome" e un array "numeri" (array di 6 reali).
Il campo "nome" e' la label di un possibile triangolo, mentre l'array "numeri" contiene
nell'ordine ascissa e ordinata di tre punti del piano cartesiano che potrebbero essere i
vertici di un triangolo.

Si richiede la generazione di un nuovo file ("finale") in cui le strutture abbiano i seguenti campi:

char nome[STRINGALEN+1]
float numeri[6];
float area;
float perimetro;

1) il campo "nome" contiene il campo "nome" del file in ingresso con i caratteri tramutati in
   maiuscolo;
2) il campo "numeri" contiene l'array "numeri" del file in ingresso;
3) i campi "area" e "perimetro" devono contenere, rispettivamente, l'area e il perimetro
   dell'eventuale triangolo individuato dai vertici le cui coordinate stanno in "numeri",
   i valori "-1" e "-1" se i 6 numeri non caratterizzano le coordinate dei vertici di un triangolo.

Il file "finale" deve risultare ordinato rispetto al campo "nome".

NOTA: per verificare che tre punti A, B, C siano i vertici di un triangolo si puo'
      controllare se la distanza tra due punti qualsiasi e' minore della somma delle
      distanze del primo e del secondo punto dal terzo, cioè
      (AC < AB + BC; AB < AC + CB; BC < BA + AC).
      Per calcolare l'area di un triangolo si puo' usare la formula di Erone:
      area = radice quadrata di p*(p-a)*(p-b)*(p-c),
      dove a, b, c sono le misure dei tre lati, e p il semiperimetro.
*/


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
#include <string.h>
#include <math.h>

#define ARRLEN 6
#define MAXREC 300
#define STRINGALEN 20

typedef
  struct
  {
    char nome[STRINGALEN+1]; // 1 carattere in piu' per \0
    int numeri[ARRLEN];
  }
  t_dato;

typedef
    struct dato
    {
        char nome[STRINGALEN+1];
        float numeri[6];
        float area;
        float perimetro;
    } t_datofinale;

typedef
    struct punto
    {
        float x;
        float y;
    }t_punto;

typedef
    struct lista
    {
        t_datofinale elemento;
        struct lista *prox;
    }t_lista;

void prepara_archivio(void);
void elabora_struttura(t_dato*, t_datofinale*);
void elabora_nome(char*, char*, int);
void elabora_numeri(int* array1, float* array2, int dim_array);
void calcola_area(t_datofinale* elaborato, int dim_array);
int verifica_triangolo(t_datofinale* da_controllare, int dim_array);
float distanza_punti(t_punto* a, t_punto* b);
int in_lista(t_lista**, t_datofinale);

int main()
{
    FILE *a, *f;
    t_dato da_elaborare;
    t_datofinale elaborato;
    t_lista *p;

    prepara_archivio();
    if((a = fopen("archivio", "rb")))
    {
        while(!feof(a))
        {
            fread(&da_elaborare, sizeof(t_dato), 1, a);
            elabora_struttura(&da_elaborare, &elaborato);
            in_lista(&p, elaborato);
        }
        fclose(a);
    }
    else
    {
        printf("Errore nell'apertura del file archivio\n");
        return -1;
    }
    //scriviamo il file
    if((f = fopen("finale", "wb")))
    {
        while(p)
        {
            fwrite(&(p->elemento), sizeof(t_datofinale), 1, f);
            p = p->prox;
        }
        fclose(f);
    }
    else
    {
        printf("Errore nell'apertura del file finale.\n");
        return -1;
    }
    return 0;
}

//Funzioni

void prepara_archivio(void)
{
    FILE *f;
    t_dato x;
    int i,k,n;//temp
    srand(time(0));
    n = MAXREC + rand() % MAXREC;
    if ((f = fopen("archivio","wb")))
    {
        for (k = 0; k < n; k++)
        {
            for (i=0; i<ARRLEN; i++)
                x.numeri[i] = (rand()%10000)/55.66;
            for (i=0;i < STRINGALEN; i++)
                x.nome[i]= 97 + rand()%26;
            x.nome[STRINGALEN]='\0';
            fwrite(&x,sizeof(t_dato),1,f);
        }
        fclose(f);
    }
    else
        printf("Errore nell'apertura del file.\n");
}

void elabora_struttura(t_dato* iniziale, t_datofinale* finale)
{
    elabora_nome(iniziale->nome, finale->nome, STRINGALEN+1);
    elabora_numeri(iniziale->numeri, finale->numeri, ARRLEN);
    if((verifica_triangolo(finale, ARRLEN)));
    {
        calcola_area(finale, ARRLEN);
    }

}

void elabora_nome(char* array1, char* array2, int dim_array)
{
    //il campo "nome" contiene il campo "nome" del file in ingresso con i caratteri tramutati in maiuscolo;
    int i;

    for(i = 0; i < dim_array-1; i++)
    {
        //copia e conversione in maiuscolo
        array2[i] = toupper(array1[i]);
    }
    array2[dim_array] = '\0';
}

void elabora_numeri(int* array1, float* array2, int dim_array)
{
    //il campo "numeri" contiene l'array "numeri" del file in ingresso;
    int i;
    //copiamo l'array
    for(i = 0; i <= dim_array; i++)
    {
        array2[i] = array1[i];
    }
}

int verifica_triangolo(t_datofinale* da_controllare, int dim_array)
{
    /*
     * per verificare che tre punti A, B, C siano i vertici di un triangolo si puo'
      controllare se la distanza tra due punti qualsiasi e' minore della somma delle
      distanze del primo e del secondo punto dal terzo, cioè
      (AC < AB + BC; AB < AC + CB; BC < BA + AC).
      */
    int i;
    float distanza1, distanza2, distanza3;
    t_punto a, b, c;

    //assegnamento dei punti cartesiani
    for(i = 0; i < dim_array; i+=2)
    {
        if(i == 0)
        {
            a.x = da_controllare->numeri[i];
            a.y = da_controllare->numeri[i+1];
        }
        else if(i == 2)
        {
            b.x = da_controllare->numeri[i];
            b.y = da_controllare->numeri[i+1];
        }
        else if(i == 4)
        {
            c.x = da_controllare->numeri[i];
            c.y = da_controllare->numeri[i+1];
        }
    }
    distanza1 = distanza_punti(&a, &b);
    distanza2 = distanza_punti(&b, &c);
    distanza3 = distanza_punti(&a, &c);


    if(distanza1 < distanza2 + distanza3)
    {
        printf("Il triangolo è valido!\n");
        return 1;
    }
    else
    {
		printf("Il triangolo non è valido\n");
		return 0;
	}
}

float distanza_punti(t_punto* a, t_punto* b)
{
    float distanza, somma;

    somma = pow((b->x - a->x), 2) + pow((b->y - a->y), 2);
    distanza = sqrt(somma);
    return distanza;
}

void calcola_area(t_datofinale* elaborato, int dim_array)
{
    /*
     * Per calcolare l'area di un triangolo si puo' usare la formula di Erone:
      area = radice quadrata di p*(p-a)*(p-b)*(p-c),
      dove a, b, c sono le misure dei tre lati, e p il semiperimetro.*/
    int i;
    float semip;
    t_punto a, b, c;
    float ab, bc, ac; //lati triangolo

    for(i = 0; i <= dim_array; i+=2)
    {
        if(i == 0)
        {
            a.x = elaborato->numeri[i];
            a.y = elaborato->numeri[i+1];
        }
        else if(i == 2)
        {
            b.x = elaborato->numeri[i];
            b.y = elaborato->numeri[i+1];
        }
        else if(i == 4)
        {
            c.x = elaborato->numeri[i];
            c.y = elaborato->numeri[i+1];
        }
    }
    ab = distanza_punti(&a, &b);
    bc = distanza_punti(&b, &c);
    ac = distanza_punti(&a, &c);

    elaborato->perimetro = ab+bc+ac;
    semip = elaborato->perimetro/2.0;
    elaborato->area = sqrt(semip*(semip-ab)*(semip-bc)*(semip-ac));
}

int in_lista(t_lista**p, t_datofinale x)
{
    t_lista *temp, *prec, *corr;
    temp=(t_lista*) malloc(sizeof(t_lista));
    if(temp)
    {
        temp->elemento = x;
        temp->prox = NULL;
        if(*p)
        {
            prec = NULL;
            corr = *p;
            //scorri finchè corr esiste e il nome della lista è piu piccola dell'elemento
            while((corr) && (strcmp((corr->elemento).nome, x.nome) <= 0))
            {
                prec = corr;
                corr = corr->prox;
            }
            if(prec)
            {
                prec->prox = temp;
                temp->prox = corr;
            }
            else
            {
                temp->prox = *p;
                *p = temp;
            }
        }
        else
        {
            *p = temp;
        }
        return 0;
    }
    else
    {
        return 1;
    }
}