//FUNZIONI UTILI

//gcc -g -lm -o test test.c
//    debug math output



// valore assoluto
float valoreAssoluto(float x) {
  return x >= 0 ? x : -x;
}

// potenza
int potenza(int base, int esp) {
  int cont, prod = 1;
  for (cont = 0; cont < esp; cont++)
    prod *= base;
  return prod;
}

// radice quadrata
float radice(float a) {
  float x = 1.0;
  while (valoreAssoluto(x * x - a) > 1e-5)
    x = (x + a / x) / 2.0;
  return x;
}

#include <math.h>

float radq(float numero) {
  // restituisce un'approssimazione della radice quadrata
  // del parametro, calcolata con il metodo babilonese
  float x;
  x = 1.0;
  while (fabsf(x * x - numero) > 1e-5)
    x = (x + numero / x) / 2.0;
  return x;
}

// primo?

int primo(int n) {
  int i, potenzialmente_primo;
  potenzialmente_primo = n % 2 || n == 2;
  i = 3;
  while (potenzialmente_primo && i * i <= n) {
    if (n % i == 0)
      potenzialmente_primo = 0;
    i += 2;
  }
  return potenzialmente_primo; //1- primo 0- non primo
}

// mcm
int mcm(int a, int b){
    int p,d;
    if(a>b){
        p=a;
    }else{
        p=b;
    }
    d = p;
    while(d%a!=0 || d%b!=0){
        d +=p;
    }
    return d;
}
// divisori
int divisori(int n){
    int s = 0, i = 1;
    while(i*i<=n){
        if(n%i==0){
            s += 1;
            if(!(i*i == n)){
                s +=1;
            }
        }
        i++;
    }
    return s;
}

int bisestile(int anno) {
  // restituisce 1 se il parametro e` un anno bisestile,
  // 0 altrimenti
  if (anno % 400 == 0 || (anno % 4 == 0 && anno % 100 != 0))
    return 1;
  else
    return 0;
}

int giorni_del_mese(int mese, int anno) {
  // restituisce il numero di giorni
  // del mese primo parametro
  // nell'anno secondo parametro
  if (mese == 4 || mese == 6 || mese == 9 || mese == 11)
    return 30;
  else if (mese == 2)
    if (bisestile(anno))
      return 29;
    else
      return 28;
  else
    return 31;
}

// definizione della funzione massimo
int massimo(int a, int b) {
  if (a > b)
    return a;
  else
    return b;
}


// ordinamento  INSERTION SORT
#include <stdio.h>
#define DIM 5

int main(void) {
  int a[] = {4, 1, 8, 0, 5}, i, dl = 0;

  for (dl = 0; dl < DIM; dl++) {
    int j = dl, m = a[dl];
    while (j > 0 && m < a[j - 1]) {
      a[j] = a[j - 1];
      j--;
    }
    a[j] = m;
  }
  for (i = 0; i < DIM; i++)
    printf("%d ", a[i]);
  printf("\n");
}



/*****************************************************************************/
/*************    MIN MAX MEDIA SOMMA N DIVERSI FREQUENZA     ********************************/


#include <stdio.h>
#define DIM 100

int main() {
  int a[DIM], i, dl, somma;
  int numeri[DIM], frequenze[DIM];
  int dlf, ind_max_frequenza;
  int ind_min;
  i = 0;
  do {
    scanf("%d", &a[i]);
    i++;
  } while (a[i - 1] >= 0);
  dl = i - 1;

  // calcolo e stampa del minimo
  ind_min = 0;
  for (i = 1; i < dl; i++)
    if (a[i] < a[ind_min])
      ind_min = i;
  // ind_min è l'indice dell'elemento minimo
  printf("Minimo: %d\n", a[ind_min]);

  // calcolo e stampa del massimo

  // calcolo e stampa della media
  // calcolo somma (Reduce)
  somma = 0;
  for (i = 0; i < dl; i++)
    somma = somma + a[i];
  // somma contiene la somma di tutti gli elementi dell'array
  printf("Media: %.2f\n", (float)somma / dl);

  //
  dlf = 0;  // numero di numeri diversi trovati
  for (i = 0; i < dl; i++) {
    int j;
    for (j = 0; j < dlf; j++)
      if (a[i] == numeri[j]) {
        frequenze[j]++;
        break;
      }
    if (j == dlf) {
      numeri[j] = a[i];
      frequenze[j] = 1;
      dlf++;
    }
  }

  ind_max_frequenza = 0;
  for (i = 1; i < dlf; i++)
    if (frequenze[i] > frequenze[ind_max_frequenza])
      ind_max_frequenza = i;

  //  frequenze[ind_max_frequenza] è la frequenza massima
  printf("Numeri più frequenti: ");
  for (i = 0; i < dlf; i++)
    if (frequenze[i] == frequenze[ind_max_frequenza])
      printf("%d ", numeri[i]);
  printf("\n");

  //   // ForEach stampa
  //   for (i = 0; i < dl; i++)
  //     printf("%d ", a[i]);
  //   printf("\n");
}
/*****************************************************************************/
/*************    ANAGRAMMA     ********************************/

