#include <stdio.h>
#include <string.h>
#include <malloc.h>
#define MAXRECORDS 100

main()
{
 struct persona{
  char nome[30];
  char cognome[30];
 };

struct persona *p[MAXRECORDS]; //definisco un array con 100 elementi di tipo struct persona

int i=-1;


/*
do {
	i++;
	printf("Inserisci un nome: ");
	p[i]=(struct persona *) malloc(sizeof(struct persona));
 gets(p[i]->nome);
}while(p[i]->nome[0] != '\0');
*/

for (i = 0; i < MAXRECORDS; i++){
 printf("Inserisci un nome: ");
 p[i]=(struct persona *) malloc(sizeof(struct persona)); //inizializzo un elemento dell'array
 gets(p[i]->nome);
 if (p[i]->nome[0] == '\0')
  break;
 printf("Inserisci un cognome: ");
 gets(p[i]->cognome);
}
}

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

int main()
{
FILE *fp;
printf("Cerco la stringa 'printf' dentro il mio sorgente.\n");

if ((fp = fopen("abc.c", "r")) == NULL)
	{
		printf("Errore non posso aprire il file.");
		exit(1);
	}

char c;
char c1[5];
int i = 1, x, printf_trovati = 0;

while (i == 1) //controllo cosi se ho raggiunto fine file
{
	i = fread(&c, 1, 1, fp);
	/*if (i != 1)
        {
            fputs ("Errore non posso leggere dal file. ",stderr);
            exit(2);
        }*/
    //printf("%c", c);
	if (c == 'p') // 'p' non "p" PD!
	{
		x = fread(c1, 1, 5, fp); // !!!!!!!!!!!!!!!!!!!! 1,5 non 5,1
		c1[x]='\0';//la string finisce con \0
		if (strcmp(c1,"rintf")==0)
		{
            //abbiamo trovato un printf, si come lo abbiamo letto e quindi saltato lo dobbiamo scrivere
			printf_trovati++;
		}
		else		      {
                    //non `e printf, quindi dobbiamo andare indietro di 5 carratteri pd!
		          fseek(fp,-x,SEEK_CUR);//se cambio riga, poi la printf non funziona PD, quindi non stampiamo il file
            }
	}
}

printf("\n\n------------------------------\nHo trovato %d printf!\n", printf_trovati);

fclose(fp);
getch();
return 0;
}

/*
1) Scrivere una funzione che verifichi se un numero è primo. Scrivere quindi un
programma principale che, utilizzando la funzione, stampi i numeri primi presenti
fino ad un certo n, con n richiesto da input.
*/
//assumiamo che i numeri sono positivi
#include <stdio.h>

int primo( int x )
{
    int primo = 0;
    if ((x == 1) || (x == 2) || (x == 3))
        {
            primo = 1;
        }//fine true if
        
    else
    
        {
            int i = 2;
            primo = 1;
            while((primo) && (i < x-1))
                {
                    if ((x % i)==0)
                        primo = 0;
                    i++;
                }//fine while
        }//fine else
    return primo;
}

int main () 
{
    int n = 0, i;
    
    while (n <= 0) //controllo che n `e positivo
    {
        printf("Scrivi tutti i numeri primi fino a n = ");
        scanf("%d", &n);
    }
    
    printf("I numeri primi sono :");
    
    for (i = 1; i <= n; i++)
    {
        if (primo(i) == 1)
            printf(" %d ", i);
    }
    
    getch();
    return 0;
}

/*
2) Scrivere una funzione che si comporti esattamente come la funzione trim() senza che
ovviamente questa venga utilizzata. La funzione trim() riceve come argomento una stringa
(di cui non si conosce la lunghezza) e restituisce (torna) la stessa stringa dopo aver tolto
eventuali spazi finali (quelli a destra della stringa). La stringa restituita deve comunque
terminare con il terminatore di fine stringa.
Non è necessario scrivere il programma principale.
Sarà ulteriormente valutata la scrittura delle funzioni simili ltrim() (restituisce una stringa
senza gli spazi a sinistra) e la alltrim() (senza spazi nè a destra , nè a sinistra).
*/
// blah
// ltrim dovrebbe rimuovere spazi a sinistra
// rtrim ... a destra
// trim rimuove gli spazi all'inizio e alla fine di un testo
// e questa invece si inveta i nomi
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

char * ltrim(char *msg)
{
    int i = -1;
    char *copia;
    
    copia = (char *)malloc(sizeof(char)*1);
    copia[0] = '\0'; //inizializzo la strigna vuota
        
    while(msg[++i] == ' ');
    
    //a questo punto i indica dove inizia la stringa
    int x = 0;
    while(msg[i] != '\0')
    {
        copia = (char *)realloc(copia, sizeof(char)*(x+1)); // ah this magic command :)
        copia[x] = msg[i];
        i++;
        x++;
    }
    copia[x] = '\0';
    return copia;
}


