feat(appunti): Aggiunto esempio modalità esame fax simile Santini (#77)

Aggiunto esame scritto di Santini.
Migliorato il README iniziale così che rimanda alla tipologia d'esame corretta che si vuole visualizzare.

magistrale/Anno 1/Didattica/Santini/FaxSimileEsame/README.md

@@ -0,0 +1,26 @@
+# Didattica dell'Informatica
+## Esame di Programmazione Procedurale con Laboratorio
+Elaborato con gli esercizi, e relative soluzioni, per l'esame di Programmazione Procedurale con Laboratorio.
+
+## :pencil: Caratteristiche
+Il progetto rispetta le seguenti specifiche:
+
+* Composto da 5 esercizi (versione corta) che coprono più argomenti possibili del corso.
+* Ispirato agli esami degli anni passati (a.a. 2021 in poi) visibili sulla [pagina del corso](https://francescosantini.sites.dmi.unipg.it/progI23.html) di Programmazione procedurale con Laboratorio. 
+* Scritto in Latex sfruttando il package [exam](https://ctan.org/pkg/exam?lang=en). 
+* Contiene le soluzioni e i codici sorgente di tutti gli esercizi proposti.
+
+## :page_facing_up: Elaborato PDF
+Come anticipato sopra, sono stati creati due documenti PDF:
+
+* [Compito d'esame](pdf/didattica_inf_esame_prog1_cerami.pdf): contiene il compito d'esame vero e proprio da assegnare agli studenti. Va solo cambiata l'intestazione che per ora contiene il mio nome. Per farlo si può modificare il [seguente file LaTeX](latex_sources/Esame/esercizi.tex).
+* [Compito d'esame con correzioni](pdf/didattica_inf_esame_prog1_con_soluzioni_cerami.pdf): identico al precedente file ma al suo interno contiene le risposte (correzioni) degli esercizi. Anche qui va cambiata l'intestazione del documento con il [relativo file LaTeX](latex_sources/Esame/esercizi.tex). 
+
+## :computer: Codice sorgente esercizi
+Per ogni esercizio assegnato in questo compito d'esame è stato creato un file contenente il codice sorgente e la relativa spiegazione di risoluzione dell'esercizio.
+
+* [Esercizio 1](c_sources/esercizio%201/Es_1.c)
+* [Esercizio 2](c_sources/esercizio%202/Es_2.c)
+* [Esercizio 3](c_sources/esercizio%203/Es_3.c)
+* [Esercizio 4](c_sources/esercizio%204)
+* [Esercizio 5](c_sources/esercizio%205/Es_5.c)

magistrale/Anno 1/Didattica/Santini/FaxSimileEsame/c_sources/esercizio 1/Es_1.c

@@ -0,0 +1,78 @@
+//***********************************************************//
+//  5 punti.  Cosa stampa il seguente frammento di codice?   //
+//***********************************************************//
+
+#include <stdio.h>
+
+int main() {
+
+	int a = 0123 ^ 0x056 ; //3+2*8+8*8 = 83 , 6+5*16 = 86
+
+  	/* 
+		83 = 64 + 16 + 2 + 1 = 01010011
+		86 = 64 + 16 + 4 + 2 = 01010110
+	
+		01010011 = 83
+		01010110 = 86
+		-------- ^ XOR BIT A BIT
+		00000101 = 1 + 4 = 5
+  	*/
+
+	double b = 2.59;
+
+	printf ("%d\n", a); //5
+
+	while ((++a || a++) ? a-=1 : 0) {
+		if (!(a-- && --a ))
+			break;
+		else
+			printf("%d\n", a);
+	}
+
+	/*
+	 	Step dentro ciclo while:
+		inizio con a==5 -> ++a == 6 -> (a-=1) == 5
+			if !(5 && 3) -> Falso , a == 3
+				stampo 3
+		inizio con a==3 -> ++a == 4 -> (a-=1) == 3
+			if !(3 && 1) -> Falso , a == 1
+				stampo 1
+		inizio con a==1 -> ++a == 2 -> (a-=1) == 1
+			if !(1 && -1) -> Falso , a == -1
+				stampo -1
+		inizio con a==-1 -> ++a == 0 || a++ == valuto 0 e poi incremento a 1 -> 0 || 0 quindi esco dal while con a==1
+	*/
+
+	a<=a, a+=b, a++;
+
+	/*
+	 	La prima espressione non ha nessun side effect quindi può essere ignorata in questo caso.
+		Nella seconda invece si somma ad "a" il float "b" ma, come da regole, si prende solo la parte intera quindi a=1+2 -> a==3
+		Nella terza si incrementa nuovamente a -> a==4
+	*/
+
+	printf("a: %d\n", a); //4
+
+	return 0;
+}
+
+/*
+	Stampa:
+	5
+	3
+	1
+	-1
+	a: 4
+
+	---------------------------------------
+
+	Usati argomenti:
+		- Logical operator
+		- Bitwise operator
+		- Conditional operator
+		- Compound assignment operator
+		- Expressions and comma operator
+		- Precedence and associativity
+		- Order of evaluation, Short circuit
+		- Side effects 
+*/

magistrale/Anno 1/Didattica/Santini/FaxSimileEsame/c_sources/esercizio 2/Es_2.c

@@ -0,0 +1,91 @@
+//**************************************************************************//
+//  6 punti.                                                                //
+//           Elencare le conversioni di tipo implicite (... da ... a)       //
+//           Scrivere cosa viene stampato a schermo sapendo che:            //
+//           UCHAR_MAX = 255 , 'a' = 97                                     //
+//                                                                          //
+//**************************************************************************//
+
+#include <stdio.h>
+
+double fun (float a) {
+	char b = ('x' * 3) - 'g'; // = 1
+	return (a / b);
+}
+
+int main (void) {
+	unsigned int a = 'g' - 3UL; // = 100
+	float b = fun(a) ; // = 100.0
+	unsigned char c = -(int) (b+53); // = (UCHAR_MAX + 1) - 153 = 256-153 = 103
+	printf("c: %c, %d\n", c, c); // c: g, 103
+	return 0;
+}
+
+
+/*
+	linea 7: 'g' convertito da int a unsigned long int
+	linea 7: il valore dopo l'uguale è convertito da unsigned long int ad unsigned int
+	linea 8: il parametro "a" di fun() è convertito da unsigned int a float
+	linea 2: il valore dopo l'uguale è convertito da int a char
+	linea 3: "b" è convertito da char a float per la divisione
+	linea 3: il risultato della divisione è convertito da float a double
+	linea 8: il valore di ritorno è convertito da double a float
+	linea 9: 53 è convertito da int a float
+	linea 9: il valore dopo l'uguale è convertito da int (dopo la conversione esplicita) a unsigned char
+
+	A schermo viene stampato "c: g, 103" perchè c = (UCHAR_MAX + 1) - 153 = 103 = 'g' in ASCII
+*/
+
+/* 
+	Per sapere cosa stampa il seguente programma è bene prima scrivere da una parte tutti i valori int ASCII così da non doverli
+	calcolare ogni volta (si risparmia molto tempo e si riducono gli errori):
+	
+	97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
+	a  b  c  d   e   f   g   h   i   j   k   l   m   n   o   p   q   r   s   t   u   v   w   x   y   z
+	
+	printf("%d\n", 'x'); // 'x' = 120
+	printf("%d\n", 'g'); // 'g' = 103
+	printf("%d\n", ('x' * 3) - 'g');  // 'x' * 3 - 'g' = 120*3 - 103 = 257
+	
+	char a = ('x' * 3) - 'g';
+	printf("%d\n", a); // = 1 perchè:
+	
+	-------------------------------------------
+	char a = 257, UCHAR_MAX = 255
+	
+	Per troncamento si ha (rappresentazione little endian):
+	INT  (4 byte)	10000000 10000000 00000000 00000000	= 257
+	CHAR (1 byte)	10000000 xxxxxxxx xxxxxxxx xxxxxxxx = 1
+	
+	==============================================================================
+	==============================================================================
+	
+	Quando si arriva qua si ha "b"==100.0
+	Aggiungendogli 53 si arriva a 153.0 che poi per il cast esplicito e il 
+	segno meno diventa -153 causando un wraparound che può essere così calcolato:
+	unsigned char c = -(int) (b+53); // -153 -> (UCHAR_MAX + 1) - 153 = (255 + 1) -153 = 103 = 'g' in ASCII
+	
+	==============================================================================
+	==============================================================================
+	
+	Per vedere direttamente a schermo i valori ottenuti a ogni passaggio si può usare il seguente codice:
+	
+	double fun (float a) {
+		char b = ('x' * 3) - 'g'; //   // 'x' * 3 - 'g' = 120*3 - 103 = 257 = 1
+		printf("b: %d\n", b);
+		printf("a/b: %f\n", a/b);
+		return (a / b);
+	}
+	
+	int main (void) {
+		unsigned int a = 'g' - 3UL; // = 100
+		printf("a: %u\n", a);
+		float b = fun(a) ; // = 100.0
+		printf("b: %f\n", b);
+		printf("b cast int: %d\n", -(int) (b+53)); // = -153
+		unsigned char c = -(int) (b+53); // = 256-153 = 103
+		printf("c: %c, %d\n", c, c); // = 'g', 103
+		return 0;
+	}
+
+*/

magistrale/Anno 1/Didattica/Santini/FaxSimileEsame/c_sources/esercizio 3/Es_3.c

@@ -0,0 +1,117 @@
+/*
+	Data la seguente struct, scrivere la definizione di una funzione di nome ritorna_dispari che prende come parametro una 
+	lista (lista_input) e ritorna un'altra lista (lista_output, creata nella funzione) che contiene, nello stesso ordine della
+	lista passata, solamente gli elementi in posizione dispari (se presenti). 
+
+	Se la lista originale è 5-2-9, la lista ritornata sarà 5-9.
+
+	
+	typedef struct node Node;
+
+	struct node {
+		int info;
+		struct node* pNext;
+	};
+*/
+
+/*
+	Del seguente codice era richiesta solo la funzione "ritorna_dispari" ma per farne vedere il corretto funzionamento
+	sono state create delle funzioni aggiuntive.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node Node;
+
+struct node {
+	int info;
+	struct node* pNext;
+};
+
+void print_list(Node* pFirst) {
+	if(pFirst == NULL)
+		printf("Lista vuota!\n"); 
+	else {
+		Node* pScan = pFirst;
+		do {
+			printf("Info: %d\n", pScan->info);
+			pScan = pScan->pNext;
+		} while(pScan!= NULL);
+	}
+	return;
+}
+
+
+Node* ritorna_dispari(Node* lista_input) {
+
+	if (lista_input == NULL) {
+		//Se lista_input è vuota allora non ritorno alcuna lista
+		return NULL;
+	} else {
+		//Se lista_input contiene almeno un elemento allora procedo a creare la lista di elementi dispari
+		//Ricordiamo che dobbiamo mantenere lo stesso ordine degli elementi di input quindi INSERIMENTO IN CODA!
+		int counter = 0;
+		Node* pScan = lista_input;
+
+		Node* lista_output = NULL; //Puntatore al primo elemento della nuova lista
+		Node* lista_output_pLast = NULL; //Per inserire in coda all'ultimo elemento
+
+		while (pScan != NULL) {
+			if (counter % 2 == 0) {
+				Node* pNew = (Node*) malloc(sizeof(Node));
+				pNew -> info = pScan -> info;
+				pNew -> pNext = NULL;
+
+				//Se lista_output non contiene neanche un elemento 
+				if (lista_output == NULL) {
+				    lista_output = pNew;
+				    lista_output_pLast = pNew;
+				} else {
+				    //Se lista_output contiene almeno un elemento allora lo inseriamo in coda 
+				    lista_output_pLast -> pNext = pNew;
+				    lista_output_pLast = pNew;
+				}	    		
+			}
+
+			pScan = pScan -> pNext;
+			counter++;
+		}
+
+		return lista_output;
+	}
+}
+
+
+int main() {
+
+	Node *pFirst = NULL;
+	Node *pLast = NULL;
+
+	//Creo una linked list con campi info da 1 a 5
+	for (int i = 1; i < 6; i++) {
+		Node* pNew = (Node*) malloc(sizeof(Node));
+		pNew -> info = i;
+		pNew -> pNext = NULL;
+
+		if (pFirst == NULL) {
+			pFirst = pNew;
+			pLast = pNew;
+		} else {
+			pLast -> pNext = pNew;
+			pLast = pNew;
+		}               
+	}
+
+	//Stampo il contenuto della lista ritornata da "ritorna_dispari" e che contiene solo gli elementi in posizione dispari 
+	print_list(ritorna_dispari(pFirst));
+
+	/* 
+		Viene stampato:
+		Info: 1
+		Info: 3
+		Info: 5
+	*/
+
+	return 0;
+}

magistrale/Anno 1/Didattica/Santini/FaxSimileEsame/c_sources/esercizio 4/main.c

@@ -0,0 +1,26 @@
+/*
+	Dire quali compilazioni provocano errore a causa del linker (e perchè):
+	1) gcc -o write write.c
+	2) gcc -c main.c
+	3) gcc -o main main.c
+	4) gcc -o execute main.c write.c
+	
+	In caso il punto 4) ritorni un errore, descrivere come può essere corretto. Infine, dopo la correzione 
+	eventualmente applicata, elencare tutte le definizioni, dichiarazioni e tipologie di linkage, presenti 
+	in ogni file, per count, i, a, e mywrite. Cosa stampa il programma?
+*/
+
+/*
+	Le correzioni sono presenti nel file "write.c"
+*/
+
+extern void mywrite(int *count);
+extern int count;
+int i;
+int i = 1;
+
+int main(void) {
+	do {
+		mywrite(&count);
+	} while(count <= 0);
+}