#include <stdio.h>
#define DIM 30

int main() {
  char parola1[DIM], parola2[DIM];
  int frequenze1[26], frequenze2[26];
  int i;

  printf("Digita due parole\n");
  scanf("%s", parola1);
  scanf("%s", parola2);

  // ForEach inizializzazione a 0
  for (i = 0; i < 26; i++) {
    frequenze1[i] = 0;
    frequenze2[i] = 0;
  }

  // se parola1[0] è c
  // dobbiamo incrementare il terzo elemento di frequenze1
  // cioè quello di indice 2
  // 'a' = 97
  // 'b' = 98
  // 'c' = 99

  for (i = 0; parola1[i] != '\0'; i++)
    frequenze1[parola1[i] - 'a']++;

  for (i = 0; parola2[i] != '\0'; i++)
    frequenze2[parola2[i] - 'a']++;

  for (i = 0; i < 26; i++)
    if (frequenze1[i] != frequenze2[i])
      break;

  if (i==26)
    printf("Anagramma\n");
  else
    printf("Non anagramma\n");

  return 0;
}

//rand
#include <stdlib.h>
#include <time.h>

srand(time(NULL));
int r = min+rand()%(max-min+1);

int dado=1+rand()%6;

//BOOLEAN
typedef enum {false,true} Boolean;

//SWAP
void swap(int m, int n) {
  int t;
  t = m;
  m = n;
  n = t;
}
//SWAP PUNTATORI
//chiamata
swap (&a ,&b) ;
//funzione
void swap(int *pm, int *pn) {
  int t;
  t = *pm;
  *pm = *pn;
  *pn = t;
}

//AZZERA
void azzera(int *pa){
    *pa = 0;
}

//ARRAY->PUNTATORE
*(a+i) = a[i];

//PASSAGGIO DI UN ARRAY AD UNA FUNZIONE
somma(array);

int somma(int vettore[5])

//se serve la dimensione logica la calcolo con
sizeof(array)/sizeof(int)

//FILE TXT
    //APERTURA
    FILE* fp;
    fp = fopen("file.txt","wt");
    if(fp==NULL){
        printf("file non trovato");
        exit(-1);
    }
    //CHIUSURA
    if(fclose(fp)!=0){
        printf("Errore chiusura file\n");
        exit(-2);
    }
    //SCRITTURA
    fprintf(fp,"%s ",stringa);
    //LETTURA
    while(fscanf(fp,"%c",&carattere)==1)
        printf("%c",carattere);

//FILE BINARI
    //APERTURA
    FILE* fp;
    fp = fopen("file.txt","wt");
    if(fp==NULL){
        printf("file non trovato");
        exit(-1);
    }
    //CHIUSURA
    if(fclose(fp)!=0){
        printf("Errore chiusura file\n");
        exit(-2);
    }
    //SCRITTURA
    int vet[10];
    fwrite(vet,sizeof(int),10,fp);
    //LETTURA
    int vet[40], i, n;
    n = fread(vet,sizeof(int),40,fp);
    for (i=0; i<n; i++)
    printf("%d ",vet[i]);

    //CREA FILE DAT PERSONE
    #include <stdio.h>
    #include <stdlib.h>

    typedef struct{
        char cognome[30];
        char nome[30];
        char sesso;
        int anno_nascita;
    } Persona;

    Persona leggiPersona() {
      Persona p;
      char s[2];  // stringa ausiliaria
      scanf("%s%s%s%d", p.cognome, p.nome, s, &p.anno_nascita);
      p.sesso = s[0];
      return p;
    }

    int main(){
      FILE* fp;
      Persona p;
      int risposta;
      fp = fopen("persone.dat", "wb");
      if (fp == NULL) {
        printf("Errore apertura file\n");
        exit(2);
      }
      do {
        p = leggiPersona();
        fwrite(&p, sizeof(Persona), 1, fp);
        printf("Altra persona (1=si, 0=no)?");
        scanf("%d", &risposta);
      } while (risposta == 1);
      fclose(fp);
      return 0;
    }

    //LETTURA FILE PERSONE
    #include <stdio.h>
  #include <stdlib.h>
  #define DIM 1000

  typedef struct {
    char Cognome[30];
    char Nome[30];
    char gender;
    int anno;
  } Persona;

  int main() {
    Persona persone[DIM];
    FILE* fp;
    int dl, i;
    fp = fopen("persone.dat", "rb");
    if (fp == NULL) {
      printf("Errore apertura file\n");
      exit(1);
    }
    dl = fread(persone, sizeof(Persona), DIM, fp);
    fclose(fp);
    for (i = 0; i < dl; i++) {
      printf("%s %s %d %c\n", persone[i].Nome, persone[i].Cognome,
            persone[i].anno, persone[i].gender);
    }
    return 0;
  }