char * rtrim(char *msg)
{
    int i = 0;
    char *copia;

    copia = (char *)malloc(sizeof(char)*1);
    copia[0] = '\0';

    while(msg[i] != '\0')// == strlen(msg)
        i++;
    
    i--; // perche adesso indica al \0 ma non ci interessa fine stringa ma gli ultimi spazi
    
    while(msg[i] == ' ')
    {
        i--;
    }
    
    //a questo punto i indica dove iniziano i spazi alla fine della stringa
    int x = 0, y = 0;
    while(y <= i)
    {
        copia = (char *)realloc(copia, sizeof(char)*(x+1)); // ah this magic command :)
        copia[x] = msg[y];
        y++;
        x++;
    }
    copia[x] = '\0';
    return copia;
}


char * trim(char *msg)
{
    return (ltrim(rtrim(msg)));
}

int main ()
{
    char *msg = NULL; // FOTUTO NULL mi ha mangiato 3 ore
    printf("Inserisci una stringa         :");
    char c;
    int i = 0;//lunghezza della stringa

    msg = (char *)malloc(sizeof(char)*1);
    msg[0] = '\0';//inizializzo la strigna vuota
    
    while ((c = getchar()) != '\n')
    {
        msg = (char *)realloc(msg, sizeof(char)*(i+1)); //realloc baby
        msg[i] = c;
        i++;
    }
    
    msg[i] = '\0'; //sto cazzo di fine stringa
    printf("La lunghezza della stringa `e : %d\n\n",i);
    printf("La stringa originale `e       :'%s'\n", msg);

    printf("La stringa dopo ltrim `e      :'%s'\n", ltrim(msg));
    printf("La stringa dopo rtrim `e      :'%s'\n", rtrim(msg));
    printf("La stringa dopo trim `e       :'%s'\n", trim(msg)); // bug a volte ? mostra un char in pi`u a caso alla fine ?


    free(msg);
    getch();
    return 0;
}


/*
1) Scrivere un programma che calcoli il massimo, il minimo e la media dei valori di
una matrice quadrata NxN con N valore dato, dopo aver acquisito da input la
matrice stessa.
*/
#include <stdio.h>

int main()
{
    int n = 0 ,i, j, massimo = 0, minimo = 0, media = 0, somma = 0;

    while (n <= 0)
    {
        printf("Inserisci la dimensione di una matrice N x N,  n = ");
        scanf("%d", &n);
    }
    int matrice[n][n];
    for(i = 0; i < n; i++)
        {
            for(j = 0; j < n; j++)
                {
                    printf("A[%d][%d] = ", (i+1), (j+1));
                    scanf("%d", &matrice[i][j]);
                    if ((i == 0) && (j == 0))
                        {
                            massimo = matrice[i][j];
                            minimo = matrice[i][j];
                        }
                    if (massimo < matrice[i][j])
                        massimo = matrice[i][j];
                        
                    if (minimo > matrice[i][j])
                        minimo = matrice[i][j];
                        
                    somma = somma + matrice[i][j];
                }
            printf("\n");
        }

    printf("Il massimo `e : %d\n", massimo);
    printf("Il minimo `e  : %d\n", minimo);
    printf("La media `e   : %f\n", ((float)somma/(n+n)));
    getch();
    return 0;
}


/*
Scrivere un programma che si pone l'obiettivo di leggere e poi memorizzare una serie di
stringhe (non si sa quante) di lunghezza variabile, senza occupare memoria oltre quella
necessaria. Il programma acquisisce da input, all'inizio, il numero di stringhe che si
vogliono memorizzare (0 se nessuna), e dovrà effettuare poi la memorizzazione solo di
quelle richieste. Il programma inoltre, prima di acquisire da input ogni stringa, acquisirà,
sempre da input, la lunghezza della stringa che segue, che deve essere comprensiva di
terminatore. Se la stringa fornita è più lunga di quanto dichiarato, i caratteri in eccesso non
devono essere memorizzati. Per uscire si digiterà 0 alla richiesta della lunghezza.
L’input del programma sarà quindi del tipo:
<numero di stringhe>
<lunghezza della prima stringa>
<valore della prima stringa>
…
<lunghezza ultima stringa>
<valore ultima stringa>
Si chiede di stampare alla fine del programma tutte e sole le stringhe memorizzate,
prima di liberare la memoria.
Non si può usare la funzione realloc(), né si possono utilizzare variabili con
allocazione non fissa, ad esempio:
{
<leggi n>;
char Stringa[n];
}
Sarà ulteriormente (e di molto) valutata la stesura dello stesso programma senza
che si sappia da input il numero di stringhe da memorizzare. In questo, e solo in
questo, caso è ammessa la realloc().
*/

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

