/* =============================================================== */
/*   CORSO DI PROGRAMMAZIONE IN C (C89)                            */
/*   Claudio Fornaro                                               */
/*   Ver. 3 - 2021                                                 */
/*   16-Struct_Soluzioni.txt                                       */
/* =============================================================== */


/* =============================================================== */
/*   1                                                             */
/* =============================================================== */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define NUMPUNTI 4

struct punto
{
    float x;
    float y;
};

int main()
{
    struct punto punti[NUMPUNTI];
    int i, j;
    float perimetro;
    float distmin, d;

    for (i=0; i < NUMPUNTI; i++)
    {
        printf("Punto %d, coordinate x e y (separate da spazio): ", i);
        scanf("%f%f", &punti[i].x, &punti[i].y);
    }

    /* calcolo lunghezza del perimetro */
    perimetro = 0.0;
    for (i=0; i<NUMPUNTI; i++)
    {
        j = (i+1)%NUMPUNTI; /* vale i+1 per tutti i valori di i tranne 
                               l'ultimo per cui vale 0 */
        perimetro += sqrt( (punti[i].x-punti[j].x)*(punti[i].x-punti[j].x) +
                           (punti[i].y-punti[j].y)*(punti[i].y-punti[j].y) );
    }
    printf("Lunghezza perimetro: %f\n", perimetro);

    /* calcolo distanza minima tra due due punti qualsiasi del percorso */
    distmin = sqrt( (punti[0].x-punti[1].x)*(punti[0].x-punti[1].x) +
                    (punti[0].y-punti[1].y)*(punti[0].y-punti[1].y) );
    for (i=0; i<NUMPUNTI-1; i++)
        for (j=i+1; j<NUMPUNTI; j++)
        {
            d = sqrt( (punti[i].x-punti[j].x)*(punti[i].x-punti[j].x) +
                      (punti[i].y-punti[j].y)*(punti[i].y-punti[j].y) );
            if (d<distmin)
                distmin = d;
        }
    printf("Distanza minima tra i punti: %f\n", distmin);

    return EXIT_SUCCESS;
}



/* ========================================================================== */
/*   2                                                                        */
/* ========================================================================== */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* dichiarata esternamente perche' sia visibile a tutte le funzioni */
struct poligono
{
   int nlati;
   double lato;
};

struct poligono creapoli(void);
double areapoli(struct poligono poli);
double perimpoli(struct poligono poli);
void doppiopoli(struct poligono *ppoli);

int main()
{   
   struct poligono poli1, poli2;
   
   poli1 = creapoli();

   printf("Il poligono 1 ha perimetro: %f e area %f\n", 
                                 perimpoli(poli1), areapoli(poli1));

   poli2=poli1;
   doppiopoli(&poli2);
   printf("Il poligono 2 ha perimetro: %f e area %f\n", 
                                 perimpoli(poli2), areapoli(poli2));

   return EXIT_SUCCESS;
}

struct poligono creapoli(void)
{
   struct poligono po;

   printf("Numero lati poligono: ");
   scanf("%d", &po.nlati);
   printf("Lunghezza lati: ");
   scanf("%lf", &po.lato);
   return po;
}

double areapoli(struct poligono poli)
{
   const double PI = 4.0 * atan(1.0);      /* pi greco */
   return (poli.nlati*poli.lato*poli.lato)/(4.0*tan(PI/poli.nlati));
}

double perimpoli(struct poligono poli)
{
   return poli.lato * poli.nlati;
}

void doppiopoli(struct poligono *ppoli)
{
   ppoli->lato *= 2;   /* equivalentemente: (*ppoli).lato *=2; */
}


/* ========================================================================== */
/*   3                                                                        */
/* ========================================================================== */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* definita esternamente perche' sia visibile a tutte le funzioni */
typedef struct poligono     /* il tag poligono puo' essere omesso */
{
   int nlati;
   double lato;
} Poligono;

Poligono creapoli(void);
double areapoli(Poligono poli);
double perimpoli(Poligono poli);
void doppiopoli(Poligono *ppoli);