//ARGS
#include <stdio.h>

int main(int argc, char *argv[])
{
    int i = 0;
    printf("Numero di argomenti passati: %d\n",argc);
    for(i=0;i<argc;i++)
        printf("%s\t",argv[i]);
    return 0;
}

//MAKEFILE
prog: main.o file1.o file2.o file3.o
    gcc -o prog main.o file1.o file2.o file3.o

main.o: main.c file1.h file2.h
    gcc -c main.c

file1.o: file1.c file3.h
    gcc -c file1.c

file2.o: file2.c file3.h
    gcc -c file2.c

file3.o: file3.c
    gcc -c file3.c

//esempio
liste: main.o liste_sequenziali.o
    gcc -o liste main.o liste_sequenziali.o -lc

main.o: main.c liste_sequenziali.h
    gcc -c main.c

liste_sequenziali.o: liste_sequenziali.c liste_sequenziali.h
    gcc -c liste_sequenziali.c

//RICORSIONE fattoriale
  #include <stdio.h>
  int fact(int n)
  {
      if (n<=0)
      return 1;
      else
        return n*fact(n-1);
  }

  int main()
  {
      int fz, z = 5;
      fz = fact(z);
      printf("%d\n",fz);
  }

//LISTE FUNZIONI PRINCIPALI
  #define DIMENSIONE 100

  typedef struct {
    int n_elementi;
    int dati[DIMENSIONE];
  } Lista;

  void nuova_lista(Lista* pl) {
    *pl = NULL;
  }
void insTesta(Lista *l, Dato d) {
  Nodo* aux = (Nodo*)malloc(sizeof(Nodo));
  aux->dato = d;
  aux->next = *l;
  *l = aux;
}

  int vuota(Lista l){
      // e' vuota se la dimensione logica e' 0
      return l.n_elementi == 0;
  }
  int piena(Lista l){
      // e' piena se la dimensione logica e' pari alla dimensione massima
      return l.n_elementi == DIMENSIONE;
  }
  void inserimento_testa(Lista* pl, int numero) {
    int i;
    if (piena(*pl)) {
      // se la lista e' piena non posso inserire elementi
      printf("Errore: lista piena\n");
      exit(-1);
    }
    // faccio spazio per il nuovo numero spostando gli altri a destra
    for (i = pl->n_elementi; i > 0; i--)
      pl->dati[i] = pl->dati[i - 1];
    // inserisco il nuovo numero
    pl->dati[0] = numero;
    // incremento la dimensione logica
    pl->n_elementi++;
  }

  void inserimento_ordinato(Lista* pl, int numero) {
    int i;
    if (piena(*pl)) {
      // se la lista e' piena non posso inserire elementi
      printf("Errore: lista piena\n");
      exit(-1);
    }
    // sposto a destra tutti gli elementi della lista
    // maggiori del numero da inserire
    i = pl->n_elementi;
    while (i > 0 && pl->dati[i - 1] > numero) {
      pl->dati[i] = pl->dati[i - 1];
      i--;
    }
    // inserisco il numero
    pl->dati[i] = numero;
    // incremento la dimensione logica
    pl->n_elementi++;
  }

  Lista* ricerca(Lista* l, char nome[]){
    //Oltrepasso tutti i nodi che precedono quello da inserire o aggiornare
    while(*l)
    {
        if(strcmp(nome,(*l)->dato.nome) == 0)
            break;
      l = &(*l)->next;
    }
    return l;
  }

  void elimina(Lista* pl, int numero) {
    int i = 0;
    while (i < pl->n_elementi)  // scorro tutti gli elementi
    {
      // se ne trovo uno uguale al numero da eliminare...
      if (pl->dati[i] == numero) {
        int j;
        // sposto a sinistra tutti gli elementi che lo seguono
        for (j = i; j < pl->n_elementi - 1; j++)
          pl->dati[j] = pl->dati[j + 1];
        pl->n_elementi--;  // decremento la dimensione logica
      } else
        i++;
    }
  }

  int lunghezza(Lista l) {
    // Corrisponde alla dimensione logica della lista
    return l.n_elementi;
  }

  void stampa(Lista l) {
    while(l){
      printf("%d ", l->dato);
      l = l->next;
    }
    printf("\n");
  }

//NODO

typedef int Dato;

typedef struct nodo {
  Dato dato;
  struct nodo* next;
} Nodo;

typedef Nodo* Lista;


//UNION
typedef union
{int a ;
float b ;}
numero ;
numero n ;
n . a = 3;
n . b = 3.5;
printf ( " % d " , n . a );