int main ()
{
    int i, y, str_len, x, n;
    char **array;
    char *mychar;
    char c;
    
    printf("Quante stringhe vuoi leggere :");
    scanf("%d", &i);
    
    array=(char **)malloc(sizeof(char *)*i);
    
    for (y = 0; y < i; y++)
        { 
            printf("Inserisci la lunghezza della stringa : ");
            scanf("%d", &str_len);
            
            x = 0;
            mychar =(char *)malloc(sizeof(char)*(str_len+1));

            if (str_len > 0)
            {
               /*
                Se la stringa fornita è più lunga di quanto dichiarato, i caratteri in eccesso non
                devono essere memorizzati. 
                
                come cazzo faccio? uso fflush che manco ci hai insegnato
               */     
                fflush(stdin);
    //            getchar();
                printf("Inserisci la stringa : ");
    //            scanf("*%s", mychar);
    //            fgets(mychar, str_len, stdin);
    
                //scanf e gets PEZZI DI MERDA CON BUFFER DI MERDA
                while ((x < str_len))
                     {
                        c = getchar();
                        mychar[x] = c;
                        x++;
                    }
                fflush(stdin); // fflush sei pericolosa, non segui il standart, non ti dovrei usare, ma ti amo :D
            }
            mychar[str_len]='\0';
            array[y]=(char*)malloc(sizeof(char)*str_len);
            strcpy(array[y], mychar);
        }

    //stampo le stringhe salvate
    printf("\n");
    for (y = 0; y < i; y++)
        printf("La stringa %d `e : '%s'\n", (y+1), array[y]);
    
    free(array);
    free(mychar);
    getch();
    return 0;
}


/*
Scrivere un programma che si pone l'obiettivo di leggere e poi memorizzare una serie di
stringhe (non si sa quante) di lunghezza variabile, senza occupare memoria oltre quella
necessaria. Il programma acquisisce da input, all'inizio, il numero di stringhe che si
vogliono memorizzare (0 se nessuna), e dovrà effettuare poi la memorizzazione solo di
quelle richieste. Il programma inoltre, prima di acquisire da input ogni stringa, acquisirà,
sempre da input, la lunghezza della stringa che segue, che deve essere comprensiva di
terminatore. Se la stringa fornita è più lunga di quanto dichiarato, i caratteri in eccesso non
devono essere memorizzati. Per uscire si digiterà 0 alla richiesta della lunghezza.
L’input del programma sarà quindi del tipo:
<numero di stringhe>
<lunghezza della prima stringa>
<valore della prima stringa>
…
<lunghezza ultima stringa>
<valore ultima stringa>
Si chiede di stampare alla fine del programma tutte e sole le stringhe memorizzate,
prima di liberare la memoria.
Non si può usare la funzione realloc(), né si possono utilizzare variabili con
allocazione non fissa, ad esempio:
{
<leggi n>;
char Stringa[n];
}
Sarà ulteriormente (e di molto) valutata la stesura dello stesso programma senza
che si sappia da input il numero di stringhe da memorizzare. In questo, e solo in
questo, caso è ammessa la realloc().
*/

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

int main ()
{
    int y, str_len, x;
    char **array;
    char *mychar;
    char c;
    
    array=(char **)malloc(sizeof(char *)*1); // inizializz`o l'array

    y = 0; //stupid trick
    do {
        printf("Inserisci la lunghezza della stringa : ");
        scanf("%d", &str_len);

        x = 0;
        mychar =(char *)malloc(sizeof(char)*(str_len+1));

        if (str_len > 0)
            {
                fflush(stdin);
                printf("Inserisci la stringa : ");
                while ((x < str_len))
                     {
                        c = getchar();
                        mychar[x] = c;
                        x++;
                    }
                fflush(stdin);
            }
            mychar[str_len]='\0';
            array[y]=(char*)malloc(sizeof(char)*str_len);
            strcpy(array[y], mychar);
            y++;
            array=realloc(array, sizeof(char *)*(y+1)); //y+1 xke devono essere 2, 3, 4 ... non 1, 2, 3 ...
    } while (str_len > 0);

    //stampo le stringhe salvate
    printf("\n");
    for (x = 0; x < y; x++)
        printf("La stringa %d `e : '%s'\n", (x+1), array[x]);

    free(array);
    free(mychar);
    getch();
    return 0;
}