int main()
{
   
   Poligono poli1, poli2;
   poli1 = creapoli();

   printf("Il poligono 1 ha perimetro: %f e area %f\n", perimpoli(poli1), areapoli(poli1));

   poli2=poli1;
   doppiopoli(&poli2);
   printf("Il poligono 2 ha perimetro: %f e area %f\n", perimpoli(poli2), areapoli(poli2));

   return EXIT_SUCCESS;
}

Poligono creapoli(void)
{
   Poligono po;

   printf("Numero lati poligono: ");
   scanf("%d", &po.nlati);
   printf("Lunghezza lati: ");
   scanf("%lf", &po.lato);
   return po;
}

double areapoli(Poligono poli)
{
   const double PI = 4.0 * atan(1.0);      /* pi greco */
   return (poli.nlati*poli.lato*poli.lato)/(4.0*tan(PI/poli.nlati));
}

double perimpoli(Poligono poli)
{
   return poli.lato * poli.nlati;
}

void doppiopoli(Poligono *ppoli)
{
   ppoli->lato *= 2;   /* equivalentemente: (*ppoli).lato *=2; */
}


/* =============================================================== */
/*   4                                                             */
/* =============================================================== */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXPERSONE 100
#define LUNGNOME 32

/* definizione esterna perche' sia visibile anche nel prototipo */
struct persona
{
   char nome[LUNGNOME];
   char cognome[LUNGNOME];
   int eta;
   int salario;
};

void ordina(struct persona pe[], int n);

int main()
{
   struct persona pers, persone[MAXPERSONE] = {"","",0,0};
   FILE *fp;
   char file[FILENAME_MAX];
   int i;
   int numPersone; /* numero di persone lette */
   

   printf("Nome del file da leggere: ");
   gets(file);
   if ((fp=fopen(file,"r")) == NULL)
   {
      fprintf(stderr, "Non posso aprire il file: %s\n", file);
      return EXIT_FAILURE;
   }

   i=0; 
   while (i<MAXPERSONE && 
          fscanf(fp, "%s%s%d%d", pers.nome, pers.cognome, 
                                 &pers.eta, &pers.salario) == 4) 
      persone[i++] = pers;

   if (!feof(fp))
      fprintf(stderr, "Ci sono piu' di %d righe (ignorate)\n",
                                                        MAXPERSONE);

   fclose(fp);
   numPersone = i; /* numero persone lette dal file */

   ordina(persone, numPersone);

   printf("Nome del file da scrivere: ");
   gets(file);
   if ((fp=fopen(file,"w")) == NULL)
   {
      fprintf(stderr, "Non posso aprire il file: %s\n", file);
      return EXIT_FAILURE;
   }

   for (i=0; i<numPersone; i++)
   {
      pers = persone[i];
      fprintf(fp, "%s %s %d %d\n", pers.nome, pers.cognome, 
                                   pers.eta, pers.salario);
   }

   fclose(fp);

   return EXIT_SUCCESS;
}

void ordina(struct persona pe[], int n)
{
   struct persona temp;
   int i, j, jmin;
   /* ordinamento selection sort con chiave il campo cognome */
   for (i=0; i<n-1; i++)
   {
      jmin = i;
      for (j=i+1; j<n; j++)
         if (strcmp(pe[j].cognome,pe[jmin].cognome) < 0)
            jmin = j;
         
      temp = pe[jmin];
      pe[jmin] = pe[i];
      pe[i] = temp;
   }

}

/* Note
   Si preferisce verificare se la fscanf() restituisce 4 e non EOF
    perche' EOF viene restituito solo se NESSUN elemento viene letto
    arrivando alla fine del file; se invece per qualche motivo (es.
    sono rimasti da 1 a 3 valori) vengono letti meno di 4 valori, 
    la fscanf() restituisce il numero di valori letti.
   La scanf() avrebbe potuto leggere i valori e collocarli subito
    nei membri:
    scanf(... persone[i].nome, persone[i].cognome, &persone[i].eta, 
                                                &persone[i].salario)
    ma usare una variabile intermedia e' piu' chiaro e veloce (non 
    deve calcolare ogni volta la posizione dell'elemento i del
    vettore)
*/