Organize repository

2N/v.c

@@ -1,64 +1,64 @@
-#include <stdio.h>
+#include <stdio.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <time.h>
+#include <time.h>
-
+
-// Funzione per generare un valore casuale compreso tra a e b
+// Funzione per generare un valore casuale compreso tra a e b
-int genera_valore_casuale(int a, int b) {
+int genera_valore_casuale(int a, int b) {
-    return rand() % (b - a + 1) + a;
+    return rand() % (b - a + 1) + a;
-}
+}
-
+
-// Funzione per cercare le occorrenze di un valore specifico in un array
+// Funzione per cercare le occorrenze di un valore specifico in un array
-int conta_occorrenze(int array[], int lunghezza, int valore) {
+int conta_occorrenze(int array[], int lunghezza, int valore) {
-    int contatore = 0;
+    int contatore = 0;
-    for (int i = 0; i < lunghezza; i++) {
+    for (int i = 0; i < lunghezza; i++) {
-        if (array[i] == valore) {
+        if (array[i] == valore) {
-            contatore++;
+            contatore++;
-        }
+        }
-    }
+    }
-    return contatore;
+    return contatore;
-}
+}
-
+
-int main() {
+int main() {
-    int n, a, b, valore_specifico;
+    int n, a, b, valore_specifico;
-
+
-    // Input della dimensione degli array e degli estremi dell'intervallo
+    // Input della dimensione degli array e degli estremi dell'intervallo
-    printf("Inserisci la dimensione degli array: ");
+    printf("Inserisci la dimensione degli array: ");
-    scanf("%d", &n);
+    scanf("%d", &n);
-    printf("Inserisci gli estremi dell'intervallo (a e b): ");
+    printf("Inserisci gli estremi dell'intervallo (a e b): ");
-    scanf("%d %d", &a, &b);
+    scanf("%d %d", &a, &b);
-    printf("Inserisci il valore specifico da cercare: ");
+    printf("Inserisci il valore specifico da cercare: ");
-    scanf("%d", &valore_specifico);
+    scanf("%d", &valore_specifico);
-
+
-    // Allocazione dinamica di memoria per gli array
+    // Allocazione dinamica di memoria per gli array
-    int *array_valori = (int *)malloc(n * sizeof(int));
+    int *array_valori = (int *)malloc(n * sizeof(int));
-    int *array_random = (int *)malloc(n * sizeof(int));
+    int *array_random = (int *)malloc(n * sizeof(int));
-
+
-    // Inizializzazione del generatore di numeri casuali
+    // Inizializzazione del generatore di numeri casuali
-    srand(time(NULL));
+    srand(time(NULL));
-
+
-    // Input dei valori nell'array
+    // Input dei valori nell'array
-    printf("Inserisci i valori nell'array:\n");
+    printf("Inserisci i valori nell'array:\n");
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
-        scanf("%d", &array_valori[i]);
+        scanf("%d", &array_valori[i]);
-    }
+    }
-
+
-    // Generazione di valori casuali e memorizzazione nell'array random
+    // Generazione di valori casuali e memorizzazione nell'array random
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
-        array_random[i] = genera_valore_casuale(a, b);
+        array_random[i] = genera_valore_casuale(a, b);
-    }
+    }
-
+
-    // Cerca le occorrenze del valore specifico in entrambi gli array
+    // Cerca le occorrenze del valore specifico in entrambi gli array
-    int occorrenze_valori = conta_occorrenze(array_valori, n, valore_specifico);
+    int occorrenze_valori = conta_occorrenze(array_valori, n, valore_specifico);
-    int occorrenze_random = conta_occorrenze(array_random, n, valore_specifico);
+    int occorrenze_random = conta_occorrenze(array_random, n, valore_specifico);
-
+
-    // Stampa il risultato
+    // Stampa il risultato
-    printf("Il valore %d compare %d volte nell'array dei valori inseriti.\n", valore_specifico, occorrenze_valori);
+    printf("Il valore %d compare %d volte nell'array dei valori inseriti.\n", valore_specifico, occorrenze_valori);
-    printf("Il valore %d compare %d volte nell'array dei valori casuali.\n", valore_specifico, occorrenze_random);
+    printf("Il valore %d compare %d volte nell'array dei valori casuali.\n", valore_specifico, occorrenze_random);
-
+
-    // Deallocazione della memoria
+    // Deallocazione della memoria
-    free(array_valori);
+    free(array_valori);
-    free(array_random);
+    free(array_random);
-
+
-    return 0;
+    return 0;
-}
+}
-
+

2N/z.c

@@ -1,64 +1,64 @@
-#include <stdio.h>
+#include <stdio.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <time.h>
+#include <time.h>
-
+
-// Funzione per generare un valore casuale compreso tra a e b
+// Funzione per generare un valore casuale compreso tra a e b
-int genera_valore_casuale(int a, int b) {
+int genera_valore_casuale(int a, int b) {
-    return rand() % (b - a + 1) + a;
+    return rand() % (b - a + 1) + a;
-}
+}
-
+
-// Funzione per cercare le occorrenze di un valore specifico in un array
+// Funzione per cercare le occorrenze di un valore specifico in un array
-int conta_occorrenze(int array[], int lunghezza, int valore) {
+int conta_occorrenze(int array[], int lunghezza, int valore) {
-    int contatore = 0;
+    int contatore = 0;
-    for (int i = 0; i < lunghezza; i++) {
+    for (int i = 0; i < lunghezza; i++) {
-        if (array[i] == valore) {
+        if (array[i] == valore) {
-            contatore++;
+            contatore++;
-        }
+        }
-    }
+    }
-    return contatore;
+    return contatore;
-}
+}
-
+
-int main() {
+int main() {
-    int n, a, b, valore_specifico;
+    int n, a, b, valore_specifico;
-
+
-    // Input della dimensione degli array e degli estremi dell'intervallo
+    // Input della dimensione degli array e degli estremi dell'intervallo
-    printf("Inserisci la dimensione degli array: ");
+    printf("Inserisci la dimensione degli array: ");
-    scanf("%d", &n);
+    scanf("%d", &n);
-    printf("Inserisci gli estremi dell'intervallo (a e b): ");
+    printf("Inserisci gli estremi dell'intervallo (a e b): ");
-    scanf("%d %d", &a, &b);
+    scanf("%d %d", &a, &b);
-    printf("Inserisci il valore specifico da cercare: ");
+    printf("Inserisci il valore specifico da cercare: ");
-    scanf("%d", &valore_specifico);
+    scanf("%d", &valore_specifico);
-
+
-    // Allocazione dinamica di memoria per gli array
+    // Allocazione dinamica di memoria per gli array
-    int *array_valori = (int *)malloc(n * sizeof(int));
+    int *array_valori = (int *)malloc(n * sizeof(int));
-    int *array_random = (int *)malloc(n * sizeof(int));
+    int *array_random = (int *)malloc(n * sizeof(int));
-
+
-    // Inizializzazione del generatore di numeri casuali
+    // Inizializzazione del generatore di numeri casuali
-    srand(time(NULL));
+    srand(time(NULL));
-
+
-    // Input dei valori nell'array
+    // Input dei valori nell'array
-    printf("Inserisci i valori nell'array:\n");
+    printf("Inserisci i valori nell'array:\n");
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
-        scanf("%d", &array_valori[i]);
+        scanf("%d", &array_valori[i]);
-    }
+    }
-
+
-    // Generazione di valori casuali e memorizzazione nell'array random
+    // Generazione di valori casuali e memorizzazione nell'array random
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
-        array_random[i] = genera_valore_casuale(a, b);
+        array_random[i] = genera_valore_casuale(a, b);
-    }
+    }
-
+
-    // Cerca le occorrenze del valore specifico in entrambi gli array
+    // Cerca le occorrenze del valore specifico in entrambi gli array
-    int occorrenze_valori = conta_occorrenze(array_valori, n, valore_specifico);
+    int occorrenze_valori = conta_occorrenze(array_valori, n, valore_specifico);
-    int occorrenze_random = conta_occorrenze(array_random, n, valore_specifico);
+    int occorrenze_random = conta_occorrenze(array_random, n, valore_specifico);
-
+
-    // Stampa il risultato
+    // Stampa il risultato
-    printf("Il valore %d compare %d volte nell'array dei valori inseriti.\n", valore_specifico, occorrenze_valori);
+    printf("Il valore %d compare %d volte nell'array dei valori inseriti.\n", valore_specifico, occorrenze_valori);
-    printf("Il valore %d compare %d volte nell'array dei valori casuali.\n", valore_specifico, occorrenze_random);
+    printf("Il valore %d compare %d volte nell'array dei valori casuali.\n", valore_specifico, occorrenze_random);
-
+
-    // Deallocazione della memoria
+    // Deallocazione della memoria
-    free(array_valori);
+    free(array_valori);
-    free(array_random);
+    free(array_random);
-
+
-    return 0;
+    return 0;
-}
+}
-
+

3AIN/array/array_tutti_pari.cpp

@@ -1,36 +1,36 @@
-/*
+/*
-AUTORE: Vichingo455
+AUTORE: Vichingo455
-Function returning if all values stored in an array of values are peer numbers or not
+Function returning if all values stored in an array of values are peer numbers or not
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-bool isPeerArray(int array[], size_t size) {
+bool isPeerArray(int array[], size_t size) {
-	int numberOfPeers = 0;
+	int numberOfPeers = 0;
-	for (int i = 0; i < size; i++) {
+	for (int i = 0; i < size; i++) {
-		if (array[i] % 2 == 0) {
+		if (array[i] % 2 == 0) {
-			numberOfPeers++;
+			numberOfPeers++;
-		}
+		}
-	}
+	}
-	return numberOfPeers == size;
+	return numberOfPeers == size;
-}
+}
-int main() {
+int main() {
-	size_t numberOfValues;
+	size_t numberOfValues;
-	cout << "Insert the number of values to store on an array: ";
+	cout << "Insert the number of values to store on an array: ";
-	cin >> numberOfValues;
+	cin >> numberOfValues;
-	cout << endl;
+	cout << endl;
-	int array[numberOfValues];
+	int array[numberOfValues];
-	for (int i = 0; i < numberOfValues; i++) {
+	for (int i = 0; i < numberOfValues; i++) {
-		cout << "Insert the value: ";
+		cout << "Insert the value: ";
-		cin >> array[i];
+		cin >> array[i];
-	}
+	}
-	if (isPeerArray(array, numberOfValues)) {
+	if (isPeerArray(array, numberOfValues)) {
-		cout << "All numbers are peers." << endl;
+		cout << "All numbers are peers." << endl;
-	}
+	}
-	else {
+	else {
-		cout << "Not all numbers are peers." << endl;
+		cout << "Not all numbers are peers." << endl;
-	}
+	}
-    return 0;
+    return 0;
-}
+}

3AIN/array/arraytools.h

@@ -1,200 +1,200 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Array Tools
+Array Tools
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-void insertionSort(int arr[], int n)
+void insertionSort(int arr[], int n)
-{
+{
-    for (int i = 1; i < n; ++i) {
+    for (int i = 1; i < n; ++i) {
-        int key = arr[i];
+        int key = arr[i];
-        int j = i - 1;
+        int j = i - 1;
-
+
-        /* Move elements of arr[0..i-1], that are
+        /* Move elements of arr[0..i-1], that are
-           greater than key, to one position ahead
+           greater than key, to one position ahead
-           of their current position */
+           of their current position */
-        while (j >= 0 && arr[j] > key) {
+        while (j >= 0 && arr[j] > key) {
-            arr[j + 1] = arr[j];
+            arr[j + 1] = arr[j];
-            j = j - 1;
+            j = j - 1;
-        }
+        }
-        arr[j + 1] = key;
+        arr[j + 1] = key;
-    }
+    }
-}
+}
-vector<int> countSort(vector<int>& inputArray)
+vector<int> countSort(vector<int>& inputArray)
-{
+{
-
+
-    int N = inputArray.size();
+    int N = inputArray.size();
-
+
-    // Finding the maximum element of array inputArray[].
+    // Finding the maximum element of array inputArray[].
-    int M = 0;
+    int M = 0;
-
+
-    for (int i = 0; i < N; i++)
+    for (int i = 0; i < N; i++)
-        M = max(M, inputArray[i]);
+        M = max(M, inputArray[i]);
-
+
-    // Initializing countArray[] with 0
+    // Initializing countArray[] with 0
-    vector<int> countArray(M + 1, 0);
+    vector<int> countArray(M + 1, 0);
-
+
-    // Mapping each element of inputArray[] as an index
+    // Mapping each element of inputArray[] as an index
-    // of countArray[] array
+    // of countArray[] array
-
+
-    for (int i = 0; i < N; i++)
+    for (int i = 0; i < N; i++)
-        countArray[inputArray[i]]++;
+        countArray[inputArray[i]]++;
-
+
-    // Calculating prefix sum at every index
+    // Calculating prefix sum at every index
-    // of array countArray[]
+    // of array countArray[]
-    for (int i = 1; i <= M; i++)
+    for (int i = 1; i <= M; i++)
-        countArray[i] += countArray[i - 1];
+        countArray[i] += countArray[i - 1];
-
+
-    // Creating outputArray[] from countArray[] array
+    // Creating outputArray[] from countArray[] array
-    vector<int> outputArray(N);
+    vector<int> outputArray(N);
-
+
-    for (int i = N - 1; i >= 0; i--)
+    for (int i = N - 1; i >= 0; i--)
-
+
-    {
+    {
-        outputArray[countArray[inputArray[i]] - 1]
+        outputArray[countArray[inputArray[i]] - 1]
-            = inputArray[i];
+            = inputArray[i];
-
+
-        countArray[inputArray[i]]--;
+        countArray[inputArray[i]]--;
-    }
+    }
-
+
-    return outputArray;
+    return outputArray;
-}
+}
-void selectionSort(vector<int> &arr) {
+void selectionSort(vector<int> &arr) {
-    int n = arr.size();
+    int n = arr.size();
-
+
-    for (int i = 0; i < n - 1; ++i) {
+    for (int i = 0; i < n - 1; ++i) {
-
+
-        // Assume the current position holds
+        // Assume the current position holds
-        // the minimum element
+        // the minimum element
-        int min_idx = i;
+        int min_idx = i;
-
+
-        // Iterate through the unsorted portion
+        // Iterate through the unsorted portion
-        // to find the actual minimum
+        // to find the actual minimum
-        for (int j = i + 1; j < n; ++j) {
+        for (int j = i + 1; j < n; ++j) {
-            if (arr[j] < arr[min_idx]) {
+            if (arr[j] < arr[min_idx]) {
-
+
-                // Update min_idx if a smaller
+                // Update min_idx if a smaller
-                // element is found
+                // element is found
-                min_idx = j; 
+                min_idx = j; 
-            }
+            }
-        }
+        }
-
+
-        // Move minimum element to its
+        // Move minimum element to its
-        // correct position
+        // correct position
-        swap(arr[i], arr[min_idx]);
+        swap(arr[i], arr[min_idx]);
-    }
+    }
-}
+}
-int partition(vector<int>& arr, int low, int high) {
+int partition(vector<int>& arr, int low, int high) {
-  
+  
-    // Choose the pivot
+    // Choose the pivot
-    int pivot = arr[high];
+    int pivot = arr[high];
-  
+  
-    // Index of smaller element and indicates 
+    // Index of smaller element and indicates 
-    // the right position of pivot found so far
+    // the right position of pivot found so far
-    int i = low - 1;
+    int i = low - 1;
-
+
-    // Traverse arr[;ow..high] and move all smaller
+    // Traverse arr[;ow..high] and move all smaller
-    // elements on left side. Elements from low to 
+    // elements on left side. Elements from low to 
-    // i are smaller after every iteration
+    // i are smaller after every iteration
-    for (int j = low; j <= high - 1; j++) {
+    for (int j = low; j <= high - 1; j++) {
-        if (arr[j] < pivot) {
+        if (arr[j] < pivot) {
-            i++;
+            i++;
-            swap(arr[i], arr[j]);
+            swap(arr[i], arr[j]);
-        }
+        }
-    }
+    }
-    
+    
-    // Move pivot after smaller elements and
+    // Move pivot after smaller elements and
-    // return its position
+    // return its position
-    swap(arr[i + 1], arr[high]);  
+    swap(arr[i + 1], arr[high]);  
-    return i + 1;
+    return i + 1;
-}
+}
-
+
-// The QuickSort function implementation
+// The QuickSort function implementation
-void quickSort(vector<int>& arr, int low, int high) {
+void quickSort(vector<int>& arr, int low, int high) {
-  
+  
-    if (low < high) {
+    if (low < high) {
-      
+      
-        // pi is the partition return index of pivot
+        // pi is the partition return index of pivot
-        int pi = partition(arr, low, high);
+        int pi = partition(arr, low, high);
-
+
-        // Recursion calls for smaller elements
+        // Recursion calls for smaller elements
-        // and greater or equals elements
+        // and greater or equals elements
-        quickSort(arr, low, pi - 1);
+        quickSort(arr, low, pi - 1);
-        quickSort(arr, pi + 1, high);
+        quickSort(arr, pi + 1, high);
-    }
+    }
-}
+}
-void bubbleSort(vector<int>& arr) {
+void bubbleSort(vector<int>& arr) {
-    int n = arr.size();
+    int n = arr.size();
-    bool swapped;
+    bool swapped;
-  
+  
-    for (int i = 0; i < n - 1; i++) {
+    for (int i = 0; i < n - 1; i++) {
-        swapped = false;
+        swapped = false;
-        for (int j = 0; j < n - i - 1; j++) {
+        for (int j = 0; j < n - i - 1; j++) {
-            if (arr[j] > arr[j + 1]) {
+            if (arr[j] > arr[j + 1]) {
-                swap(arr[j], arr[j + 1]);
+                swap(arr[j], arr[j + 1]);
-                swapped = true;
+                swapped = true;
-            }
+            }
-        }
+        }
-      
+      
-        // If no two elements were swapped, then break
+        // If no two elements were swapped, then break
-        if (!swapped)
+        if (!swapped)
-            break;
+            break;
-    }
+    }
-}
+}
-void CocktailSort(int a[], int n)
+void CocktailSort(int a[], int n)
-{
+{
-    bool swapped = true;
+    bool swapped = true;
-    int start = 0;
+    int start = 0;
-    int end = n - 1;
+    int end = n - 1;
- 
+ 
-    while (swapped) {
+    while (swapped) {
-        // reset the swapped flag on entering
+        // reset the swapped flag on entering
-        // the loop, because it might be true from
+        // the loop, because it might be true from
-        // a previous iteration.
+        // a previous iteration.
-        swapped = false;
+        swapped = false;
- 
+ 
-        // loop from left to right same as
+        // loop from left to right same as
-        // the bubble sort
+        // the bubble sort
-        for (int i = start; i < end; ++i) {
+        for (int i = start; i < end; ++i) {
-            if (a[i] > a[i + 1]) {
+            if (a[i] > a[i + 1]) {
-                swap(a[i], a[i + 1]);
+                swap(a[i], a[i + 1]);
-                swapped = true;
+                swapped = true;
-            }
+            }
-        }
+        }
- 
+ 
-        // if nothing moved, then array is sorted.
+        // if nothing moved, then array is sorted.
-        if (!swapped)
+        if (!swapped)
-            break;
+            break;
- 
+ 
-        // otherwise, reset the swapped flag so that it
+        // otherwise, reset the swapped flag so that it
-        // can be used in the next stage
+        // can be used in the next stage
-        swapped = false;
+        swapped = false;
- 
+ 
-        // move the end point back by one, because
+        // move the end point back by one, because
-        // item at the end is in its rightful spot
+        // item at the end is in its rightful spot
-        --end;
+        --end;
- 
+ 
-        // from right to left, doing the
+        // from right to left, doing the
-        // same comparison as in the previous stage
+        // same comparison as in the previous stage
-        for (int i = end - 1; i >= start; --i) {
+        for (int i = end - 1; i >= start; --i) {
-            if (a[i] > a[i + 1]) {
+            if (a[i] > a[i + 1]) {
-                swap(a[i], a[i + 1]);
+                swap(a[i], a[i + 1]);
-                swapped = true;
+                swapped = true;
-            }
+            }
-        }
+        }
- 
+ 
-        // increase the starting point, because
+        // increase the starting point, because
-        // the last stage would have moved the next
+        // the last stage would have moved the next
-        // smallest number to its rightful spot.
+        // smallest number to its rightful spot.
-        ++start;
+        ++start;
-    }
+    }
-}
+}
-void printArray(int a[], int n)
+void printArray(int a[], int n)
-{
+{
-    for (int i = 0; i < n; i++)
+    for (int i = 0; i < n; i++)
-        printf("%d ", a[i]);
+        printf("%d ", a[i]);
-    printf("\n");
+    printf("\n");
 }

3AIN/array/conta_numeri.cpp

@@ -1,25 +1,25 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Conta numeri
+Conta numeri
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-void contaValoriUguali(int array[], size_t array_size) {
+void contaValoriUguali(int array[], size_t array_size) {
-	for (size_t i = 0; i < array_size; i++) {
+	for (size_t i = 0; i < array_size; i++) {
-		int valoreVolte = 0;
+		int valoreVolte = 0;
-		for (size_t j = 0; j < array_size; ++j) {
+		for (size_t j = 0; j < array_size; ++j) {
-			if (array[j] == array[i]) {
+			if (array[j] == array[i]) {
-				valoreVolte++;
+				valoreVolte++;
-			}
+			}
-		}
+		}
-		cout << "Il valore " << array[i] << " compare " << valoreVolte << " volte." << endl;
+		cout << "Il valore " << array[i] << " compare " << valoreVolte << " volte." << endl;
-	}
+	}
-}
+}
-int main() {
+int main() {
-	int array[] = {-1, 0, 1, 2, 0, 2, -1, 7, 9};
+	int array[] = {-1, 0, 1, 2, 0, 2, -1, 7, 9};
-	contaValoriUguali(array,9);
+	contaValoriUguali(array,9);
-    return 0;
+    return 0;
-}
+}

3AIN/array/elimina_pari_vettori.cpp

@@ -1,38 +1,38 @@
-/*
+/*
-AUTORE: Vichingo455
+AUTORE: Vichingo455
-The program deletes peer numbers from a vector without using memmove
+The program deletes peer numbers from a vector without using memmove
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-void printVector(const vector<int> & vett) {
+void printVector(const vector<int> & vett) {
-	for (int i = 0; i < vett.size(); i++)
+	for (int i = 0; i < vett.size(); i++)
-		cout << vett.at(i) << " ";
+		cout << vett.at(i) << " ";
-	cout << endl;
+	cout << endl;
-}
+}
-void deletePeers(vector<int> & vett) {
+void deletePeers(vector<int> & vett) {
-	for (int i = 0; i < vett.size(); i++) {
+	for (int i = 0; i < vett.size(); i++) {
-		if (vett.at(i) % 2 == 0) {
+		if (vett.at(i) % 2 == 0) {
-			vett.erase(vett.begin() + i);
+			vett.erase(vett.begin() + i);
-		}
+		}
-	}
+	}
-}
+}
-int main() {
+int main() {
-	vector<int> vett;
+	vector<int> vett;
-	int vectorSize;
+	int vectorSize;
-	cout << "Insert the size of the vector: ";
+	cout << "Insert the size of the vector: ";
-	cin >> vectorSize;
+	cin >> vectorSize;
-	cout << endl;
+	cout << endl;
-	for (int i = 0,value; i < vectorSize; i++) {
+	for (int i = 0,value; i < vectorSize; i++) {
-		cout << "Insert a value: ";
+		cout << "Insert a value: ";
-		cin >> value;
+		cin >> value;
-		vett.push_back(value);
+		vett.push_back(value);
-		cout << endl;
+		cout << endl;
-	}
+	}
-	printVector(vett);
+	printVector(vett);
-	deletePeers(vett);
+	deletePeers(vett);
-	printVector(vett);
+	printVector(vett);
-    return 0;
+    return 0;
-}
+}

3AIN/array/elimina_pari_vettori_memmove.cpp

@@ -1,46 +1,46 @@
-/*
+/*
-AUTORE: Vichingo455
+AUTORE: Vichingo455
-The program deletes peer numbers from a vector using memmove
+The program deletes peer numbers from a vector using memmove
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-#include <cstring>
+#include <cstring>
-using namespace std;
+using namespace std;
-void printVector(const vector<int> & vett) {
+void printVector(const vector<int> & vett) {
-	for (int i = 0; i < vett.size(); i++)
+	for (int i = 0; i < vett.size(); i++)
-		cout << vett.at(i) << " ";
+		cout << vett.at(i) << " ";
-	cout << endl;
+	cout << endl;
-}
+}
-void deletePeers(vector<int>& vec) {
+void deletePeers(vector<int>& vec) {
-    int* data = vec.data();
+    int* data = vec.data();
-    size_t size = vec.size();
+    size_t size = vec.size();
-    size_t newSize = 0;
+    size_t newSize = 0;
-    for (size_t i = 0; i < size; ++i) {
+    for (size_t i = 0; i < size; ++i) {
-        if (data[i] % 2 != 0) {
+        if (data[i] % 2 != 0) {
-            if (newSize != i) {
+            if (newSize != i) {
-                std::memmove(&data[newSize], &data[i], sizeof(int));
+                std::memmove(&data[newSize], &data[i], sizeof(int));
-            }
+            }
-            ++newSize;
+            ++newSize;
-        }
+        }
-    }
+    }
-    vec.resize(newSize);
+    vec.resize(newSize);
-}
+}
-int main() {
+int main() {
-	vector<int> vett;
+	vector<int> vett;
-	int vectorSize;
+	int vectorSize;
-	cout << "Insert the size of the vector: ";
+	cout << "Insert the size of the vector: ";
-	cin >> vectorSize;
+	cin >> vectorSize;
-	cout << endl;
+	cout << endl;
-	for (int i = 0,value; i < vectorSize; i++) {
+	for (int i = 0,value; i < vectorSize; i++) {
-		cout << "Insert a value: ";
+		cout << "Insert a value: ";
-		cin >> value;
+		cin >> value;
-		vett.push_back(value);
+		vett.push_back(value);
-		cout << endl;
+		cout << endl;
-	}
+	}
-	printVector(vett);
+	printVector(vett);
-	deletePeers(vett);
+	deletePeers(vett);
-	printVector(vett);
+	printVector(vett);
-    return 0;
+    return 0;
-}
+}

3AIN/array/maggiori_minori_array.cpp

@@ -1,33 +1,33 @@
-/*
+/*
-AUTORE: Vichingo455
+AUTORE: Vichingo455
-Leggere un array di interi di 6 posizioni, leggere un ulteriore numero intero, una funzione deve restituire quanti numeri memorizzati nell’array sono inferiori e quanti superiori dell’ultimo numero letto.
+Leggere un array di interi di 6 posizioni, leggere un ulteriore numero intero, una funzione deve restituire quanti numeri memorizzati nell’array sono inferiori e quanti superiori dell’ultimo numero letto.
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-#define SIZE 6
+#define SIZE 6
-using namespace std;
+using namespace std;
-void maggioriMinori(int array[], size_t array_size, int numero) {
+void maggioriMinori(int array[], size_t array_size, int numero) {
-	int maggiori = 0, minori = 0;
+	int maggiori = 0, minori = 0;
-	for (int i = 0; i < array_size; i++) {
+	for (int i = 0; i < array_size; i++) {
-		if (array[i] < numero)
+		if (array[i] < numero)
-			minori++;
+			minori++;
-		else if (array[i] > numero)
+		else if (array[i] > numero)
-			maggiori++;
+			maggiori++;
-	}
+	}
-	cout << "I numeri maggiori di " << numero << " sono " << maggiori << ", mentre quelli minori sono " << minori << endl;
+	cout << "I numeri maggiori di " << numero << " sono " << maggiori << ", mentre quelli minori sono " << minori << endl;
-}
+}
-int main() {
+int main() {
-	int array[SIZE],numero;
+	int array[SIZE],numero;
-	for (int i = 0; i < SIZE; i++) {
+	for (int i = 0; i < SIZE; i++) {
-		cout << "Inserisci il valore: ";
+		cout << "Inserisci il valore: ";
-		cin >> array[i];
+		cin >> array[i];
-		cout << endl;
+		cout << endl;
-	}
+	}
-	cout << "Inserisci il numero master: ";
+	cout << "Inserisci il numero master: ";
-	cin >> numero;
+	cin >> numero;
-	cout << endl;
+	cout << endl;
-	maggioriMinori(array, SIZE, numero);
+	maggioriMinori(array, SIZE, numero);
-    return 0;
+    return 0;
-}
+}

3AIN/array/media_variaz.cpp

@@ -1,47 +1,47 @@
-/*Dato in input un elenco di numeri casuali, determinare la media e la varianza.
+/*Dato in input un elenco di numeri casuali, determinare la media e la varianza.
-Suggerimento: sola lettura
+Suggerimento: sola lettura
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-using namespace std;
+using namespace std;
-
+
-#define NMAX 13
+#define NMAX 13
-
+
-void genera(int vett[], size_t n) {
+void genera(int vett[], size_t n) {
-	srand(time(NULL));
+	srand(time(NULL));
-	for(size_t i = 0; i< n; ++i)
+	for(size_t i = 0; i< n; ++i)
-		vett[i] = rand () % (100-10+1) + 10;
+		vett[i] = rand () % (100-10+1) + 10;
-}
+}
-
+
-float media(int vett[], size_t n) {
+float media(int vett[], size_t n) {
-	int media2;
+	int media2;
-	for (int i = 0; i <= n; i++)
+	for (int i = 0; i <= n; i++)
-		media2 += vett[i];
+		media2 += vett[i];
-	media2/= n;
+	media2/= n;
-	return media2;
+	return media2;
-}
+}
-
+
-float varianza(int vett[], size_t n) {
+float varianza(int vett[], size_t n) {
-	int varianza2;
+	int varianza2;
-	int media2;
+	int media2;
-	for (int i = 0; i <= n; i++)
+	for (int i = 0; i <= n; i++)
-		media2 += vett[i];
+		media2 += vett[i];
-	media2/= n;
+	media2/= n;
-	for (int i = 0; i <= n; i++)
+	for (int i = 0; i <= n; i++)
-		varianza2 = varianza2 + (1 / n * ((vett[i] - media2) * (vett[i] - media2)));
+		varianza2 = varianza2 + (1 / n * ((vett[i] - media2) * (vett[i] - media2)));
-	return varianza2;
+	return varianza2;
-}
+}
-
+
-int main()
+int main()
-{
+{
-	int card;
+	int card;
-	cout << "Inserisci il numero di valori da memorizzare dentro l'array: ";
+	cout << "Inserisci il numero di valori da memorizzare dentro l'array: ";
-	cin >> card;
+	cin >> card;
-	cout << endl;
+	cout << endl;
-	int vett[card];
+	int vett[card];
-	genera(vett, card);
+	genera(vett, card);
-	cout << "Media: " << media(vett, card) << endl;
+	cout << "Media: " << media(vett, card) << endl;
-	cout << "Varianza: " << varianza(vett, card) << endl;
+	cout << "Varianza: " << varianza(vett, card) << endl;
-	return 0;
+	return 0;
 }

3AIN/array/somma_array_zero.cpp

@@ -1,33 +1,33 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Dopo aver letto e memorizzato 8 numeri in un array, la funzione deve calcolare la somma di quelli negativi e memorizzare zero al loro posto
+Dopo aver letto e memorizzato 8 numeri in un array, la funzione deve calcolare la somma di quelli negativi e memorizzare zero al loro posto
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-int sommaNegativi(int array[], size_t size) {
+int sommaNegativi(int array[], size_t size) {
-	int somma;
+	int somma;
-	for (int i = 0; i < size; i++) {
+	for (int i = 0; i < size; i++) {
-		if (array[i] < 0) {
+		if (array[i] < 0) {
-			somma += array[i];
+			somma += array[i];
-			array[i] = 0;
+			array[i] = 0;
-		}
+		}
-	}
+	}
-	return somma;
+	return somma;
-}
+}
-int main() {
+int main() {
-	size_t dimensioneArray;
+	size_t dimensioneArray;
-	cout << "Inserisci il numero di valori da memorizzare: ";
+	cout << "Inserisci il numero di valori da memorizzare: ";
-	cin >> dimensioneArray;
+	cin >> dimensioneArray;
-	cout << endl;
+	cout << endl;
-	int array[dimensioneArray];
+	int array[dimensioneArray];
-	for (int i = 0; i < dimensioneArray; i++) {
+	for (int i = 0; i < dimensioneArray; i++) {
-		cout << "Inserisci il valore: ";
+		cout << "Inserisci il valore: ";
-		cin >> array[i];
+		cin >> array[i];
-		cout << endl;
+		cout << endl;
-	}
+	}
-	cout << "La somma dei numeri negativi e': " << sommaNegativi(array,dimensioneArray) << endl;
+	cout << "La somma dei numeri negativi e': " << sommaNegativi(array,dimensioneArray) << endl;
-    return 0;
+    return 0;
-}
+}

3AIN/array/somma_positivi.cpp

@@ -1,22 +1,22 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Somma dei numeri positivi
+Somma dei numeri positivi
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-int sommaPositivi(int array[], size_t array_size) {
+int sommaPositivi(int array[], size_t array_size) {
-	int somma = 0;
+	int somma = 0;
-	for (size_t i = 0; i < array_size; i++) {
+	for (size_t i = 0; i < array_size; i++) {
-		if (array[i] > 0)
+		if (array[i] > 0)
-			somma += array[i];
+			somma += array[i];
-	}
+	}
-	return somma;
+	return somma;
-}
+}
-int main() {
+int main() {
-	int array[] = {-1, 0, 1, 2, 3};
+	int array[] = {-1, 0, 1, 2, 3};
-	cout << "La somma dei valori positivi e': " << sommaPositivi(array,5) << endl;
+	cout << "La somma dei valori positivi e': " << sommaPositivi(array,5) << endl;
-    return 0;
+    return 0;
-}
+}

3AIN/array/stampa_coppie.cpp

@@ -1,35 +1,35 @@
-/*
+/*
-AUTORE: Vichingo455
+AUTORE: Vichingo455
-Stampa tutte le possibili coppie di valori in base all'input
+Stampa tutte le possibili coppie di valori in base all'input
-NOTA: Funziona solo se la compilazione su Windows e' a 64 bit
+NOTA: Funziona solo se la compilazione su Windows e' a 64 bit
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-void print(int array[],size_t size) {
+void print(int array[],size_t size) {
-	for (int i = 0; i < size; i++) {
+	for (int i = 0; i < size; i++) {
-		cout << "{" << array[i] << "," << array[i + 1] << "}" << endl;
+		cout << "{" << array[i] << "," << array[i + 1] << "}" << endl;
-		cout << "{" << array[i] << "," << array[i] << "}" << endl;
+		cout << "{" << array[i] << "," << array[i] << "}" << endl;
-		cout << "{" << array[i + 1] << "," << array[i] << "}" << endl;
+		cout << "{" << array[i + 1] << "," << array[i] << "}" << endl;
-		if (i > 0) {
+		if (i > 0) {
-			cout << "{" << array[i] << "," << array[i - 1] << "}" << endl;
+			cout << "{" << array[i] << "," << array[i - 1] << "}" << endl;
-			cout << "{" << array[i - 1] << "," << array[i] << "}" << endl;
+			cout << "{" << array[i - 1] << "," << array[i] << "}" << endl;
-		}
+		}
-	}
+	}
-}
+}
-int main() {
+int main() {
-	size_t size;
+	size_t size;
-	cout << "Inserisci la lunghezza dell'array: ";
+	cout << "Inserisci la lunghezza dell'array: ";
-	cin >> size;
+	cin >> size;
-	cout << endl;
+	cout << endl;
-	int array[size];
+	int array[size];
-	for (int i = 0; i < size; i++) {
+	for (int i = 0; i < size; i++) {
-		cout << "Inserisci il valore: ";
+		cout << "Inserisci il valore: ";
-		cin >> array[i];
+		cin >> array[i];
-		cout << endl;
+		cout << endl;
-	}
+	}
-	print(array,size);
+	print(array,size);
-    return 0;
+    return 0;
-}
+}

3AIN/file/es18_cdoctor.cpp

@@ -1,42 +1,42 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Scrivere una funzione che, ricevuti in ingresso un nome di file e una parola S, restituisca il numero di occorrenze di S all'interno del file oppure -1 in caso di errore nella gestione del file. La funzione opera sotto le seguenti condizioni: una parola è una sequenza di caratteri priva di whitespace; un file è composto da una sequenza di parole separate da whitespace; la ricerca delle occorrenze è di tipo case insensitive.
+Scrivere una funzione che, ricevuti in ingresso un nome di file e una parola S, restituisca il numero di occorrenze di S all'interno del file oppure -1 in caso di errore nella gestione del file. La funzione opera sotto le seguenti condizioni: una parola è una sequenza di caratteri priva di whitespace; un file è composto da una sequenza di parole separate da whitespace; la ricerca delle occorrenze è di tipo case insensitive.
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <cstring>
+#include <cstring>
-#include <cctype>
+#include <cctype>
-using namespace std;
+using namespace std;
-int searchWord(const char * fileName, const char * word) {
+int searchWord(const char * fileName, const char * word) {
-	FILE* file = fopen(fileName,"r");
+	FILE* file = fopen(fileName,"r");
-	unsigned occorrenze = 0;
+	unsigned occorrenze = 0;
-	if (file != NULL) {
+	if (file != NULL) {
-		char buffer[256];
+		char buffer[256];
-		char wordModified[256];
+		char wordModified[256];
-		for (size_t i = 0; i < strlen(word); i++) {
+		for (size_t i = 0; i < strlen(word); i++) {
-			if (!isupper(word[i])) {
+			if (!isupper(word[i])) {
-				wordModified[i] = toupper(word[i]);
+				wordModified[i] = toupper(word[i]);
-			}
+			}
-			else {
+			else {
-				wordModified[i] = word[i];
+				wordModified[i] = word[i];
-			}
+			}
-		}
+		}
-		while(fgets(buffer,sizeof(buffer),file)) {
+		while(fgets(buffer,sizeof(buffer),file)) {
-			for (size_t i = 0; buffer[i] != '\0'; i++) {
+			for (size_t i = 0; buffer[i] != '\0'; i++) {
-				if (isalpha(buffer[i]) && !isupper(buffer[i])) {
+				if (isalpha(buffer[i]) && !isupper(buffer[i])) {
-					buffer[i] = toupper(buffer[i]);
+					buffer[i] = toupper(buffer[i]);
-				}
+				}
-			}
+			}
-		}
+		}
-		fclose(file);
+		fclose(file);
-		return occorrenze;
+		return occorrenze;
-	}
+	}
-	else {
+	else {
-		perror("Errore durante l'apertura del file");
+		perror("Errore durante l'apertura del file");
-		return -1;
+		return -1;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int main(void) {
+int main(void) {
-	cout << "Occorrenze: " << searchWord("occorrenze.txt","parola") << endl;
+	cout << "Occorrenze: " << searchWord("occorrenze.txt","parola") << endl;
-	return 0;
+	return 0;
-}
+}

3AIN/file/es1_binary.cpp

@@ -1,37 +1,37 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Esercizio 1 File Binari
+Esercizio 1 File Binari
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdbool.h>
+#include <stdbool.h>
-using namespace std;
+using namespace std;
-int writeBinary(char * const fileName, size_t elements) {
+int writeBinary(char * const fileName, size_t elements) {
-	FILE* file = fopen(fileName, "wb");
+	FILE* file = fopen(fileName, "wb");
-	if (file == NULL) {
+	if (file == NULL) {
-		perror("Errore durante l'apertura del file di scrittura");
+		perror("Errore durante l'apertura del file di scrittura");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		int arr[elements];
+		int arr[elements];
-		for (size_t i = 0; i < elements; i++) {
+		for (size_t i = 0; i < elements; i++) {
-			arr[i] = i;
+			arr[i] = i;
-		}
+		}
-		int count = sizeof(arr) / sizeof(arr[0]);
+		int count = sizeof(arr) / sizeof(arr[0]);
-		int written = fwrite(&arr, sizeof(int), count,file);
+		int written = fwrite(&arr, sizeof(int), count,file);
-		fclose(file);
+		fclose(file);
-		return written;
+		return written;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int main(void) {
+int main(void) {
-	char file1[] = "file_70.bin";
+	char file1[] = "file_70.bin";
-	unsigned elements1 = 70;
+	unsigned elements1 = 70;
-	char file2[] = "file_100.bin";
+	char file2[] = "file_100.bin";
-	unsigned elements2 = 100;
+	unsigned elements2 = 100;
-	char file3[] = "file_200.bin";
+	char file3[] = "file_200.bin";
-	unsigned elements3 = 200;
+	unsigned elements3 = 200;
-	printf("Dimensione del tipo int: %d\n",sizeof(int));
+	printf("Dimensione del tipo int: %d\n",sizeof(int));
-	printf("Elementi scritti con successo (file %s): %d\n",file1,writeBinary(file1,elements1));
+	printf("Elementi scritti con successo (file %s): %d\n",file1,writeBinary(file1,elements1));
-	printf("Elementi scritti con successo (file %s): %d\n",file2,writeBinary(file2,elements2));
+	printf("Elementi scritti con successo (file %s): %d\n",file2,writeBinary(file2,elements2));
-	printf("Elementi scritti con successo (file %s): %d\n",file3,writeBinary(file3,elements3));
+	printf("Elementi scritti con successo (file %s): %d\n",file3,writeBinary(file3,elements3));
-	return 0;
+	return 0;
-}
+}

3AIN/file/es2.cpp

@@ -1,20 +1,20 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Esercizio 2 file
+Esercizio 2 file
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <cstring>
+#include <cstring>
-#include <cctype>
+#include <cctype>
-using namespace std;
+using namespace std;
-void leggiFileRigaPerRiga(const char* fileName) {
+void leggiFileRigaPerRiga(const char* fileName) {
-	FILE* file = fopen(fileName, "r");
+	FILE* file = fopen(fileName, "r");
-	char riga[256];
+	char riga[256];
-	while(fgets(riga,sizeof(riga),file))
+	while(fgets(riga,sizeof(riga),file))
-		cout << riga;
+		cout << riga;
-	cout << endl;
+	cout << endl;
-	fclose(file);
+	fclose(file);
-}
+}
-int main(void) {
+int main(void) {
-	leggiFileRigaPerRiga("vmware.log");
+	leggiFileRigaPerRiga("vmware.log");
-	return 0;
+	return 0;
 }

3AIN/file/es2_binary.cpp

@@ -1,91 +1,91 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Esercizio 2 File Binari
+Esercizio 2 File Binari
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdbool.h>
+#include <stdbool.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <time.h>
+#include <time.h>
-using namespace std;
+using namespace std;
-void initializeArray(int array[], size_t size) {
+void initializeArray(int array[], size_t size) {
-	//size_t size = sizeof(array) / sizeof(array[0]);
+	//size_t size = sizeof(array) / sizeof(array[0]);
-	for (size_t i = 0; i < size; i++) {
+	for (size_t i = 0; i < size; i++) {
-		array[i] = 0;
+		array[i] = 0;
-	}
+	}
-}
+}
-int readBinary(char * const fileName, int buffer[], size_t count) {
+int readBinary(char * const fileName, int buffer[], size_t count) {
-	FILE* file = fopen(fileName, "rb");
+	FILE* file = fopen(fileName, "rb");
-	if (file == NULL) {
+	if (file == NULL) {
-		perror("Errore nell'apertura del file di lettura");
+		perror("Errore nell'apertura del file di lettura");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		fseek(file,0,SEEK_SET);
+		fseek(file,0,SEEK_SET);
-		int read = fread(buffer,sizeof(int),count,file);
+		int read = fread(buffer,sizeof(int),count,file);
-		fclose(file);
+		fclose(file);
-		return read;
+		return read;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int readSpecific(char * const fileName, int &buffer, unsigned index) {
+int readSpecific(char * const fileName, int &buffer, unsigned index) {
-	FILE* file = fopen(fileName, "rb");
+	FILE* file = fopen(fileName, "rb");
-	if (file == NULL) {
+	if (file == NULL) {
-		perror("Errore nell'apertura del file di lettura");
+		perror("Errore nell'apertura del file di lettura");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		unsigned n = (index-1);
+		unsigned n = (index-1);
-		fseek(file,n * sizeof(int),SEEK_SET);
+		fseek(file,n * sizeof(int),SEEK_SET);
-		int read = fread(&buffer,sizeof(int),1,file);
+		int read = fread(&buffer,sizeof(int),1,file);
-		fclose(file);
+		fclose(file);
-		return read;
+		return read;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int readBeforeLast(char * const fileName, int &buffer) {
+int readBeforeLast(char * const fileName, int &buffer) {
-	FILE* file = fopen(fileName, "rb");
+	FILE* file = fopen(fileName, "rb");
-	if (file == NULL) {
+	if (file == NULL) {
-		perror("Errore nell'apertura del file di lettura");
+		perror("Errore nell'apertura del file di lettura");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		fseek(file,-sizeof(int),SEEK_END);
+		fseek(file,-sizeof(int),SEEK_END);
-		int read = fread(&buffer,sizeof(int),1,file);
+		int read = fread(&buffer,sizeof(int),1,file);
-		fclose(file);
+		fclose(file);
-		return read;
+		return read;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int readRandom(char * const fileName, int &buffer, unsigned count_max) {
+int readRandom(char * const fileName, int &buffer, unsigned count_max) {
-	FILE* file = fopen(fileName, "rb");
+	FILE* file = fopen(fileName, "rb");
-	if (file == NULL) {
+	if (file == NULL) {
-		perror("Errore nell'apertura del file di lettura");
+		perror("Errore nell'apertura del file di lettura");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		srand(time(NULL));
+		srand(time(NULL));
-		unsigned n = rand() % (count_max + 1);
+		unsigned n = rand() % (count_max + 1);
-		fseek(file,n * sizeof(int),SEEK_SET);
+		fseek(file,n * sizeof(int),SEEK_SET);
-		int read = fread(&buffer,sizeof(int),1,file);
+		int read = fread(&buffer,sizeof(int),1,file);
-		fclose(file);
+		fclose(file);
-		return read;
+		return read;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int main(void) {
+int main(void) {
-	char file[] = "file_200.bin";
+	char file[] = "file_200.bin";
-	//char file[] = "file.txt";
+	//char file[] = "file.txt";
-	int arr[200];
+	int arr[200];
-	int num = 0,numlast = 0,random = 0;
+	int num = 0,numlast = 0,random = 0;
-	size_t count = sizeof(arr) / sizeof(arr[0]);
+	size_t count = sizeof(arr) / sizeof(arr[0]);
-	initializeArray(arr,count);
+	initializeArray(arr,count);
-	printf("Valori letti dal file %s: %d\n",file,readBinary(file,arr,count));
+	printf("Valori letti dal file %s: %d\n",file,readBinary(file,arr,count));
-	printf("Valori letti dal file %s: %d\n",file,readSpecific(file,num,2));
+	printf("Valori letti dal file %s: %d\n",file,readSpecific(file,num,2));
-	printf("Valori letti dal file %s: %d\n",file,readBeforeLast(file,numlast));
+	printf("Valori letti dal file %s: %d\n",file,readBeforeLast(file,numlast));
-	printf("Valori letti dal file %s: %d\n",file,readRandom(file,random,count));
+	printf("Valori letti dal file %s: %d\n",file,readRandom(file,random,count));
-	printf("Lettura completa: ");
+	printf("Lettura completa: ");
-	for (size_t i = 0; i < count; i++) {
+	for (size_t i = 0; i < count; i++) {
-		printf("%d ", arr[i]);
+		printf("%d ", arr[i]);
-	}
+	}
-	printf("\n");
+	printf("\n");
-	printf("Risultato lettura specifica: %d\n",num);
+	printf("Risultato lettura specifica: %d\n",num);
-	printf("Risultato lettura penultimo elemento: %d\n",numlast);
+	printf("Risultato lettura penultimo elemento: %d\n",numlast);
-	printf("Risultato lettura casuale: %d\n",random);
+	printf("Risultato lettura casuale: %d\n",random);
-	return 0;
+	return 0;
-}
+}

3AIN/file/es3_binary.cpp

@@ -1,85 +1,85 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Esercizio 3 File Binari
+Esercizio 3 File Binari
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdbool.h>
+#include <stdbool.h>
-#include <string.h>
+#include <string.h>
-using namespace std;
+using namespace std;
-typedef struct {
+typedef struct {
-	char nome[20];
+	char nome[20];
-	char cognome[20];
+	char cognome[20];
-	float reddito;
+	float reddito;
-} Persona;
+} Persona;
-Persona leggiPersona(const char * fileName) {
+Persona leggiPersona(const char * fileName) {
-	Persona persona;
+	Persona persona;
-	FILE* file = fopen(fileName, "rb");
+	FILE* file = fopen(fileName, "rb");
-	if (file != NULL) {
+	if (file != NULL) {
-		Persona persona;
+		Persona persona;
-		fread(&persona, sizeof(persona), 1, file);
+		fread(&persona, sizeof(persona), 1, file);
-		fclose(file);
+		fclose(file);
-	} else {
+	} else {
-		perror("Errore durante l'apertura del file di lettura");
+		perror("Errore durante l'apertura del file di lettura");
-		return persona;
+		return persona;
-	}
+	}
-	return persona;
+	return persona;
-}
+}
-int leggiPersone(const char * fileName, Persona persone[], const size_t count) {
+int leggiPersone(const char * fileName, Persona persone[], const size_t count) {
-	FILE * file = fopen(fileName, "rb");
+	FILE * file = fopen(fileName, "rb");
-	if (file != NULL) {
+	if (file != NULL) {
-		int read = fread(persone, sizeof(Persona), count, file);
+		int read = fread(persone, sizeof(Persona), count, file);
-		return read;
+		return read;
-	} else {
+	} else {
-		perror("Errore durante l'apertura del file di lettura");
+		perror("Errore durante l'apertura del file di lettura");
-		return -1;
+		return -1;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int scriviPersona(const char * fileName, const Persona persona) {
+int scriviPersona(const char * fileName, const Persona persona) {
-	FILE * file = fopen(fileName, "wb");
+	FILE * file = fopen(fileName, "wb");
-	if (file != NULL) {
+	if (file != NULL) {
-		int written = fwrite(&persona, sizeof(persona), 1, file);
+		int written = fwrite(&persona, sizeof(persona), 1, file);
-		fclose(file);
+		fclose(file);
-		return written;
+		return written;
-	} else {
+	} else {
-		perror("Errore durante l'apertura del file di scrittura");
+		perror("Errore durante l'apertura del file di scrittura");
-		return -1;
+		return -1;
-	}
+	}
-}
+}
-Persona memorizzaPersona(const char nome[], const char cognome[], const float reddito) {
+Persona memorizzaPersona(const char nome[], const char cognome[], const float reddito) {
-	Persona persona;
+	Persona persona;
-	strcpy(persona.nome, nome);
+	strcpy(persona.nome, nome);
-	strcpy(persona.cognome, cognome);
+	strcpy(persona.cognome, cognome);
-	persona.reddito = reddito;
+	persona.reddito = reddito;
-	return persona;
+	return persona;
-}
+}
-int convertiText(const char * binaryName, const char * textName, const size_t count) {
+int convertiText(const char * binaryName, const char * textName, const size_t count) {
-	FILE* read = fopen(binaryName, "rb");
+	FILE* read = fopen(binaryName, "rb");
-	FILE* write = fopen(textName, "wt");
+	FILE* write = fopen(textName, "wt");
-	if (read == NULL || write == NULL) {
+	if (read == NULL || write == NULL) {
-		perror("Errore durante l'apertura di uno dei file");
+		perror("Errore durante l'apertura di uno dei file");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		Persona buffer[count];
+		Persona buffer[count];
-		int written = 0;
+		int written = 0;
-		fread(buffer,sizeof(Persona),count,read);
+		fread(buffer,sizeof(Persona),count,read);
-		for (size_t i = 0; i < count; i++) {
+		for (size_t i = 0; i < count; i++) {
-			written += fprintf(write,"%s %s %f", buffer[i].nome, buffer[i].cognome, buffer[i].reddito);
+			written += fprintf(write,"%s %s %f", buffer[i].nome, buffer[i].cognome, buffer[i].reddito);
-		}
+		}
-		return written;
+		return written;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int main(void) {
+int main(void) {
-	Persona persona;
+	Persona persona;
-	char file[] = "persona.bin";
+	char file[] = "persona.bin";
-	char file2[] = "persona2.bin";
+	char file2[] = "persona2.bin";
-	printf("Dimensione del tipo Persona: %d\n", sizeof(persona));
+	printf("Dimensione del tipo Persona: %d\n", sizeof(persona));
-	persona = memorizzaPersona("Mario", "Rossi", 1350.50);
+	persona = memorizzaPersona("Mario", "Rossi", 1350.50);
-	printf("Valori scritti su file binario %s: %d\n", file, scriviPersona("persona.bin", persona));
+	printf("Valori scritti su file binario %s: %d\n", file, scriviPersona("persona.bin", persona));
-	persona = leggiPersona(file);
+	persona = leggiPersona(file);
-	printf("Valori letti dal file binario %s: %s, %s, %f\n", file, persona.nome, persona.cognome, persona.reddito);
+	printf("Valori letti dal file binario %s: %s, %s, %f\n", file, persona.nome, persona.cognome, persona.reddito);
-	Persona persone[5];
+	Persona persone[5];
-	printf("Numero di valori letti dal file binario %s: %d\n", file2, leggiPersone(file2, persone, 5));
+	printf("Numero di valori letti dal file binario %s: %d\n", file2, leggiPersone(file2, persone, 5));
-	return 0;
+	return 0;
-}
+}

3AIN/file/es6_binary.cpp

@@ -1,51 +1,51 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Esercizio 6 File Binari
+Esercizio 6 File Binari
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdbool.h>
+#include <stdbool.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <time.h>
+#include <time.h>
-using namespace std;
+using namespace std;
-int countBitOne(const char string[], const unsigned bit, const size_t lenght) {
+int countBitOne(const char string[], const unsigned bit, const size_t lenght) {
-	unsigned count = 0;
+	unsigned count = 0;
-	for (size_t i = 0; i < lenght; i++) {
+	for (size_t i = 0; i < lenght; i++) {
-		if ((string[i] >> bit) & 1) {
+		if ((string[i] >> bit) & 1) {
-			count++;
+			count++;
-		}
+		}
-	}
+	}
-	return count;
+	return count;
-}
+}
-void generate(char string[], const size_t size) {
+void generate(char string[], const size_t size) {
-	srand(time(NULL));
+	srand(time(NULL));
-	for (size_t i = 0; i < size; i++) {
+	for (size_t i = 0; i < size; i++) {
-		string[i] = (rand() % 26) + 'A';
+		string[i] = (rand() % 26) + 'A';
-	}
+	}
-}
+}
-int writeBinary(const char * fileName, const char arr[], const size_t count) {
+int writeBinary(const char * fileName, const char arr[], const size_t count) {
-	FILE* file = fopen(fileName,"wb");
+	FILE* file = fopen(fileName,"wb");
-	if (file != NULL) {
+	if (file != NULL) {
-		int written = fwrite(arr,sizeof(char),count,file);
+		int written = fwrite(arr,sizeof(char),count,file);
-		fclose(file);
+		fclose(file);
-		return written;
+		return written;
-	} else {
+	} else {
-		perror("Errore durante l'apertura del file di scrittura");
+		perror("Errore durante l'apertura del file di scrittura");
-		return -1;
+		return -1;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int main(void) {
+int main(void) {
-	char fileName[] = "girmilloblu.bin";
+	char fileName[] = "girmilloblu.bin";
-	char arr[10];
+	char arr[10];
-	unsigned bitNumber = 3;
+	unsigned bitNumber = 3;
-	generate(arr,sizeof(arr));
+	generate(arr,sizeof(arr));
-	printf("Array generato: ");
+	printf("Array generato: ");
-	for (unsigned i = 0; i < sizeof(arr); i++) {
+	for (unsigned i = 0; i < sizeof(arr); i++) {
-		printf("%c", arr[i]);
+		printf("%c", arr[i]);
-	}
+	}
-	printf("\n");
+	printf("\n");
-	size_t count = sizeof(arr) / sizeof(arr[0]);
+	size_t count = sizeof(arr) / sizeof(arr[0]);
-	printf("Valori scritti nel file %s: %d\n", fileName, writeBinary(fileName,arr,count));
+	printf("Valori scritti nel file %s: %d\n", fileName, writeBinary(fileName,arr,count));
-	printf("Byte con il bit %d a 1: %d", bitNumber, countBitOne(arr,bitNumber,sizeof(arr)));
+	printf("Byte con il bit %d a 1: %d", bitNumber, countBitOne(arr,bitNumber,sizeof(arr)));
-	return 0;
+	return 0;
-}
+}

3AIN/file/es7_binary.cpp

@@ -1,32 +1,32 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Esercizio 7 File Binari
+Esercizio 7 File Binari
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdbool.h>
+#include <stdbool.h>
-#include <stdint.h>
+#include <stdint.h>
-using namespace std;
+using namespace std;
-void fChangeEndianness(char * fileName) {
+void fChangeEndianness(char * fileName) {
-	FILE *file = fopen(fileName, "rb+");
+	FILE *file = fopen(fileName, "rb+");
-    if (!file) {
+    if (!file) {
-        perror("Errore durante l'apertura del file di lettura/scrittura");
+        perror("Errore durante l'apertura del file di lettura/scrittura");
-        return;
+        return;
-    }
+    }
-    uint8_t buffer[4];
+    uint8_t buffer[4];
-    long pos = 0;
+    long pos = 0;
-    while (fread(buffer, 1, 4, file) == 4) {
+    while (fread(buffer, 1, 4, file) == 4) {
-        uint8_t tmp;
+        uint8_t tmp;
-        tmp = buffer[0]; buffer[0] = buffer[3]; buffer[3] = tmp;
+        tmp = buffer[0]; buffer[0] = buffer[3]; buffer[3] = tmp;
-        tmp = buffer[1]; buffer[1] = buffer[2]; buffer[2] = tmp;
+        tmp = buffer[1]; buffer[1] = buffer[2]; buffer[2] = tmp;
-        fseek(file, pos, SEEK_SET);
+        fseek(file, pos, SEEK_SET);
-        fwrite(buffer, 1, 4, file);
+        fwrite(buffer, 1, 4, file);
-        pos += 4;
+        pos += 4;
-        fseek(file, pos, SEEK_SET);
+        fseek(file, pos, SEEK_SET);
-    }
+    }
-    fclose(file);
+    fclose(file);
-}
+}
-int main(void) {
+int main(void) {
-	char file[] = "indiano.bin";
+	char file[] = "indiano.bin";
-	fChangeEndianness(file);
+	fChangeEndianness(file);
-	return 0;
+	return 0;
-}
+}

3AIN/file/es8_binary.cpp

@@ -1,65 +1,65 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Esercizio 8 File Binari
+Esercizio 8 File Binari
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdbool.h>
+#include <stdbool.h>
-using namespace std;
+using namespace std;
-int convertBinaryIntegers(const char * textFile, const char * binaryFile, const size_t count) {
+int convertBinaryIntegers(const char * textFile, const char * binaryFile, const size_t count) {
-	FILE* text = fopen(textFile,"r");
+	FILE* text = fopen(textFile,"r");
-	FILE* binary = fopen(binaryFile,"wb");
+	FILE* binary = fopen(binaryFile,"wb");
-	if (text == NULL || binary == NULL) {
+	if (text == NULL || binary == NULL) {
-		perror("Errore durante l'apertura dei file");
+		perror("Errore durante l'apertura dei file");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		char buffer[count];
+		char buffer[count];
-		int array[count];
+		int array[count];
-		size_t i = 0;
+		size_t i = 0;
-		for (size_t i = 0; i < count; i++) {
+		for (size_t i = 0; i < count; i++) {
-			array[i] = 0;
+			array[i] = 0;
-		}
+		}
-		while (fgets(buffer,sizeof(buffer),text) && i < count) {
+		while (fgets(buffer,sizeof(buffer),text) && i < count) {
-			int numero;
+			int numero;
-        	if (sscanf(buffer, "%d", &numero) == 1) {
+        	if (sscanf(buffer, "%d", &numero) == 1) {
-            	array[i] = numero;
+            	array[i] = numero;
-            	i++;
+            	i++;
-        	}
+        	}
-		}
+		}
-		fwrite(&array,sizeof(int),count,binary);
+		fwrite(&array,sizeof(int),count,binary);
-		fclose(text);
+		fclose(text);
-		fclose(binary);
+		fclose(binary);
-		return 0;
+		return 0;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int convertBinaryFloat(const char * textFile, const char * binaryFile, const size_t count) {
+int convertBinaryFloat(const char * textFile, const char * binaryFile, const size_t count) {
-	FILE* text = fopen(textFile,"r");
+	FILE* text = fopen(textFile,"r");
-	FILE* binary = fopen(binaryFile,"wb");
+	FILE* binary = fopen(binaryFile,"wb");
-	if (text == NULL || binary == NULL) {
+	if (text == NULL || binary == NULL) {
-		perror("Errore durante l'apertura dei file");
+		perror("Errore durante l'apertura dei file");
-		return -1;
+		return -1;
-	} else {
+	} else {
-		char buffer[count];
+		char buffer[count];
-		float array[count];
+		float array[count];
-		size_t i = 0;
+		size_t i = 0;
-		for (size_t i = 0; i < count; i++) {
+		for (size_t i = 0; i < count; i++) {
-			array[i] = 0;
+			array[i] = 0;
-		}
+		}
-		while (fgets(buffer,sizeof(buffer),text) && i < count) {
+		while (fgets(buffer,sizeof(buffer),text) && i < count) {
-			float numero;
+			float numero;
-        	if (sscanf(buffer, "%f", &numero) == 1) {
+        	if (sscanf(buffer, "%f", &numero) == 1) {
-            	array[i] = numero;
+            	array[i] = numero;
-            	i++;
+            	i++;
-        	}
+        	}
-		}
+		}
-		fwrite(&array,sizeof(int),count,binary);
+		fwrite(&array,sizeof(int),count,binary);
-		fclose(text);
+		fclose(text);
-		fclose(binary);
+		fclose(binary);
-		return 0;
+		return 0;
-	}
+	}
-	return -1;
+	return -1;
-}
+}
-int main(void) {
+int main(void) {
-	//return convertBinaryIntegers("test.txt","test.bin",20);
+	//return convertBinaryIntegers("test.txt","test.bin",20);
-	return convertBinaryFloat("test.txt","test.bin",20);
+	return convertBinaryFloat("test.txt","test.bin",20);
-}
+}

3AIN/file/filtralinee_fauser.cpp

@@ -1,35 +1,35 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Scrivere una funzione che accetti come parametri d'ingresso due nomi di file e una parola P e
+Scrivere una funzione che accetti come parametri d'ingresso due nomi di file e una parola P e
- memorizzi nel secondo file le sole righe del primo che contengono P
+ memorizzi nel secondo file le sole righe del primo che contengono P
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <cstring>
+#include <cstring>
-#include <cctype>
+#include <cctype>
-using namespace std;
+using namespace std;
-void filtraLinee(const char* fileNameRead, const char* fileNameWrite, const char* word) {
+void filtraLinee(const char* fileNameRead, const char* fileNameWrite, const char* word) {
-	FILE* file = fopen(fileNameRead,"r");
+	FILE* file = fopen(fileNameRead,"r");
-	if (file != NULL) {
+	if (file != NULL) {
-		FILE* destination = fopen(fileNameWrite,"w");
+		FILE* destination = fopen(fileNameWrite,"w");
-		if (destination != NULL) {
+		if (destination != NULL) {
-			char riga[256];
+			char riga[256];
-			while (fgets(riga, sizeof(riga),file)) {
+			while (fgets(riga, sizeof(riga),file)) {
-				if (strstr(riga, word)) {
+				if (strstr(riga, word)) {
-					fputs(riga, destination);
+					fputs(riga, destination);
-				}
+				}
-			}
+			}
-			fclose(destination);
+			fclose(destination);
-		}
+		}
-		else {
+		else {
-			perror("Errore nella scrittura del file");
+			perror("Errore nella scrittura del file");
-		}
+		}
-		fclose(file);
+		fclose(file);
-	}
+	}
-	else {
+	else {
-		perror("Errore nella lettura del file");
+		perror("Errore nella lettura del file");
-	}
+	}
-}
+}
-int main(void) {
+int main(void) {
-	filtraLinee("righe.txt","righeParole.txt","Moodle");
+	filtraLinee("righe.txt","righeParole.txt","Moodle");
-	return 0;
+	return 0;
-}
+}

3AIN/file/fsorts.h

@@ -1,176 +1,176 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Algoritmi sort su file
+Algoritmi sort su file
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdlib.h>
+#include <stdlib.h>
-#include <stdbool.h>
+#include <stdbool.h>
-void fSelectionSort(const char *nomeFile) {
+void fSelectionSort(const char *nomeFile) {
-    FILE *fp = fopen(nomeFile, "r+b");
+    FILE *fp = fopen(nomeFile, "r+b");
-    if (fp == NULL) {
+    if (fp == NULL) {
-        perror("Errore nell'apertura del file");
+        perror("Errore nell'apertura del file");
-        return;
+        return;
-    }
+    }
-    fseek(fp, 0, SEEK_END);
+    fseek(fp, 0, SEEK_END);
-    long dimensioneFile = ftell(fp);
+    long dimensioneFile = ftell(fp);
-    fseek(fp, 0, SEEK_SET);
+    fseek(fp, 0, SEEK_SET);
-    size_t n = dimensioneFile / sizeof(int);
+    size_t n = dimensioneFile / sizeof(int);
-    int valoreMin, valoreCorrente;
+    int valoreMin, valoreCorrente;
-    size_t indiceMin;
+    size_t indiceMin;
-    int temp;
+    int temp;
-    for (size_t i = 0; i < n - 1; i++) {
+    for (size_t i = 0; i < n - 1; i++) {
-        indiceMin = i;
+        indiceMin = i;
-        fseek(fp, i * sizeof(int), SEEK_SET);
+        fseek(fp, i * sizeof(int), SEEK_SET);
-        fread(&valoreMin, sizeof(int), 1, fp);
+        fread(&valoreMin, sizeof(int), 1, fp);
-        for (size_t j = i + 1; j < n; j++) {
+        for (size_t j = i + 1; j < n; j++) {
-            fseek(fp, j * sizeof(int), SEEK_SET);
+            fseek(fp, j * sizeof(int), SEEK_SET);
-            fread(&valoreCorrente, sizeof(int), 1, fp);
+            fread(&valoreCorrente, sizeof(int), 1, fp);
-            if (valoreCorrente < valoreMin) {
+            if (valoreCorrente < valoreMin) {
-                valoreMin = valoreCorrente;
+                valoreMin = valoreCorrente;
-                indiceMin = j;
+                indiceMin = j;
-            }
+            }
-        }
+        }
-        if (indiceMin != i) {
+        if (indiceMin != i) {
-            fseek(fp, i * sizeof(int), SEEK_SET);
+            fseek(fp, i * sizeof(int), SEEK_SET);
-            fread(&temp, sizeof(int), 1, fp);
+            fread(&temp, sizeof(int), 1, fp);
-            int valoreTemp;
+            int valoreTemp;
-            fseek(fp, indiceMin * sizeof(int), SEEK_SET);
+            fseek(fp, indiceMin * sizeof(int), SEEK_SET);
-            fread(&valoreTemp, sizeof(int), 1, fp);
+            fread(&valoreTemp, sizeof(int), 1, fp);
-            fseek(fp, i * sizeof(int), SEEK_SET);
+            fseek(fp, i * sizeof(int), SEEK_SET);
-            fwrite(&valoreTemp, sizeof(int), 1, fp);
+            fwrite(&valoreTemp, sizeof(int), 1, fp);
-            fseek(fp, indiceMin * sizeof(int), SEEK_SET);
+            fseek(fp, indiceMin * sizeof(int), SEEK_SET);
-            fwrite(&temp, sizeof(int), 1, fp);
+            fwrite(&temp, sizeof(int), 1, fp);
-        }
+        }
-    }
+    }
-    fclose(fp);
+    fclose(fp);
-}
+}
-void fBubbleSort(const char *nomeFile) {
+void fBubbleSort(const char *nomeFile) {
-    FILE *fp = fopen(nomeFile, "r+b");
+    FILE *fp = fopen(nomeFile, "r+b");
-    if (fp == NULL) {
+    if (fp == NULL) {
-        perror("Errore nell'apertura del file");
+        perror("Errore nell'apertura del file");
-        return;
+        return;
-    }
+    }
-    fseek(fp, 0, SEEK_END);
+    fseek(fp, 0, SEEK_END);
-    long dimensioneFile = ftell(fp);
+    long dimensioneFile = ftell(fp);
-    fseek(fp, 0, SEEK_SET);
+    fseek(fp, 0, SEEK_SET);
-    size_t n = dimensioneFile / sizeof(int);
+    size_t n = dimensioneFile / sizeof(int);
-    int valore1, valore2;
+    int valore1, valore2;
-    bool scambiato;
+    bool scambiato;
-    for (size_t i = 0; i < n - 1; i++) {
+    for (size_t i = 0; i < n - 1; i++) {
-        scambiato = false;
+        scambiato = false;
-        for (size_t j = 0; j < n - i - 1; j++) {
+        for (size_t j = 0; j < n - i - 1; j++) {
-            fseek(fp, j * sizeof(int), SEEK_SET);
+            fseek(fp, j * sizeof(int), SEEK_SET);
-            if (fread(&valore1, sizeof(int), 1, fp) != 1) {
+            if (fread(&valore1, sizeof(int), 1, fp) != 1) {
-                perror("Errore di lettura del file");
+                perror("Errore di lettura del file");
-                fclose(fp);
+                fclose(fp);
-                return;
+                return;
-            }
+            }
-            fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
+            fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
-            if (fread(&valore2, sizeof(int), 1, fp) != 1) {
+            if (fread(&valore2, sizeof(int), 1, fp) != 1) {
-                perror("Errore di lettura del file");
+                perror("Errore di lettura del file");
-                fclose(fp);
+                fclose(fp);
-                return;
+                return;
-            }
+            }
-            if (valore1 > valore2) {
+            if (valore1 > valore2) {
-                fseek(fp, j * sizeof(int), SEEK_SET);
+                fseek(fp, j * sizeof(int), SEEK_SET);
-                if (fwrite(&valore2, sizeof(int), 1, fp) != 1) {
+                if (fwrite(&valore2, sizeof(int), 1, fp) != 1) {
-                    perror("Errore di scrittura nel file");
+                    perror("Errore di scrittura nel file");
-                    fclose(fp);
+                    fclose(fp);
-                    return;
+                    return;
-                }
+                }
-                fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
+                fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
-                if (fwrite(&valore1, sizeof(int), 1, fp) != 1) {
+                if (fwrite(&valore1, sizeof(int), 1, fp) != 1) {
-                    perror("Errore di scrittura nel file");
+                    perror("Errore di scrittura nel file");
-                    fclose(fp);
+                    fclose(fp);
-                    return;
+                    return;
-                }
+                }
-                scambiato = true;
+                scambiato = true;
-            }
+            }
-        }
+        }
-        if (!scambiato) {
+        if (!scambiato) {
-            break;
+            break;
-        }
+        }
-    }
+    }
-    fclose(fp);
+    fclose(fp);
-}
+}
-void swap(FILE *fp, int pos1, int pos2, size_t elementSize) {
+void swap(FILE *fp, int pos1, int pos2, size_t elementSize) {
-    int temp1, temp2;
+    int temp1, temp2;
-    fseek(fp, pos1 * elementSize, SEEK_SET);
+    fseek(fp, pos1 * elementSize, SEEK_SET);
-    fread(&temp1, elementSize, 1, fp);
+    fread(&temp1, elementSize, 1, fp);
-    fseek(fp, pos2 * elementSize, SEEK_SET);
+    fseek(fp, pos2 * elementSize, SEEK_SET);
-    fread(&temp2, elementSize, 1, fp);
+    fread(&temp2, elementSize, 1, fp);
-    fseek(fp, pos1 * elementSize, SEEK_SET);
+    fseek(fp, pos1 * elementSize, SEEK_SET);
-    fwrite(&temp2, elementSize, 1, fp);
+    fwrite(&temp2, elementSize, 1, fp);
-    fseek(fp, pos2 * elementSize, SEEK_SET);
+    fseek(fp, pos2 * elementSize, SEEK_SET);
-    fwrite(&temp1, elementSize, 1, fp);
+    fwrite(&temp1, elementSize, 1, fp);
-}
+}
-int partition(FILE *fp, int low, int high, size_t elementSize) {
+int partition(FILE *fp, int low, int high, size_t elementSize) {
-    int pivot;
+    int pivot;
-    fseek(fp, high * elementSize, SEEK_SET);
+    fseek(fp, high * elementSize, SEEK_SET);
-    fread(&pivot, elementSize, 1, fp);
+    fread(&pivot, elementSize, 1, fp);
-    int i = low - 1;
+    int i = low - 1;
-    for (int j = low; j < high; j++) {
+    for (int j = low; j < high; j++) {
-        int current;
+        int current;
-        fseek(fp, j * elementSize, SEEK_SET);
+        fseek(fp, j * elementSize, SEEK_SET);
-        fread(&current, elementSize, 1, fp);
+        fread(&current, elementSize, 1, fp);
-        if (current < pivot) {
+        if (current < pivot) {
-            i++;
+            i++;
-            swap(fp, i, j, elementSize);
+            swap(fp, i, j, elementSize);
-        }
+        }
-    }
+    }
-    swap(fp, i + 1, high, elementSize);
+    swap(fp, i + 1, high, elementSize);
-    return i + 1;
+    return i + 1;
-}
+}
-/*
+/*
-Funzione per ordinamento in-place con Quick Sort
+Funzione per ordinamento in-place con Quick Sort
-Parametri:
+Parametri:
-FILE *fp: Questo parametro è un puntatore a un file aperto in modalità binaria, cioè è il "cassetto" dove sono memorizzati i dati (gli elementi) che vuoi ordinare. Quando chiamiamo le funzioni come fseek, fread o fwrite, usiamo questo puntatore per dire al programma in quale file operare.
+FILE *fp: Questo parametro è un puntatore a un file aperto in modalità binaria, cioè è il "cassetto" dove sono memorizzati i dati (gli elementi) che vuoi ordinare. Quando chiamiamo le funzioni come fseek, fread o fwrite, usiamo questo puntatore per dire al programma in quale file operare.
-int low: Questo parametro rappresenta l'indice (cioè la "posizione") del primo elemento del gruppo (o "sottosequenza") di elementi del file che vogliamo ordinare. Ad esempio, se vuoi ordinare tutto il file, low sarà di solito 0, perché il primo elemento si trova alla posizione 0.
+int low: Questo parametro rappresenta l'indice (cioè la "posizione") del primo elemento del gruppo (o "sottosequenza") di elementi del file che vogliamo ordinare. Ad esempio, se vuoi ordinare tutto il file, low sarà di solito 0, perché il primo elemento si trova alla posizione 0.
-int high: Rappresenta l'indice dell'ultimo elemento del gruppo di elementi che stiamo considerando per l'ordinamento. Se il file contiene 100 elementi e numeriamo gli elementi da 0 a 99, allora per ordinare tutto il file useremo high = 99. In altre parole, fQuickSort ordina gli elementi dalle posizioni low a high.
+int high: Rappresenta l'indice dell'ultimo elemento del gruppo di elementi che stiamo considerando per l'ordinamento. Se il file contiene 100 elementi e numeriamo gli elementi da 0 a 99, allora per ordinare tutto il file useremo high = 99. In altre parole, fQuickSort ordina gli elementi dalle posizioni low a high.
-size_t elementSize: Questo parametro indica la dimensione, in byte, di ogni elemento contenuto nel file. Ad esempio, se il file contiene interi e ogni intero occupa 4 byte, userai sizeof(int) (che di solito vale 4) per questo parametro. È fondamentale perché la funzione deve sapere quanti byte saltare per passare da un elemento all’altro nel file: per raggiungere l’elemento in posizione i, il programma si sposta di i * elementSize byte dal principio del file.
+size_t elementSize: Questo parametro indica la dimensione, in byte, di ogni elemento contenuto nel file. Ad esempio, se il file contiene interi e ogni intero occupa 4 byte, userai sizeof(int) (che di solito vale 4) per questo parametro. È fondamentale perché la funzione deve sapere quanti byte saltare per passare da un elemento all’altro nel file: per raggiungere l’elemento in posizione i, il programma si sposta di i * elementSize byte dal principio del file.
-*/
+*/
-void fQuickSort(FILE *fp, int low, int high, size_t elementSize) {
+void fQuickSort(FILE *fp, int low, int high, size_t elementSize) {
-    if (low < high) {
+    if (low < high) {
-        int pi = partition(fp, low, high, elementSize);
+        int pi = partition(fp, low, high, elementSize);
-        fQuickSort(fp, low, pi - 1, elementSize);
+        fQuickSort(fp, low, pi - 1, elementSize);
-        fQuickSort(fp, pi + 1, high, elementSize);
+        fQuickSort(fp, pi + 1, high, elementSize);
-    }
+    }
-}
+}
-
+
-// Funzione per ordinare in-place un file binario utilizzando l'Insertion Sort.
+// Funzione per ordinare in-place un file binario utilizzando l'Insertion Sort.
-// Parametri:
+// Parametri:
-//   fp    - puntatore ad un file aperto in modalità binaria
+//   fp    - puntatore ad un file aperto in modalità binaria
-//   record_size - dimensione in byte di ogni record (ad esempio, sizeof(int))
+//   record_size - dimensione in byte di ogni record (ad esempio, sizeof(int))
-//   cmp         - funzione per confrontare due record
+//   cmp         - funzione per confrontare due record
-void fInsertionSort(FILE *fp, size_t record_size, int (*cmp)(const void *, const void *)) {
+void fInsertionSort(FILE *fp, size_t record_size, int (*cmp)(const void *, const void *)) {
-    fseek(fp, 0, SEEK_END);
+    fseek(fp, 0, SEEK_END);
-    long file_size = ftell(fp);
+    long file_size = ftell(fp);
-    size_t num_records = file_size / record_size;
+    size_t num_records = file_size / record_size;
-    void *key = malloc(record_size);
+    void *key = malloc(record_size);
-    void *temp = malloc(record_size);
+    void *temp = malloc(record_size);
-    if (!key || !temp) {
+    if (!key || !temp) {
-        perror("Errore nell'allocazione della memoria");
+        perror("Errore nell'allocazione della memoria");
-        free(key);
+        free(key);
-        free(temp);
+        free(temp);
-        return;
+        return;
-    }
+    }
-    for (size_t i = 1; i < num_records; i++) {
+    for (size_t i = 1; i < num_records; i++) {
-        fseek(fp, i * record_size, SEEK_SET);
+        fseek(fp, i * record_size, SEEK_SET);
-        fread(key, record_size, 1, fp);
+        fread(key, record_size, 1, fp);
-        size_t j = i;
+        size_t j = i;
-        while (j > 0) {
+        while (j > 0) {
-            fseek(fp, (j - 1) * record_size, SEEK_SET);
+            fseek(fp, (j - 1) * record_size, SEEK_SET);
-            fread(temp, record_size, 1, fp);
+            fread(temp, record_size, 1, fp);
-            if (cmp(temp, key) <= 0) {
+            if (cmp(temp, key) <= 0) {
-                break;
+                break;
-            }
+            }
-            fseek(fp, j * record_size, SEEK_SET);
+            fseek(fp, j * record_size, SEEK_SET);
-            fwrite(temp, record_size, 1, fp);
+            fwrite(temp, record_size, 1, fp);
-            j--;
+            j--;
-        }
+        }
-        fseek(fp, j * record_size, SEEK_SET);
+        fseek(fp, j * record_size, SEEK_SET);
-        fwrite(key, record_size, 1, fp);
+        fwrite(key, record_size, 1, fp);
-    }
+    }
-    free(key);
+    free(key);
-    free(temp);
+    free(temp);
 }

3AIN/file/inverti_fauser.cpp

@@ -1,36 +1,36 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Scrivere un programma che inverta ogni riga contenuta nel file righe.txt e riporti il risultato sullo
+Scrivere un programma che inverta ogni riga contenuta nel file righe.txt e riporti il risultato sullo
- schermo (per esempio, la riga Prova di stampa diventa apmats id avorP).
+ schermo (per esempio, la riga Prova di stampa diventa apmats id avorP).
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <cstring>
+#include <cstring>
-#include <cctype>
+#include <cctype>
-using namespace std;
+using namespace std;
-void invertiFile(const char* fileName) {
+void invertiFile(const char* fileName) {
-	FILE* file = fopen(fileName, "r");
+	FILE* file = fopen(fileName, "r");
-	if (file != NULL) {
+	if (file != NULL) {
-		char riga[256];
+		char riga[256];
-		while (fgets(riga, sizeof(riga), file)) {
+		while (fgets(riga, sizeof(riga), file)) {
-        	int n = strlen(riga);
+        	int n = strlen(riga);
-        	if (riga[n - 1] == '\n') {
+        	if (riga[n - 1] == '\n') {
-            	riga[n - 1] = '\0';
+            	riga[n - 1] = '\0';
-            	n--;
+            	n--;
-        	}
+        	}
-        	for (int i = 0; i < n / 2; i++) {
+        	for (int i = 0; i < n / 2; i++) {
-            	char temp = riga[i];
+            	char temp = riga[i];
-            	riga[i] = riga[n - i - 1];
+            	riga[i] = riga[n - i - 1];
-            	riga[n - i - 1] = temp;
+            	riga[n - i - 1] = temp;
-        	}
+        	}
-        	cout << riga << endl;
+        	cout << riga << endl;
-    	}
+    	}
-    	fclose(file);
+    	fclose(file);
-	}
+	}
-	else {
+	else {
-		perror("Errore durante la lettura di un file: ");
+		perror("Errore durante la lettura di un file: ");
-	}
+	}
-}
+}
-int main(void) {
+int main(void) {
-	invertiFile("righe.txt");
+	invertiFile("righe.txt");
-	return 0;
+	return 0;
-}
+}

3AIN/file/prova_file.cpp

@@ -1,23 +1,23 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Prova file
+Prova file
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <cstring>
+#include <cstring>
-#include <cctype>
+#include <cctype>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-int main(void){
+int main(void){
-	FILE *fp = fopen("file.txt","r");
+	FILE *fp = fopen("file.txt","r");
-	if (fp != NULL) {
+	if (fp != NULL) {
-		int ch;
+		int ch;
-		while((ch = fgetc(fp)) != EOF)
+		while((ch = fgetc(fp)) != EOF)
-			cout << (char)ch;
+			cout << (char)ch;
-//		cout << endl;
+//		cout << endl;
-		fclose(fp);
+		fclose(fp);
-	} else {
+	} else {
-		perror("Errore: ");
+		perror("Errore: ");
-		return 1;
+		return 1;
-	}
+	}
-	return 0;
+	return 0;
-}
+}

3AIN/file/read_binary.cpp

@@ -1,50 +1,50 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Legge da un file binario e memorizza in un array.
+Legge da un file binario e memorizza in un array.
-*/
+*/
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-size_t readValues(FILE* fptr, int storage[]) {
+size_t readValues(FILE* fptr, int storage[]) {
-	rewind(fptr);
+	rewind(fptr);
-	size_t size = sizeof(storage) / sizeof(storage[0]);
+	size_t size = sizeof(storage) / sizeof(storage[0]);
-	for (size_t i = 0; i < size; i++) {
+	for (size_t i = 0; i < size; i++) {
-		storage[i] = 0;
+		storage[i] = 0;
-	}
+	}
-	return fread(&storage,sizeof(int),size,fptr);
+	return fread(&storage,sizeof(int),size,fptr);
-}
+}
-size_t readValuesLoop(FILE* fptr, int storage[]) {
+size_t readValuesLoop(FILE* fptr, int storage[]) {
-	rewind(fptr);
+	rewind(fptr);
-	int value = 0;
+	int value = 0;
-	size_t size = sizeof(storage) / sizeof(storage[0]);
+	size_t size = sizeof(storage) / sizeof(storage[0]);
-	for (size_t i = 0; i < size; i++) {
+	for (size_t i = 0; i < size; i++) {
-		storage[i] = 0;
+		storage[i] = 0;
-	}
+	}
-	size_t counter = 0;
+	size_t counter = 0;
-    while (fread(&value, sizeof(int), 1, fptr) == 1 && counter < sizeof(storage)) {
+    while (fread(&value, sizeof(int), 1, fptr) == 1 && counter < sizeof(storage)) {
-        storage[counter] = value;
+        storage[counter] = value;
-        counter++;
+        counter++;
-    }
+    }
-    return counter;
+    return counter;
-}
+}
-int main(void) {
+int main(void) {
-	FILE* file = fopen("file_70.bin","rb");
+	FILE* file = fopen("file_70.bin","rb");
-	if (file != NULL) {
+	if (file != NULL) {
-		int arr[100];
+		int arr[100];
-		int arr2[100];
+		int arr2[100];
-		cout << "Valori letti (singola fread): " << readValues(file,arr) << endl;
+		cout << "Valori letti (singola fread): " << readValues(file,arr) << endl;
-		cout << "Valori letti (ciclo while): " << readValuesLoop(file,arr2) << endl;
+		cout << "Valori letti (ciclo while): " << readValuesLoop(file,arr2) << endl;
-		cout << "Array 1: ";
+		cout << "Array 1: ";
-		size_t size = sizeof(arr) / sizeof(arr[0]);
+		size_t size = sizeof(arr) / sizeof(arr[0]);
-		for (size_t i = 0; i < size; i++) {
+		for (size_t i = 0; i < size; i++) {
-			cout << arr[i] << " ";
+			cout << arr[i] << " ";
-		}
+		}
-		cout << endl << "Array 2: ";
+		cout << endl << "Array 2: ";
-		size = sizeof(arr2) / sizeof(arr2[0]);
+		size = sizeof(arr2) / sizeof(arr2[0]);
-		for (size_t i = 0; i < sizeof(arr2); i++) {
+		for (size_t i = 0; i < sizeof(arr2); i++) {
-			cout << arr2[i] << " ";
+			cout << arr2[i] << " ";
-		}
+		}
-		cout << endl;
+		cout << endl;
-		fclose(file);
+		fclose(file);
-	}
+	}
-	return 0;
+	return 0;
-}
+}

3AIN/file/sort_example.cpp

@@ -1,28 +1,28 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Programmino di esempio che usa le sort
+Programmino di esempio che usa le sort
-*/
+*/
-#include <stdio.h>
+#include <stdio.h>
-#include <stdbool.h>
+#include <stdbool.h>
-#include "fsorts.h"
+#include "fsorts.h"
-int cmp_int(const void *a, const void *b) {
+int cmp_int(const void *a, const void *b) {
-    return (*(const int *)a) - (*(const int *)b);
+    return (*(const int *)a) - (*(const int *)b);
-}
+}
-int main(void) {
+int main(void) {
-	FILE* file = fopen("pincopallino.bin","r+b");
+	FILE* file = fopen("pincopallino.bin","r+b");
-	if (file != NULL){
+	if (file != NULL){
-//		fQuickSort(file,0,7,sizeof(int));
+//		fQuickSort(file,0,7,sizeof(int));
-		fInsertionSort(file,sizeof(int),cmp_int);
+		fInsertionSort(file,sizeof(int),cmp_int);
-		fclose(file);
+		fclose(file);
-	}
+	}
-	else
+	else
-		return -1;
+		return -1;
-//	FILE* file = fopen("pincopallino.bin","wb");
+//	FILE* file = fopen("pincopallino.bin","wb");
-//	if (file != NULL) {
+//	if (file != NULL) {
-//		int array[] = {1,5,3,7,2,9,4,0};
+//		int array[] = {1,5,3,7,2,9,4,0};
-//		size_t count = sizeof(array) / sizeof(array[0]);
+//		size_t count = sizeof(array) / sizeof(array[0]);
-//		fwrite(array,sizeof(int),count,file);
+//		fwrite(array,sizeof(int),count,file);
-//		fclose(file);
+//		fclose(file);
-//	}
+//	}
-	return 0;
+	return 0;
-}
+}

3AIN/file/write_binary.cpp

@@ -1,20 +1,20 @@
-/*
+/*
-AUTORE: Manuel Vichi 3^AIN
+AUTORE: Manuel Vichi 3^AIN
-Scrive in un file binario degli interi da un'array
+Scrive in un file binario degli interi da un'array
-*/
+*/
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-int main(void) {
+int main(void) {
-	size_t written = 0;
+	size_t written = 0;
-	FILE* file = fopen("giovanni.bin","wb");
+	FILE* file = fopen("giovanni.bin","wb");
-	if (file != NULL) {
+	if (file != NULL) {
-		int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+		int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
-    	int n = sizeof(a) / sizeof(a[0]);
+    	int n = sizeof(a) / sizeof(a[0]);
-    	written = fwrite(&a, sizeof(int), n, file);
+    	written = fwrite(&a, sizeof(int), n, file);
-    	fclose(file);
+    	fclose(file);
-	}
+	}
-    if (written > 0) {
+    if (written > 0) {
-    	return 0;
+    	return 0;
-	}
+	}
-	return -1;
+	return -1;
-}
+}

3AIN/funzioni/30ott_test.cpp

@@ -1,60 +1,60 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Esercizi 30 ottobre
+Esercizi 30 ottobre
-*/
+*/
-#include <iostream>
+#include <iostream>
-#define EC(n)  1+3*(n)*((n)-1)
+#define EC(n)  1+3*(n)*((n)-1)
-using namespace std;
+using namespace std;
-// Funzione per verificare se il numero è esagonale centrale
+// Funzione per verificare se il numero è esagonale centrale
-bool esagonalecentrato(int n) {
+bool esagonalecentrato(int n) {
-#if 0
+#if 0
-	int k;
+	int k;
-    for(k = 1; n > EC(k); ++k)
+    for(k = 1; n > EC(k); ++k)
-        ;
+        ;
-    return n == EC(k);
+    return n == EC(k);
-#else
+#else
-    for(int k = 1; n >= EC(k); ++k)
+    for(int k = 1; n >= EC(k); ++k)
-        if(n == EC(k))
+        if(n == EC(k))
-			return true;
+			return true;
-    return false;
+    return false;
-#endif
+#endif
-}
+}
-// Funzione per stampare i numeri esagonali centrati
+// Funzione per stampare i numeri esagonali centrati
-void stampaesagonalicentrati() {
+void stampaesagonalicentrati() {
-	cout << endl << "Primi 10 numeri esagonali centrati: " << endl;
+	cout << endl << "Primi 10 numeri esagonali centrati: " << endl;
-	for(int k = 1; k <= 10; ++k) //Da 1 a 10 (0 non può essere esagonale centrato)
+	for(int k = 1; k <= 10; ++k) //Da 1 a 10 (0 non può essere esagonale centrato)
-        cout << EC(k) << " "; // Stampa l'esagonale centrato
+        cout << EC(k) << " "; // Stampa l'esagonale centrato
-    cout << endl; // Per aumentare la visibilità dell'output
+    cout << endl; // Per aumentare la visibilità dell'output
-}
+}
-// Funzione per verificare se il numero è primo
+// Funzione per verificare se il numero è primo
-bool isPrimeNumber(int num) {
+bool isPrimeNumber(int num) {
-    if (num <= 1)
+    if (num <= 1)
-		return false; // 0 e 1 non sono primi
+		return false; // 0 e 1 non sono primi
-    for (int i = 2; i * i <= num; i++) {
+    for (int i = 2; i * i <= num; i++) {
-        if (num % i == 0)
+        if (num % i == 0)
-			return false; // Se num è divisibile per i, non è primo
+			return false; // Se num è divisibile per i, non è primo
-    }
+    }
-    return true; // Se non ci sono divisori, è primo
+    return true; // Se non ci sono divisori, è primo
-}
+}
-// Funzione principale
+// Funzione principale
-int main(void) {
+int main(void) {
-	int n;
+	int n;
-	cout << "Inserisci un numero: ";
+	cout << "Inserisci un numero: ";
-    cin >> n;
+    cin >> n;
-	cout << endl; // Per aumentare la visibilità dell'output
+	cout << endl; // Per aumentare la visibilità dell'output
-	if (esagonalecentrato(n)) {
+	if (esagonalecentrato(n)) {
-        cout << "Il numero " << n << " e' esagonale centrato." << endl;
+        cout << "Il numero " << n << " e' esagonale centrato." << endl;
-    }
+    }
-    else {
+    else {
-        cout << "Il numero " << n << " non e' esagonale centrato." << endl;
+        cout << "Il numero " << n << " non e' esagonale centrato." << endl;
-    }
+    }
-    stampaesagonalicentrati();
+    stampaesagonalicentrati();
-    cout << endl; // Per aumentare la visibilità dell'output
+    cout << endl; // Per aumentare la visibilità dell'output
-    if (isPrimeNumber(n)) {
+    if (isPrimeNumber(n)) {
-    	cout << "Il numero " << n << " e' primo." << endl;
+    	cout << "Il numero " << n << " e' primo." << endl;
-    }
+    }
-    else {
+    else {
-    	cout << "Il numero " << n << " non e' primo." << endl;
+    	cout << "Il numero " << n << " non e' primo." << endl;
-	}
+	}
-	return 0; // Uscita normale con codice 0
+	return 0; // Uscita normale con codice 0
-}
+}

3AIN/funzioni/descrizione_numero.cpp

@@ -1,95 +1,95 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Descrizione di un numero
+Descrizione di un numero
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <cmath>
+#include <cmath>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-//Function to calculate the square of a number (because why not??)
+//Function to calculate the square of a number (because why not??)
-int square(int x) {
+int square(int x) {
-	return x * x;
+	return x * x;
-}
+}
-
+
-//Boolean function to determinate if a number is automorphic
+//Boolean function to determinate if a number is automorphic
-bool isAutomorphic(int num) {
+bool isAutomorphic(int num) {
-    int temp = num;
+    int temp = num;
-    int digits = 0;
+    int digits = 0;
-    while (temp > 0) {
+    while (temp > 0) {
-        digits++;
+        digits++;
-        temp /= 10;
+        temp /= 10;
-    }
+    }
-    int lastDigits = square(num) % static_cast<int>(pow(10, digits));
+    int lastDigits = square(num) % static_cast<int>(pow(10, digits));
-    return lastDigits == num;
+    return lastDigits == num;
-}
+}
-
+
-//Function to check if a number is prime
+//Function to check if a number is prime
-bool isPrimeNumber(int num) {
+bool isPrimeNumber(int num) {
-    if (num <= 1)
+    if (num <= 1)
-		return false;
+		return false;
-    for (int i = 2; i * i <= num; i++) {
+    for (int i = 2; i * i <= num; i++) {
-        if (num % i == 0)
+        if (num % i == 0)
-			return false;
+			return false;
-    }
+    }
-    return true;
+    return true;
-}
+}
-
+
-//Function to check if a number is perfect
+//Function to check if a number is perfect
-bool isPerfectNumber(int n) {
+bool isPerfectNumber(int n) {
-    if (n <= 1)
+    if (n <= 1)
-		return false;
+		return false;
-    int sum = 0;
+    int sum = 0;
-    for (int i = 1; i <= n / 2; ++i)
+    for (int i = 1; i <= n / 2; ++i)
-        if (n % i == 0)
+        if (n % i == 0)
-            sum += i;
+            sum += i;
-    return sum == n;
+    return sum == n;
-}
+}
-
+
-//Function to reverse the number
+//Function to reverse the number
-int reverseNumber(int number) {
+int reverseNumber(int number) {
-	int original = number;
+	int original = number;
-    int reversed = 0;
+    int reversed = 0;
-    while (number > 0) {
+    while (number > 0) {
-        int digit = number % 10;
+        int digit = number % 10;
-        reversed = reversed * 10 + digit;
+        reversed = reversed * 10 + digit;
-        n /= 10;
+        n /= 10;
-    }
+    }
-    return reversed;
+    return reversed;
-}
+}
-
+
-//Function to check if a number is palindrome
+//Function to check if a number is palindrome
-bool isPalindrome(int n) {
+bool isPalindrome(int n) {
-    int original = n;
+    int original = n;
-    int reversed = reverseNumber(n);
+    int reversed = reverseNumber(n);
-    return original == reversed;
+    return original == reversed;
-}
+}
-
+
-
+
-//Main function, asks in input the number and prints if it's automorphic or not
+//Main function, asks in input the number and prints if it's automorphic or not
-int main() {
+int main() {
-	int numero;
+	int numero;
-    cout << "Inserisci il numero: ";
+    cout << "Inserisci il numero: ";
-    cin >> numero;
+    cin >> numero;
-    cout << endl;
+    cout << endl;
-    cout << "Il numero " << numero << " fornito in input ha le seguenti caratteristiche:" << endl;
+    cout << "Il numero " << numero << " fornito in input ha le seguenti caratteristiche:" << endl;
-    if (isAutomorphic(numero))
+    if (isAutomorphic(numero))
-    	cout << "Il numero e' automorfo" << endl;
+    	cout << "Il numero e' automorfo" << endl;
-    else
+    else
-    	cout << "Il numero non e' automorfo" << endl;
+    	cout << "Il numero non e' automorfo" << endl;
-    if (isPrimeNumber(numero))
+    if (isPrimeNumber(numero))
-    	cout << "Il numero e' primo" << endl;
+    	cout << "Il numero e' primo" << endl;
-    else
+    else
-    	cout << "Il numero non e' primo" << endl;
+    	cout << "Il numero non e' primo" << endl;
-    if (isPerfectNumber(numero))
+    if (isPerfectNumber(numero))
-    	cout << "Il numero e' perfetto" << endl;
+    	cout << "Il numero e' perfetto" << endl;
-    else
+    else
-    	cout << "Il numero non e' perfetto" << endl;
+    	cout << "Il numero non e' perfetto" << endl;
-    if (isPalindrome(numero))
+    if (isPalindrome(numero))
-    	cout << "Il numero e' palindromo" << endl;
+    	cout << "Il numero e' palindromo" << endl;
-    else
+    else
-    	cout << "Il numero non e' palindromo" << endl;
+    	cout << "Il numero non e' palindromo" << endl;
-    cout << endl; //Just to separate the output of the program
+    cout << endl; //Just to separate the output of the program
-    cout << "Il numero " << numero << " invertito e': " << reverseNumber(numero) << endl;
+    cout << "Il numero " << numero << " invertito e': " << reverseNumber(numero) << endl;
-    system("pause"); //Needed on Windows to display the console output if the executable is not runned from a console
+    system("pause"); //Needed on Windows to display the console output if the executable is not runned from a console
-    return 0;
+    return 0;
-}
+}

3AIN/funzioni/potenze.cpp

@@ -1,26 +1,26 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Potenze
+Potenze
-Work in Progress: Fare in modo che +1 mostri il segno
+Work in Progress: Fare in modo che +1 mostri il segno
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-int potenzaInteri(int base, int esponente) {
+int potenzaInteri(int base, int esponente) {
-	return base^esponente;
+	return base^esponente;
-}
+}
-
+
-float potenza(float base, float esponente) {
+float potenza(float base, float esponente) {
-	return (float)base^esponente;
+	return (float)base^esponente;
-}
+}
-
+
-unsigned int potenzaNaturale(unsigned int base, unsigned int esponente) {
+unsigned int potenzaNaturale(unsigned int base, unsigned int esponente) {
-	return base^esponente;
+	return base^esponente;
-}
+}
-
+
-int main() {
+int main() {
-	cout << "Potenza intera: " << potenzaInteri(-2,3) << endl << "Potenza float: " << potenza(2.0f,5.9f) << endl << "Potenza naturale: " << potenzaNaturale(5,7) << endl;
+	cout << "Potenza intera: " << potenzaInteri(-2,3) << endl << "Potenza float: " << potenza(2.0f,5.9f) << endl << "Potenza naturale: " << potenzaNaturale(5,7) << endl;
-    return 0;
+    return 0;
-}
+}

3AIN/funzioni/reLu.cpp

@@ -1,22 +1,22 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Rectified Linear Unit Function
+Rectified Linear Unit Function
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-char reLu(int x) {
+char reLu(int x) {
-	if (x >= 0)
+	if (x >= 0)
-		return 'X';
+		return 'X';
-	return '0';
+	return '0';
-}
+}
-int main() {
+int main() {
-	int valore;
+	int valore;
-	cout << "Inserisci un valore: ";
+	cout << "Inserisci un valore: ";
-	cin >> valore;
+	cin >> valore;
-	cout << endl;
+	cout << endl;
-	cout << reLu(valore);
+	cout << reLu(valore);
-    return 0;
+    return 0;
-}
+}

3AIN/funzioni/segno.cpp

@@ -1,24 +1,24 @@
-/*
+/*
-AUTORE: Manuel Vichi
+AUTORE: Manuel Vichi
-Funzione segno
+Funzione segno
-*/
+*/
-#include <iostream>
+#include <iostream>
-#include <array>
+#include <array>
-#include <vector>
+#include <vector>
-#include <cstdlib>
+#include <cstdlib>
-using namespace std;
+using namespace std;
-signed int sign(int number) {
+signed int sign(int number) {
-	if (number > 0)
+	if (number > 0)
-		return +1;
+		return +1;
-	else if (number == 0)
+	else if (number == 0)
-		return 0;
+		return 0;
-	else
+	else
-		return -1;
+		return -1;
-}
+}
-int main() {
+int main() {
-	signed int numero;
+	signed int numero;
-	cout << "Inserisci un numero: ";
+	cout << "Inserisci un numero: ";
-	cin >> numero;
+	cin >> numero;
-	cout << endl << "Ricorda: La funzione segno stampa -1 se il numero e' negativo e +1 se il numero e' positivo." << endl << "Risultato della funzione segno: " << sign(numero) << endl;
+	cout << endl << "Ricorda: La funzione segno stampa -1 se il numero e' negativo e +1 se il numero e' positivo." << endl << "Risultato della funzione segno: " << sign(numero) << endl;
-    return 0;
+    return 0;
-}
+}

3AIN/sfusi/3x4.cpp

@@ -1,37 +1,37 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-/*dichiarare e inizializzare una matrice 3x4
+/*dichiarare e inizializzare una matrice 3x4
-scrivere la funzione stampa che la visualizza */
+scrivere la funzione stampa che la visualizza */
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-using namespace std;
+using namespace std;
-
+
-void stampa(int arr[3] [4]) {
+void stampa(int arr[3] [4]) {
-	
+	
-	for(size_t i = 0; i<3; ++i){
+	for(size_t i = 0; i<3; ++i){
-		for(size_t j = 0; j<4; ++j){
+		for(size_t j = 0; j<4; ++j){
-			cout << setw(3) << arr[i] [j];
+			cout << setw(3) << arr[i] [j];
-		}
+		}
-		cout << endl;
+		cout << endl;
-		
+		
-	}
+	}
-	
+	
-	
+	
-};
+};
-
+
-
+
-int main(void){
+int main(void){
-	
+	
-	int arr[3] [4]{
+	int arr[3] [4]{
-	
+	
-		{3,2,6,1},
+		{3,2,6,1},
-		{5,8,3,7},
+		{5,8,3,7},
-		{6,1,5,3},
+		{6,1,5,3},
-	
+	
-	};
+	};
-	
+	
-	stampa(arr);
+	stampa(arr);
-	
+	
-}
+}
-
+
-
+
-
+

3AIN/sfusi/4x5SommaEleColVett.cpp

@@ -1,25 +1,25 @@
-//Patriche Robert Cosmin
+//Patriche Robert Cosmin
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-
+
-void sommaColonne(int matrice[4][5], int righe, int colonne) {
+void sommaColonne(int matrice[4][5], int righe, int colonne) {
-    int somma[5] = {0};
+    int somma[5] = {0};
-
+
-    for (int i = 0; i < righe; i++) {
+    for (int i = 0; i < righe; i++) {
-        for (int j = 0; j < colonne; j++) {
+        for (int j = 0; j < colonne; j++) {
-            somma[j] += matrice[i][j];
+            somma[j] += matrice[i][j];
-        }
+        }
-    }
+    }
-
+
-    cout << "Somma per colonna: ";
+    cout << "Somma per colonna: ";
-    for (int j = 0; j < colonne; j++) {
+    for (int j = 0; j < colonne; j++) {
-        cout << somma[j] << " ";
+        cout << somma[j] << " ";
-    }
+    }
-    cout << endl;
+    cout << endl;
-}
+}
-
+
-int main() {
+int main() {
-    int matrice[4][5] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}};
+    int matrice[4][5] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}};
-    sommaColonne(matrice, 4, 5);
+    sommaColonne(matrice, 4, 5);
-    return 0;
+    return 0;
-}
+}

3AIN/sfusi/BIN to DEC.cpp

@@ -1,38 +1,38 @@
-#include <iostream>
+#include <iostream>
-
+
-using namespace std;
+using namespace std;
-
+
-int main(void) {
+int main(void) {
-	int binario;
+	int binario;
-	int decimale = 0;
+	int decimale = 0;
-	int potenza = 1;
+	int potenza = 1;
-	
+	
-	cout << "Inserisci un numero binario: ";
+	cout << "Inserisci un numero binario: ";
-	cin >> binario;
+	cin >> binario;
-	
+	
-	int temp = binario;
+	int temp = binario;
-	while (temp > 0) {
+	while (temp > 0) {
-		int cifra = temp % 10;
+		int cifra = temp % 10;
-		if (cifra != 0 && cifra != 1) {
+		if (cifra != 0 && cifra != 1) {
-			cout << "Numero non valido!" << endl;
+			cout << "Numero non valido!" << endl;
-			return 0;
+			return 0;
-		}
+		}
-		temp = temp / 10;
+		temp = temp / 10;
-	}
+	}
-	
+	
-	temp = binario;
+	temp = binario;
-	while (temp > 0) {
+	while (temp > 0) {
-		decimale = decimale + (temp % 10) * potenza;
+		decimale = decimale + (temp % 10) * potenza;
-		temp = temp / 10;
+		temp = temp / 10;
-		potenza = potenza * 2;
+		potenza = potenza * 2;
-	}
+	}
-	
+	
-	if (decimale < 0 || decimale > 255) {
+	if (decimale < 0 || decimale > 255) {
-		cout << "Numero non valido!" << endl;
+		cout << "Numero non valido!" << endl;
-		return 0;
+		return 0;
-	}
+	}
-	
+	
-	cout << "Numero decimale: " << decimale << endl;
+	cout << "Numero decimale: " << decimale << endl;
-	
+	
-	return 0;
+	return 0;
 }

3AIN/sfusi/BubbleSort.cpp

@@ -1,29 +1,29 @@
-//Patriche Robert Cosmin
+//Patriche Robert Cosmin
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-
+
-void bubbleSort(int arr[], int n) {
+void bubbleSort(int arr[], int n) {
-    for (int i = 0; i < n - 1; i++) {
+    for (int i = 0; i < n - 1; i++) {
-        for (int j = 0; j < n - i - 1; j++) {
+        for (int j = 0; j < n - i - 1; j++) {
-            if (arr[j] > arr[j + 1]) {
+            if (arr[j] > arr[j + 1]) {
-                swap(arr[j], arr[j + 1]);
+                swap(arr[j], arr[j + 1]);
-            }
+            }
-        }
+        }
-    }
+    }
-}
+}
-
+
-void printArray(int arr[], int n) {
+void printArray(int arr[], int n) {
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
-        cout << arr[i] << " ";
+        cout << arr[i] << " ";
-    }
+    }
-    cout << endl;
+    cout << endl;
-}
+}
-
+
-int main() {
+int main() {
-    int arr[] = {5, 1, 4, 2, 8};
+    int arr[] = {5, 1, 4, 2, 8};
-    int n = sizeof(arr) / sizeof(arr[0]);
+    int n = sizeof(arr) / sizeof(arr[0]);
-    bubbleSort(arr, n);
+    bubbleSort(arr, n);
-    cout << "Sorted array: ";
+    cout << "Sorted array: ";
-    printArray(arr, n);
+    printArray(arr, n);
-    return 0;
+    return 0;
-}
+}

3AIN/sfusi/CalcConfrontiCercareMassRestituireCoord.cpp

@@ -1,29 +1,29 @@
-//Patriche Robert Cosmin
+//Patriche Robert Cosmin
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-
+
-void trovaMassimo(int matrice[3][3], int righe, int colonne) {
+void trovaMassimo(int matrice[3][3], int righe, int colonne) {
-    int max = matrice[0][0];
+    int max = matrice[0][0];
-    int x = 0, y = 0;
+    int x = 0, y = 0;
-    int confronti = 1;
+    int confronti = 1;
-
+
-    for (int i = 0; i < righe; i++) {
+    for (int i = 0; i < righe; i++) {
-        for (int j = 0; j < colonne; j++) {
+        for (int j = 0; j < colonne; j++) {
-            confronti++;
+            confronti++;
-            if (matrice[i][j] > max) {
+            if (matrice[i][j] > max) {
-                max = matrice[i][j];
+                max = matrice[i][j];
-                x = i;
+                x = i;
-                y = j;
+                y = j;
-            }
+            }
-        }
+        }
-    }
+    }
-
+
-    cout << "Numero di confronti: " << confronti << endl;
+    cout << "Numero di confronti: " << confronti << endl;
-    cout << "Massimo trovato: " << max << " alle coordinate (" << x << ", " << y << ")" << endl;
+    cout << "Massimo trovato: " << max << " alle coordinate (" << x << ", " << y << ")" << endl;
-}
+}
-
+
-int main() {
+int main() {
-    int matrice[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    int matrice[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
-    trovaMassimo(matrice, 3, 3);
+    trovaMassimo(matrice, 3, 3);
-    return 0;
+    return 0;
-}
+}

3AIN/sfusi/CalcProddVettore.cpp

@@ -1,31 +1,31 @@
-//Patriche Robert Cosmin
+//Patriche Robert Cosmin
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-
+
-void prodottoMatriciale(int A[3][2], int B[2][3], int C[3][3], int righeA, int colonneA, int righeB, int colonneB) {
+void prodottoMatriciale(int A[3][2], int B[2][3], int C[3][3], int righeA, int colonneA, int righeB, int colonneB) {
-    for (int i = 0; i < righeA; i++) {
+    for (int i = 0; i < righeA; i++) {
-        for (int j = 0; j < colonneB; j++) {
+        for (int j = 0; j < colonneB; j++) {
-            C[i][j] = 0;
+            C[i][j] = 0;
-            for (int k = 0; k < colonneA; k++) {
+            for (int k = 0; k < colonneA; k++) {
-                C[i][j] += A[i][k] * B[k][j];
+                C[i][j] += A[i][k] * B[k][j];
-            }
+            }
-        }
+        }
-    }
+    }
-}
+}
-
+
-int main() {
+int main() {
-    int A[3][2] = {{1, 2}, {3, 4}, {5, 6}};
+    int A[3][2] = {{1, 2}, {3, 4}, {5, 6}};
-    int B[2][3] = {{7, 8, 9}, {10, 11, 12}};
+    int B[2][3] = {{7, 8, 9}, {10, 11, 12}};
-    int C[3][3];
+    int C[3][3];
-
+
-    prodottoMatriciale(A, B, C, 3, 2, 2, 3);
+    prodottoMatriciale(A, B, C, 3, 2, 2, 3);
-
+
-    cout << "Prodotto matriciale (A * B):" << endl;
+    cout << "Prodotto matriciale (A * B):" << endl;
-    for (int i = 0; i < 3; i++) {
+    for (int i = 0; i < 3; i++) {
-        for (int j = 0; j < 3; j++) {
+        for (int j = 0; j < 3; j++) {
-            cout << C[i][j] << " ";
+            cout << C[i][j] << " ";
-        }
+        }
-        cout << endl;
+        cout << endl;
-    }
+    }
-    return 0;
+    return 0;
-}
+}

3AIN/sfusi/CalcoloMedia.cpp

@@ -1,49 +1,49 @@
-//Patriche Robert Cosmin 3Ain
+//Patriche Robert Cosmin 3Ain
-/*Dato un vettore di 15 numeri interi, caricare i propri voti di informatica (n voti, con n preso da tastiera e minore o uguale di 15). 
+/*Dato un vettore di 15 numeri interi, caricare i propri voti di informatica (n voti, con n preso da tastiera e minore o uguale di 15). 
-Successivamente calcolare e visualizzare la media dei voti.*/
+Successivamente calcolare e visualizzare la media dei voti.*/
-
+
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-
+
-// Funzione per caricare i voti
+// Funzione per caricare i voti
-void caricaVoti(int voti[], int n) {
+void caricaVoti(int voti[], int n) {
-    cout << "Inserisci " << n << " voti di informatica:" << endl;
+    cout << "Inserisci " << n << " voti di informatica:" << endl;
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i) {
-        cout << "Voto " << i + 1 << ": ";
+        cout << "Voto " << i + 1 << ": ";
-        cin >> voti[i];
+        cin >> voti[i];
-    }
+    }
-}
+}
-
+
-// Funzione per calcolare la media dei voti
+// Funzione per calcolare la media dei voti
-double calcolaMedia(int voti[], int n) {
+double calcolaMedia(int voti[], int n) {
-    int somma = 0;
+    int somma = 0;
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i) {
-        somma += voti[i];
+        somma += voti[i];
-    }
+    }
-    return somma / n;
+    return somma / n;
-}
+}
-
+
-int main() {
+int main() {
-    const int MAX_VOTI = 15;
+    const int MAX_VOTI = 15;
-    int voti[MAX_VOTI];
+    int voti[MAX_VOTI];
-    int n;
+    int n;
-
+
-    // Input del numero di voti
+    // Input del numero di voti
-    cout << "Quanti voti vuoi inserire? (max 15): ";
+    cout << "Quanti voti vuoi inserire? (max 15): ";
-    cin >> n;
+    cin >> n;
-
+
-    // Controllo del limite massimo
+    // Controllo del limite massimo
-    if (n <= 0 || n > MAX_VOTI) {
+    if (n <= 0 || n > MAX_VOTI) {
-        cout << "Numero di voti non valido. Deve essere tra 1 e 15." << endl;
+        cout << "Numero di voti non valido. Deve essere tra 1 e 15." << endl;
-        return 1; // Termina il programma con errore
+        return 1; // Termina il programma con errore
-    }
+    }
-
+
-    // Caricamento dei voti
+    // Caricamento dei voti
-    caricaVoti(voti, n);
+    caricaVoti(voti, n);
-
+
-    // Calcolo e visualizzazione della media
+    // Calcolo e visualizzazione della media
-    double media = calcolaMedia(voti, n);
+    double media = calcolaMedia(voti, n);
-    cout << "La media dei voti inseriti e': " << media << endl;
+    cout << "La media dei voti inseriti e': " << media << endl;
-
+
-    return 0;
+    return 0;
-}
+}

3AIN/sfusi/ContaPosNegNul.cpp

@@ -1,36 +1,36 @@
-//Patriche Robert Cosmin
+//Patriche Robert Cosmin
-
+
-#include <iostream>
+#include <iostream>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-using namespace std;
+using namespace std;
-
+
-void contaPNZ(int arr[], int size, int &positivi, int &negativi, int &nulli);
+void contaPNZ(int arr[], int size, int &positivi, int &negativi, int &nulli);
-
+
-int main() {
+int main() {
-    const int DIM = 15;
+    const int DIM = 15;
-    int numeri[DIM];
+    int numeri[DIM];
-    srand(time(0));
+    srand(time(0));
-    
+    
-    cout << "Array: ";
+    cout << "Array: ";
-    for (int i = 0; i < DIM; i++) {
+    for (int i = 0; i < DIM; i++) {
-        numeri[i] = rand() % 21 - 10; // Numeri tra -10 e 10
+        numeri[i] = rand() % 21 - 10; // Numeri tra -10 e 10
-        cout << numeri[i] << " ";
+        cout << numeri[i] << " ";
-    }
+    }
-    cout << endl;
+    cout << endl;
-    
+    
-    int positivi = 0, negativi = 0, nulli = 0;
+    int positivi = 0, negativi = 0, nulli = 0;
-    contaPNZ(numeri, DIM, positivi, negativi, nulli);
+    contaPNZ(numeri, DIM, positivi, negativi, nulli);
-    
+    
-    cout << "Positivi: " << positivi << ", Negativi: " << negativi << ", Nulli: " << nulli << endl;
+    cout << "Positivi: " << positivi << ", Negativi: " << negativi << ", Nulli: " << nulli << endl;
-
+
-    return 0;
+    return 0;
-}
+}
-
+
-void contaPNZ(int arr[], int size, int &positivi, int &negativi, int &nulli) {
+void contaPNZ(int arr[], int size, int &positivi, int &negativi, int &nulli) {
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++) {
-        if (arr[i] > 0) positivi++;
+        if (arr[i] > 0) positivi++;
-        else if (arr[i] < 0) negativi++;
+        else if (arr[i] < 0) negativi++;
-        else nulli++;
+        else nulli++;
-    }
+    }
-}
+}

3AIN/sfusi/Copia di One hot.cpp

@@ -1,52 +1,52 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-#include <iostream>
+#include <iostream>
-#include <vector>
+#include <vector>
-#include <string>
+#include <string>
-using namespace std;
+using namespace std;
-
+
-// Funzione per eseguire la One-Hot Encoding
+// Funzione per eseguire la One-Hot Encoding
-vector<vector<int>> oneHotEncoding(const vector<string>& categorie, const vector<string>& etichette) {
+vector<vector<int>> oneHotEncoding(const vector<string>& categorie, const vector<string>& etichette) {
-    vector<vector<int>> matriceOneHot;
+    vector<vector<int>> matriceOneHot;
-    
+    
-    // Per ogni etichetta, troviamo la sua posizione e creiamo un vettore one-hot
+    // Per ogni etichetta, troviamo la sua posizione e creiamo un vettore one-hot
-    for (const string& etichetta : etichette) {
+    for (const string& etichetta : etichette) {
-        vector<int> oneHot(categorie.size(), 0);  // Inizializza un vettore di zeri
+        vector<int> oneHot(categorie.size(), 0);  // Inizializza un vettore di zeri
-        for (int i = 0; i < categorie.size(); ++i) {
+        for (int i = 0; i < categorie.size(); ++i) {
-            if (categorie[i] == etichetta) {
+            if (categorie[i] == etichetta) {
-                oneHot[i] = 1;  // Imposta la posizione corrispondente a "1"
+                oneHot[i] = 1;  // Imposta la posizione corrispondente a "1"
-                break;
+                break;
-            }
+            }
-        }
+        }
-        matriceOneHot.push_back(oneHot);  // Aggiunge il vettore one-hot alla matrice
+        matriceOneHot.push_back(oneHot);  // Aggiunge il vettore one-hot alla matrice
-    }
+    }
-    
+    
-    return matriceOneHot;
+    return matriceOneHot;
-}
+}
-
+
-// Funzione per stampare una matrice
+// Funzione per stampare una matrice
-void stampaMatrice(const vector<vector<int>>& matrice) {
+void stampaMatrice(const vector<vector<int>>& matrice) {
-    for (const auto& riga : matrice) {
+    for (const auto& riga : matrice) {
-        for (int valore : riga) {
+        for (int valore : riga) {
-            cout << valore << " ";
+            cout << valore << " ";
-        }
+        }
-        cout << endl;
+        cout << endl;
-    }
+    }
-}
+}
-
+
-int main() {
+int main() {
-    // Definiamo le categorie possibili
+    // Definiamo le categorie possibili
-    vector<string> categorie = {"Lunedì", "Martedì", "Mercoledì", "Giovedì", "Venerdì", "Sabato", "Domenica"};
+    vector<string> categorie = {"Lunedì", "Martedì", "Mercoledì", "Giovedì", "Venerdì", "Sabato", "Domenica"};
-    
+    
-    // Definiamo alcune etichette da codificare
+    // Definiamo alcune etichette da codificare
-    vector<string> etichette = {"Lunedì", "Mercoledì", "Domenica", "Venerdì", "Martedì"};
+    vector<string> etichette = {"Lunedì", "Mercoledì", "Domenica", "Venerdì", "Martedì"};
-    
+    
-    // Otteniamo la matrice one-hot encoding
+    // Otteniamo la matrice one-hot encoding
-    vector<vector<int>> matriceOneHot = oneHotEncoding(categorie, etichette);
+    vector<vector<int>> matriceOneHot = oneHotEncoding(categorie, etichette);
-    
+    
-    // Stampiamo la matrice risultante
+    // Stampiamo la matrice risultante
-    cout << "Matrice One-Hot Encoding:" << endl;
+    cout << "Matrice One-Hot Encoding:" << endl;
-    stampaMatrice(matriceOneHot);
+    stampaMatrice(matriceOneHot);
-    
+    
-    return 0;
+    return 0;
-}
+}
-
+

3AIN/sfusi/Copia di Verifica se tutte le celle dei “bordi” contengono lo stesso valore(1).cpp

@@ -1,51 +1,51 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-//Verifica se tutte le celle dei “bordi” contengono lo stesso valore
+//Verifica se tutte le celle dei “bordi” contengono lo stesso valore
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-#define NUM 4
+#define NUM 4
-using namespace std;
+using namespace std;
-void stampaMatrice(int matrice[NUM][NUM]) {
+void stampaMatrice(int matrice[NUM][NUM]) {
-    cout << "Matrice:\n";
+    cout << "Matrice:\n";
-    for (int i = 0; i < NUM; ++i) {
+    for (int i = 0; i < NUM; ++i) {
-        for (int j = 0; j < NUM; ++j) {
+        for (int j = 0; j < NUM; ++j) {
-            cout << matrice[i][j] << " ";
+            cout << matrice[i][j] << " ";
-        }
+        }
-        cout << endl;
+        cout << endl;
-    }
+    }
-}
+}
-bool verificaBordiUguali(int arr[NUM][NUM]){
+bool verificaBordiUguali(int arr[NUM][NUM]){
-	
+	
-	int valoreBordo = arr[0][0];
+	int valoreBordo = arr[0][0];
-	
+	
-	for(size_t j =0; j<NUM; ++j){
+	for(size_t j =0; j<NUM; ++j){
-		if(arr[0][j] != valoreBordo || arr[NUM-1][j] != valoreBordo){
+		if(arr[0][j] != valoreBordo || arr[NUM-1][j] != valoreBordo){
-			return false;
+			return false;
-		}
+		}
-	}
+	}
-	
+	
-	for(size_t i = 0; i<NUM; ++i){
+	for(size_t i = 0; i<NUM; ++i){
-		if(arr[i][0] != valoreBordo || arr[i][NUM-1] != valoreBordo){
+		if(arr[i][0] != valoreBordo || arr[i][NUM-1] != valoreBordo){
-			return false;
+			return false;
-		}
+		}
-	}
+	}
-	return true;
+	return true;
-}
+}
-
+
-int main(void){
+int main(void){
-	
+	
-	int bobby[NUM][NUM]{
+	int bobby[NUM][NUM]{
-		1,1,1,1,
+		1,1,1,1,
-		1,0,0,1,
+		1,0,0,1,
-		1,0,0,1,
+		1,0,0,1,
-		1,1,1,1	
+		1,1,1,1	
-	};
+	};
-	stampaMatrice(bobby);
+	stampaMatrice(bobby);
-	verificaBordiUguali(bobby);
+	verificaBordiUguali(bobby);
-	if(verificaBordiUguali(bobby))
+	if(verificaBordiUguali(bobby))
-		cout << endl<< "La matrice ha tutti i bordi uguali";
+		cout << endl<< "La matrice ha tutti i bordi uguali";
-	else
+	else
-		cout << "no";
+		cout << "no";
-	
+	
-}
+}

3AIN/sfusi/Copia di Verifica se tutte le celle dei “bordi” contengono lo stesso valore.cpp

@@ -1,51 +1,51 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-//Verifica se tutte le celle dei “bordi” contengono lo stesso valore
+//Verifica se tutte le celle dei “bordi” contengono lo stesso valore
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-#define NUM 4
+#define NUM 4
-using namespace std;
+using namespace std;
-void stampaMatrice(int matrice[NUM][NUM]) {
+void stampaMatrice(int matrice[NUM][NUM]) {
-    cout << "Matrice:\n";
+    cout << "Matrice:\n";
-    for (int i = 0; i < NUM; ++i) {
+    for (int i = 0; i < NUM; ++i) {
-        for (int j = 0; j < NUM; ++j) {
+        for (int j = 0; j < NUM; ++j) {
-            cout << matrice[i][j] << " ";
+            cout << matrice[i][j] << " ";
-        }
+        }
-        cout << endl;
+        cout << endl;
-    }
+    }
-}
+}
-bool verificaBordiUguali(int arr[NUM][NUM]){
+bool verificaBordiUguali(int arr[NUM][NUM]){
-	
+	
-	int valoreBordo = arr[0][0];
+	int valoreBordo = arr[0][0];
-	
+	
-	for(size_t j =0; j<NUM; ++j){
+	for(size_t j =0; j<NUM; ++j){
-		if(arr[0][j] != valoreBordo || arr[NUM-1][j] != valoreBordo){
+		if(arr[0][j] != valoreBordo || arr[NUM-1][j] != valoreBordo){
-			return false;
+			return false;
-		}
+		}
-	}
+	}
-	
+	
-	for(size_t i = 0; i<NUM; ++i){
+	for(size_t i = 0; i<NUM; ++i){
-		if(arr[i][0] != valoreBordo || arr[i][NUM-1] != valoreBordo){
+		if(arr[i][0] != valoreBordo || arr[i][NUM-1] != valoreBordo){
-			return false;
+			return false;
-		}
+		}
-	}
+	}
-	return true;
+	return true;
-}
+}
-
+
-int main(void){
+int main(void){
-	
+	
-	int bobby[NUM][NUM]{
+	int bobby[NUM][NUM]{
-		1,1,1,1,
+		1,1,1,1,
-		1,0,0,1,
+		1,0,0,1,
-		1,0,0,1,
+		1,0,0,1,
-		1,1,1,1	
+		1,1,1,1	
-	};
+	};
-	stampaMatrice(bobby);
+	stampaMatrice(bobby);
-	verificaBordiUguali(bobby);
+	verificaBordiUguali(bobby);
-	if(verificaBordiUguali(bobby))
+	if(verificaBordiUguali(bobby))
-		cout << endl<< "La matrice ha tutti i bordi uguali";
+		cout << endl<< "La matrice ha tutti i bordi uguali";
-	else
+	else
-		cout << "no";
+		cout << "no";
-	
+	
-}
+}

3AIN/sfusi/Copia di contaPariEDispari.cpp

@@ -1,64 +1,64 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-//Programma con una matrice che conta Pari e Dispari
+//Programma con una matrice che conta Pari e Dispari
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-#define DEF 2
+#define DEF 2
-using namespace std;
+using namespace std;
-void riempi(int arr[DEF][DEF]);
+void riempi(int arr[DEF][DEF]);
-void stampa(int arr[DEF][DEF]);
+void stampa(int arr[DEF][DEF]);
-void contaPariEDispari(int arr[DEF][DEF], int pari, int dispari){
+void contaPariEDispari(int arr[DEF][DEF], int pari, int dispari){
-	for(size_t i = 0; i<DEF; ++i){
+	for(size_t i = 0; i<DEF; ++i){
-		for(size_t j = 0; j<DEF; ++j){
+		for(size_t j = 0; j<DEF; ++j){
-			if(arr[i][j] % 2 == 0){
+			if(arr[i][j] % 2 == 0){
-				pari+=1;
+				pari+=1;
-			}
+			}
-			else
+			else
-				dispari+=1;
+				dispari+=1;
-		}
+		}
-	}
+	}
-	cout << "In questa matrice ci sono "<< pari << " numeri pari e "<< dispari << " numeri dispari";
+	cout << "In questa matrice ci sono "<< pari << " numeri pari e "<< dispari << " numeri dispari";
-}
+}
-
+
-
+
-
+
-int main(void){
+int main(void){
-	srand(time(NULL));
+	srand(time(NULL));
-	
+	
-	int bobby[DEF][DEF];
+	int bobby[DEF][DEF];
-	int npari = 0;
+	int npari = 0;
-	int ndispari = 0;
+	int ndispari = 0;
-	
+	
-	riempi(bobby);
+	riempi(bobby);
-	stampa(bobby);
+	stampa(bobby);
-	contaPariEDispari(bobby, npari,ndispari);
+	contaPariEDispari(bobby, npari,ndispari);
-	
+	
-	
+	
-	
+	
-	
+	
-	
+	
-	
+	
-}
+}
-
+
-
+
-void stampa(int arr[DEF][DEF]){
+void stampa(int arr[DEF][DEF]){
-	for(size_t i = 0; i<DEF; ++i){
+	for(size_t i = 0; i<DEF; ++i){
-		for(size_t j = 0; j<DEF; ++j){
+		for(size_t j = 0; j<DEF; ++j){
-			cout << setw(4) << arr[i][j] ;
+			cout << setw(4) << arr[i][j] ;
-		}
+		}
-		cout << endl;
+		cout << endl;
-	}	
+	}	
-	
+	
-	
+	
-}
+}
-void riempi(int arr[DEF][DEF]){
+void riempi(int arr[DEF][DEF]){
-	for(size_t i = 0; i<DEF; ++i){
+	for(size_t i = 0; i<DEF; ++i){
-		for(size_t j = 0; j<DEF; ++j){
+		for(size_t j = 0; j<DEF; ++j){
-			arr[i][j] = rand() % 20;
+			arr[i][j] = rand() % 20;
-		}
+		}
-	}
+	}
-	
+	
-	
+	
-}
+}
-
+

3AIN/sfusi/Copia di matrice identità.cpp

@@ -1,45 +1,45 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-//Fare una matrice identità
+//Fare una matrice identità
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#define LATO 6
+#define LATO 6
-using namespace std;
+using namespace std;
-
+
-void riempi(int arr[LATO] [LATO]){
+void riempi(int arr[LATO] [LATO]){
-	for(size_t i = 0; i<LATO; ++i){
+	for(size_t i = 0; i<LATO; ++i){
-		for(size_t j = 0; j<LATO; ++j){
+		for(size_t j = 0; j<LATO; ++j){
-			if(i==j){
+			if(i==j){
-				arr[i] [j] = 1;
+				arr[i] [j] = 1;
-			}
+			}
-			else
+			else
-				arr[i] [j] = 0;
+				arr[i] [j] = 0;
-			
+			
-		}
+		}
-		
+		
-	}
+	}
-	
+	
-	
+	
-}
+}
-
+
-
+
-void stampa(int arr[LATO] [LATO]){
+void stampa(int arr[LATO] [LATO]){
-	for(size_t i = 0; i<LATO; ++i){
+	for(size_t i = 0; i<LATO; ++i){
-		for(size_t j = 0; j<LATO; ++j){
+		for(size_t j = 0; j<LATO; ++j){
-			cout << setw(3) << arr[i] [j];
+			cout << setw(3) << arr[i] [j];
-		}
+		}
-		cout << endl;
+		cout << endl;
-	}
+	}
-	
+	
-	
+	
-	
+	
-}
+}
-
+
-
+
-
+
-int main(void){
+int main(void){
-	
+	
-	int arr[LATO] [LATO];
+	int arr[LATO] [LATO];
-	riempi(arr);
+	riempi(arr);
-	stampa(arr);
+	stampa(arr);
-	
+	
-}
+}

3AIN/sfusi/Copia di matrice triangolare.cpp

@@ -1,48 +1,48 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-//Matrice triangolare (sono nulli tutti gli elementi superiori alla diagonale principale)
+//Matrice triangolare (sono nulli tutti gli elementi superiori alla diagonale principale)
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#include <time.h>
+#include <time.h>
-#include <cstdlib>
+#include <cstdlib>
-#define LATO 5
+#define LATO 5
-using namespace std;
+using namespace std;
-
+
-void triangolare(int arr[LATO] [LATO]){
+void triangolare(int arr[LATO] [LATO]){
-	
+	
-	for(size_t i = 0; i<LATO; ++i){
+	for(size_t i = 0; i<LATO; ++i){
-		for(size_t j = 0; j<LATO; ++j){
+		for(size_t j = 0; j<LATO; ++j){
-			if(i==j || i>j){
+			if(i==j || i>j){
-				arr[i] [j] = rand() % ((20-3)+1)+3;
+				arr[i] [j] = rand() % ((20-3)+1)+3;
-			}
+			}
-			else if(i<j){
+			else if(i<j){
-				arr[i] [j] = 0;
+				arr[i] [j] = 0;
-			}
+			}
-			
+			
-		}
+		}
-		
+		
-		
+		
-	}
+	}
-	
+	
-}
+}
-
+
-void stampa(int arr[LATO] [LATO]){
+void stampa(int arr[LATO] [LATO]){
-	for(size_t i = 0; i<LATO; ++i){
+	for(size_t i = 0; i<LATO; ++i){
-		for(size_t j = 0; j<LATO; ++j){
+		for(size_t j = 0; j<LATO; ++j){
-			cout << setw(3) << arr[i] [j] << " ";
+			cout << setw(3) << arr[i] [j] << " ";
-		
+		
-		}
+		}
-		cout << endl;
+		cout << endl;
-	
+	
-	
+	
-	}
+	}
-	
+	
-}
+}
-
+
-
+
-int main(void){
+int main(void){
-	
+	
-	srand(time(NULL));
+	srand(time(NULL));
-	int arr[LATO] [LATO];
+	int arr[LATO] [LATO];
-	triangolare(arr);
+	triangolare(arr);
-	stampa(arr);
+	stampa(arr);
-}
+}

3AIN/sfusi/Copia di mettiAZeroPariDispari - Copia.cpp

@@ -1,43 +1,43 @@
-/* 
+/* 
-La funzione mettiAZeroPariDispari prende un 
+La funzione mettiAZeroPariDispari prende un 
-array di numeri interi, chiamato v e ne elimina 
+array di numeri interi, chiamato v e ne elimina 
-tutte le occorrenze di un valore pari.
+tutte le occorrenze di un valore pari.
-Alla fine del processo, l'array originale 
+Alla fine del processo, l'array originale 
-è modificato, contenendo ora solo elementi dispari e zero negli altri
+è modificato, contenendo ora solo elementi dispari e zero negli altri
-*/
+*/
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-
+
-int mettiAZeroPariDispari(int arr[], size_t size){
+int mettiAZeroPariDispari(int arr[], size_t size){
-	for(size_t i = 0; i<size; i++){
+	for(size_t i = 0; i<size; i++){
-		if(arr[i] % 2 == 0){
+		if(arr[i] % 2 == 0){
-			arr[i] = 0;
+			arr[i] = 0;
-		}
+		}
-		
+		
-		
+		
-	}
+	}
-	return 0;
+	return 0;
-	
+	
-	
+	
-	
+	
-}
+}
-int stampa(int arr[], size_t size){
+int stampa(int arr[], size_t size){
-	for(size_t i = 0; i<size; i++){
+	for(size_t i = 0; i<size; i++){
-		cout << arr[i] << " ";
+		cout << arr[i] << " ";
-		
+		
-		
+		
-		
+		
-	}
+	}
-	
+	
-	
+	
-}
+}
-int main(void){
+int main(void){
-	int v[10] = {4,5,9,12,23,45,67,46,48,56};
+	int v[10] = {4,5,9,12,23,45,67,46,48,56};
-	
+	
-	stampa(v,10);
+	stampa(v,10);
-	cout << endl;
+	cout << endl;
-	mettiAZeroPariDispari(v, 10);	
+	mettiAZeroPariDispari(v, 10);	
-	stampa(v,10);
+	stampa(v,10);
-	
+	
-}
+}
-
+

3AIN/sfusi/Copia di ruota il bordo di una matrice.cpp

@@ -1,73 +1,73 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-// ruota il bordo di una matrice
+// ruota il bordo di una matrice
-#include <iostream>
+#include <iostream>
-#define RIGHE 4
+#define RIGHE 4
-#define COLONNE 4
+#define COLONNE 4
-
+
-using namespace std;
+using namespace std;
-
+
-// Funzione per stampare la matrice
+// Funzione per stampare la matrice
-void stampaMatrice(int matrice[RIGHE][COLONNE]) {
+void stampaMatrice(int matrice[RIGHE][COLONNE]) {
-    for (int i = 0; i < RIGHE; ++i) {
+    for (int i = 0; i < RIGHE; ++i) {
-        for (int j = 0; j < COLONNE; ++j) {
+        for (int j = 0; j < COLONNE; ++j) {
-            cout << matrice[i][j] << " ";
+            cout << matrice[i][j] << " ";
-        }
+        }
-        cout << endl;
+        cout << endl;
-    }
+    }
-    cout << endl;
+    cout << endl;
-}
+}
-
+
-// Funzione per ruotare il bordo della matrice in-place
+// Funzione per ruotare il bordo della matrice in-place
-void ruotaBordoInPlace(int matrice[RIGHE][COLONNE]) {
+void ruotaBordoInPlace(int matrice[RIGHE][COLONNE]) {
-    // Verifica che la matrice sia abbastanza grande per avere un bordo da ruotare
+    // Verifica che la matrice sia abbastanza grande per avere un bordo da ruotare
-    if (RIGHE < 2 || COLONNE < 2) return;
+    if (RIGHE < 2 || COLONNE < 2) return;
-
+
-    // Salva temporaneamente il primo elemento
+    // Salva temporaneamente il primo elemento
-    int temp = matrice[0][0];
+    int temp = matrice[0][0];
-    
+    
-    // Spostamento orario in senso del bordo
+    // Spostamento orario in senso del bordo
-    // Prima riga
+    // Prima riga
-    for (int j = 0; j < COLONNE - 1; ++j) {
+    for (int j = 0; j < COLONNE - 1; ++j) {
-        matrice[0][j] = matrice[0][j + 1];
+        matrice[0][j] = matrice[0][j + 1];
-    }
+    }
-
+
-    // Ultima colonna
+    // Ultima colonna
-    for (int i = 0; i < RIGHE - 1; ++i) {
+    for (int i = 0; i < RIGHE - 1; ++i) {
-        matrice[i][COLONNE - 1] = matrice[i + 1][COLONNE - 1];
+        matrice[i][COLONNE - 1] = matrice[i + 1][COLONNE - 1];
-    }
+    }
-
+
-    // Ultima riga
+    // Ultima riga
-    for (int j = COLONNE - 1; j > 0; --j) {
+    for (int j = COLONNE - 1; j > 0; --j) {
-        matrice[RIGHE - 1][j] = matrice[RIGHE - 1][j - 1];
+        matrice[RIGHE - 1][j] = matrice[RIGHE - 1][j - 1];
-    }
+    }
-
+
-    // Prima colonna
+    // Prima colonna
-    for (int i = RIGHE - 1; i > 0; --i) {
+    for (int i = RIGHE - 1; i > 0; --i) {
-        matrice[i][0] = matrice[i - 1][0];
+        matrice[i][0] = matrice[i - 1][0];
-    }
+    }
-
+
-    // Ripristina il primo elemento salvato in fondo alla colonna
+    // Ripristina il primo elemento salvato in fondo alla colonna
-    matrice[1][0] = temp;
+    matrice[1][0] = temp;
-}
+}
-
+
-int main() {
+int main() {
-    // Matrice predefinita
+    // Matrice predefinita
-    int matrice[RIGHE][COLONNE] = {
+    int matrice[RIGHE][COLONNE] = {
-        {1,  2,  3,  4},
+        {1,  2,  3,  4},
-        {5,  6,  7,  8},
+        {5,  6,  7,  8},
-        {9,  10, 11, 12},
+        {9,  10, 11, 12},
-        {13, 14, 15, 16}
+        {13, 14, 15, 16}
-    };
+    };
-
+
-    cout << "Matrice originale:\n";
+    cout << "Matrice originale:\n";
-    stampaMatrice(matrice);
+    stampaMatrice(matrice);
-
+
-    // Ruota il bordo in senso orario in-place
+    // Ruota il bordo in senso orario in-place
-    ruotaBordoInPlace(matrice);
+    ruotaBordoInPlace(matrice);
-
+
-    cout << "Matrice dopo la rotazione del bordo (in-place):\n";
+    cout << "Matrice dopo la rotazione del bordo (in-place):\n";
-    stampaMatrice(matrice);
+    stampaMatrice(matrice);
-
+
-    return 0;
+    return 0;
-}
+}
-
+

3AIN/sfusi/Copia di tavola pitagorica.cpp

@@ -1,42 +1,42 @@
-//Cristian Ronzoni 3Ain
+//Cristian Ronzoni 3Ain
-//Tavola pitagorica
+//Tavola pitagorica
-// Righe nel ciclo esterno, colonne nel ciclo interno (righe i, colonne j)
+// Righe nel ciclo esterno, colonne nel ciclo interno (righe i, colonne j)
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#define LATO 10
+#define LATO 10
-
+
-using namespace std;
+using namespace std;
-void riempi(int arr[LATO] [LATO]){
+void riempi(int arr[LATO] [LATO]){
-	for(size_t i = 0; i<LATO; ++i){
+	for(size_t i = 0; i<LATO; ++i){
-		for(size_t j = 0; j<LATO; ++j)
+		for(size_t j = 0; j<LATO; ++j)
-			arr[i][j] = (i + 1) * (j + 1);			
+			arr[i][j] = (i + 1) * (j + 1);			
-				
+				
-		
+		
-	}
+	}
-	
+	
-	
+	
-}
+}
-
+
-
+
-void stampa(int arr[LATO] [LATO]){
+void stampa(int arr[LATO] [LATO]){
-	
+	
-	for(size_t i = 0; i<LATO; ++i){
+	for(size_t i = 0; i<LATO; ++i){
-		for(size_t j = 0; j<LATO; ++j){
+		for(size_t j = 0; j<LATO; ++j){
-			cout << setw(5) << arr[i] [j];
+			cout << setw(5) << arr[i] [j];
-			
+			
-		}
+		}
-		cout << endl;
+		cout << endl;
-	}
+	}
-	
+	
-}
+}
-
+
-
+
-
+
-int main(void){
+int main(void){
-	
+	
-	int mat[LATO] [LATO];
+	int mat[LATO] [LATO];
-	riempi(mat);
+	riempi(mat);
-	stampa(mat);
+	stampa(mat);
-	
+	
-	
+	
-}
+}

3AIN/sfusi/Copia di trova la riga o la colonna con somma più alta(1).cpp

@@ -1,83 +1,83 @@
-// Cristian Ronzoni 3Ain
+// Cristian Ronzoni 3Ain
-/* Funzione che in una matrice
+/* Funzione che in una matrice
-   trova la riga o la colonna con somma più alta */
+   trova la riga o la colonna con somma più alta */
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-#define NUM 7
+#define NUM 7
-using namespace std;
+using namespace std;
-
+
-// Dichiarazione delle funzioni
+// Dichiarazione delle funzioni
-void riempi(int arr[NUM][NUM]);
+void riempi(int arr[NUM][NUM]);
-void stampa(int arr[NUM][NUM]);
+void stampa(int arr[NUM][NUM]);
-void sommaRigaColonna(int arr[NUM][NUM]);
+void sommaRigaColonna(int arr[NUM][NUM]);
-
+
-int main(void) {
+int main(void) {
-    int bobby[NUM][NUM];
+    int bobby[NUM][NUM];
-
+
-    srand(time(0)); // Inizializza il generatore di numeri casuali
+    srand(time(0)); // Inizializza il generatore di numeri casuali
-    riempi(bobby);  // Riempie la matrice con numeri casuali
+    riempi(bobby);  // Riempie la matrice con numeri casuali
-    stampa(bobby);  // Stampa la matrice
+    stampa(bobby);  // Stampa la matrice
-    sommaRigaColonna(bobby); // Trova la riga e la colonna con la somma più alta
+    sommaRigaColonna(bobby); // Trova la riga e la colonna con la somma più alta
-
+
-    return 0;
+    return 0;
-}
+}
-
+
-// Funzione per riempire la matrice con numeri casuali
+// Funzione per riempire la matrice con numeri casuali
-void riempi(int arr[NUM][NUM]) {
+void riempi(int arr[NUM][NUM]) {
-    for (size_t i = 0; i < NUM; ++i) {
+    for (size_t i = 0; i < NUM; ++i) {
-        for (size_t j = 0; j < NUM; ++j) {
+        for (size_t j = 0; j < NUM; ++j) {
-            arr[i][j] = rand() % 50; // Numeri casuali tra 0 e 49
+            arr[i][j] = rand() % 50; // Numeri casuali tra 0 e 49
-        }
+        }
-    }
+    }
-}
+}
-
+
-// Funzione per stampare la matrice
+// Funzione per stampare la matrice
-void stampa(int arr[NUM][NUM]) {
+void stampa(int arr[NUM][NUM]) {
-    cout << "Matrice generata:\n";
+    cout << "Matrice generata:\n";
-    for (size_t i = 0; i < NUM; ++i) {
+    for (size_t i = 0; i < NUM; ++i) {
-        for (size_t j = 0; j < NUM; ++j) {
+        for (size_t j = 0; j < NUM; ++j) {
-            cout << setw(3) << arr[i][j] << " ";
+            cout << setw(3) << arr[i][j] << " ";
-        }
+        }
-        cout << endl;
+        cout << endl;
-    }
+    }
-    cout << endl;
+    cout << endl;
-}
+}
-
+
-// Funzione per trovare la riga e la colonna con somma più alta
+// Funzione per trovare la riga e la colonna con somma più alta
-void sommaRigaColonna(int arr[NUM][NUM]) {
+void sommaRigaColonna(int arr[NUM][NUM]) {
-    int maxSommaRiga = 0, maxSommaColonna = 0;
+    int maxSommaRiga = 0, maxSommaColonna = 0;
-    int rigaMax = -1, colonnaMax = -1;
+    int rigaMax = -1, colonnaMax = -1;
-
+
-    // Calcolo della somma delle righe
+    // Calcolo della somma delle righe
-    for (size_t i = 0; i < NUM; ++i) {
+    for (size_t i = 0; i < NUM; ++i) {
-        int sommaRiga = 0;
+        int sommaRiga = 0;
-        for (size_t j = 0; j < NUM; ++j) {
+        for (size_t j = 0; j < NUM; ++j) {
-            sommaRiga += arr[i][j];
+            sommaRiga += arr[i][j];
-        }
+        }
-        if (sommaRiga > maxSommaRiga) {
+        if (sommaRiga > maxSommaRiga) {
-            maxSommaRiga = sommaRiga;
+            maxSommaRiga = sommaRiga;
-            rigaMax = i;
+            rigaMax = i;
-        }
+        }
-    }
+    }
-
+
-    // Calcolo della somma delle colonne
+    // Calcolo della somma delle colonne
-    for (size_t j = 0; j < NUM; ++j) {
+    for (size_t j = 0; j < NUM; ++j) {
-        int sommaColonna = 0;
+        int sommaColonna = 0;
-        for (size_t i = 0; i < NUM; ++i) {
+        for (size_t i = 0; i < NUM; ++i) {
-            sommaColonna += arr[i][j];
+            sommaColonna += arr[i][j];
-        }
+        }
-        if (sommaColonna > maxSommaColonna) {
+        if (sommaColonna > maxSommaColonna) {
-            maxSommaColonna = sommaColonna;
+            maxSommaColonna = sommaColonna;
-            colonnaMax = j;
+            colonnaMax = j;
-        }
+        }
-    }
+    }
-
+
-    // Stampa dei risultati
+    // Stampa dei risultati
-    cout << "La riga con somma più alta è la riga " << rigaMax + 1
+    cout << "La riga con somma più alta è la riga " << rigaMax + 1
-         << " con somma: " << maxSommaRiga << endl;
+         << " con somma: " << maxSommaRiga << endl;
-    cout << "La colonna con somma più alta è la colonna " << colonnaMax + 1
+    cout << "La colonna con somma più alta è la colonna " << colonnaMax + 1
-         << " con somma: " << maxSommaColonna << endl;
+         << " con somma: " << maxSommaColonna << endl;
-}
+}
-
+

3AIN/sfusi/Copia di trova la riga o la colonna con somma più alta.cpp

@@ -1,83 +1,83 @@
-// Cristian Ronzoni 3Ain
+// Cristian Ronzoni 3Ain
-/* Funzione che in una matrice
+/* Funzione che in una matrice
-   trova la riga o la colonna con somma più alta */
+   trova la riga o la colonna con somma più alta */
-#include <iostream>
+#include <iostream>
-#include <iomanip>
+#include <iomanip>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-#define NUM 7
+#define NUM 7
-using namespace std;
+using namespace std;
-
+
-// Dichiarazione delle funzioni
+// Dichiarazione delle funzioni
-void riempi(int arr[NUM][NUM]);
+void riempi(int arr[NUM][NUM]);
-void stampa(int arr[NUM][NUM]);
+void stampa(int arr[NUM][NUM]);
-void sommaRigaColonna(int arr[NUM][NUM]);
+void sommaRigaColonna(int arr[NUM][NUM]);
-
+
-int main(void) {
+int main(void) {
-    int bobby[NUM][NUM];
+    int bobby[NUM][NUM];
-
+
-    srand(time(0)); // Inizializza il generatore di numeri casuali
+    srand(time(0)); // Inizializza il generatore di numeri casuali
-    riempi(bobby);  // Riempie la matrice con numeri casuali
+    riempi(bobby);  // Riempie la matrice con numeri casuali
-    stampa(bobby);  // Stampa la matrice
+    stampa(bobby);  // Stampa la matrice
-    sommaRigaColonna(bobby); // Trova la riga e la colonna con la somma più alta
+    sommaRigaColonna(bobby); // Trova la riga e la colonna con la somma più alta
-
+
-    return 0;
+    return 0;
-}
+}
-
+
-// Funzione per riempire la matrice con numeri casuali
+// Funzione per riempire la matrice con numeri casuali
-void riempi(int arr[NUM][NUM]) {
+void riempi(int arr[NUM][NUM]) {
-    for (size_t i = 0; i < NUM; ++i) {
+    for (size_t i = 0; i < NUM; ++i) {
-        for (size_t j = 0; j < NUM; ++j) {
+        for (size_t j = 0; j < NUM; ++j) {
-            arr[i][j] = rand() % 50; // Numeri casuali tra 0 e 49
+            arr[i][j] = rand() % 50; // Numeri casuali tra 0 e 49
-        }
+        }
-    }
+    }
-}
+}
-
+
-// Funzione per stampare la matrice
+// Funzione per stampare la matrice
-void stampa(int arr[NUM][NUM]) {
+void stampa(int arr[NUM][NUM]) {
-    cout << "Matrice generata:\n";
+    cout << "Matrice generata:\n";
-    for (size_t i = 0; i < NUM; ++i) {
+    for (size_t i = 0; i < NUM; ++i) {
-        for (size_t j = 0; j < NUM; ++j) {
+        for (size_t j = 0; j < NUM; ++j) {
-            cout << setw(3) << arr[i][j] << " ";
+            cout << setw(3) << arr[i][j] << " ";
-        }
+        }
-        cout << endl;
+        cout << endl;
-    }
+    }
-    cout << endl;
+    cout << endl;
-}
+}
-
+
-// Funzione per trovare la riga e la colonna con somma più alta
+// Funzione per trovare la riga e la colonna con somma più alta
-void sommaRigaColonna(int arr[NUM][NUM]) {
+void sommaRigaColonna(int arr[NUM][NUM]) {
-    int maxSommaRiga = 0, maxSommaColonna = 0;
+    int maxSommaRiga = 0, maxSommaColonna = 0;
-    int rigaMax = -1, colonnaMax = -1;
+    int rigaMax = -1, colonnaMax = -1;
-
+
-    // Calcolo della somma delle righe
+    // Calcolo della somma delle righe
-    for (size_t i = 0; i < NUM; ++i) {
+    for (size_t i = 0; i < NUM; ++i) {
-        int sommaRiga = 0;
+        int sommaRiga = 0;
-        for (size_t j = 0; j < NUM; ++j) {
+        for (size_t j = 0; j < NUM; ++j) {
-            sommaRiga += arr[i][j];
+            sommaRiga += arr[i][j];
-        }
+        }
-        if (sommaRiga > maxSommaRiga) {
+        if (sommaRiga > maxSommaRiga) {
-            maxSommaRiga = sommaRiga;
+            maxSommaRiga = sommaRiga;
-            rigaMax = i;
+            rigaMax = i;
-        }
+        }
-    }
+    }
-
+
-    // Calcolo della somma delle colonne
+    // Calcolo della somma delle colonne
-    for (size_t j = 0; j < NUM; ++j) {
+    for (size_t j = 0; j < NUM; ++j) {
-        int sommaColonna = 0;
+        int sommaColonna = 0;
-        for (size_t i = 0; i < NUM; ++i) {
+        for (size_t i = 0; i < NUM; ++i) {
-            sommaColonna += arr[i][j];
+            sommaColonna += arr[i][j];
-        }
+        }
-        if (sommaColonna > maxSommaColonna) {
+        if (sommaColonna > maxSommaColonna) {
-            maxSommaColonna = sommaColonna;
+            maxSommaColonna = sommaColonna;
-            colonnaMax = j;
+            colonnaMax = j;
-        }
+        }
-    }
+    }
-
+
-    // Stampa dei risultati
+    // Stampa dei risultati
-    cout << "La riga con somma più alta è la riga " << rigaMax + 1
+    cout << "La riga con somma più alta è la riga " << rigaMax + 1
-         << " con somma: " << maxSommaRiga << endl;
+         << " con somma: " << maxSommaRiga << endl;
-    cout << "La colonna con somma più alta è la colonna " << colonnaMax + 1
+    cout << "La colonna con somma più alta è la colonna " << colonnaMax + 1
-         << " con somma: " << maxSommaColonna << endl;
+         << " con somma: " << maxSommaColonna << endl;
-}
+}
-
+

3AIN/sfusi/DEC to BIN.cpp

@@ -1,36 +1,36 @@
-#include <iostream>
+#include <iostream>
-
+
-using namespace std;
+using namespace std;
-
+
-int main(void) {
+int main(void) {
-	int decimale;
+	int decimale;
-	
+	
-	cout << "Inserisci un numero decimale: ";
+	cout << "Inserisci un numero decimale: ";
-	cin >> decimale;
+	cin >> decimale;
-	
+	
-	if (decimale < 0 || decimale > 255) {
+	if (decimale < 0 || decimale > 255) {
-		cout << "Numero decimale non valido!" << endl;
+		cout << "Numero decimale non valido!" << endl;
-		return 0;
+		return 0;
-	}
+	}
-	
+	
-	int binario[9] = {0};
+	int binario[9] = {0};
-	int i = 0;
+	int i = 0;
-	
+	
-    while (decimale > 0 && i < 9) {
+    while (decimale > 0 && i < 9) {
-        binario[i++] = (decimale % 2);
+        binario[i++] = (decimale % 2);
-        decimale = decimale / 2;
+        decimale = decimale / 2;
-    }
+    }
-    binario[i] = '\0';
+    binario[i] = '\0';
-	
+	
-	cout << "Numero binario: ";
+	cout << "Numero binario: ";
-    for (int j = 0; j < 8 - i; j++) {
+    for (int j = 0; j < 8 - i; j++) {
-		cout << "0";
+		cout << "0";
-	}
+	}
-	
+	
-    for (int j = i - 1; j >= 0; j--) {
+    for (int j = i - 1; j >= 0; j--) {
-    	cout << binario[j];
+    	cout << binario[j];
-	}
+	}
-	cout << endl;
+	cout << endl;
-	
+	
-	return 0;
+	return 0;
 }

3AIN/sfusi/DEC to HEX.cpp

@@ -1,38 +1,38 @@
-#include <iostream>
+#include <iostream>
-
+
-using namespace std;
+using namespace std;
-
+
-int main(void) {
+int main(void) {
-	int decimale;
+	int decimale;
-	
+	
-	cout << "Inserisci un numero decimale: ";
+	cout << "Inserisci un numero decimale: ";
-	cin >> decimale;
+	cin >> decimale;
-	
+	
-	if (decimale < 0 || decimale > 255) {
+	if (decimale < 0 || decimale > 255) {
-		cout << "Numero non valido!" << endl;
+		cout << "Numero non valido!" << endl;
-		
+		
-		return 0;
+		return 0;
-	}
+	}
-	
+	
-	char esadecimale[3] = {0};
+	char esadecimale[3] = {0};
-	int i = 0;
+	int i = 0;
-	
+	
-	if (decimale == 0) {
+	if (decimale == 0) {
-		esadecimale[i++] = '0';
+		esadecimale[i++] = '0';
-	}
+	}
-	
+	
-	while (decimale > 0) {
+	while (decimale > 0) {
-        int resto = decimale % 16;
+        int resto = decimale % 16;
-        esadecimale[i++] = (resto < 10) ? ('0' + resto) : ('A' + resto - 10);
+        esadecimale[i++] = (resto < 10) ? ('0' + resto) : ('A' + resto - 10);
-        decimale = decimale / 16;
+        decimale = decimale / 16;
-    }
+    }
-    esadecimale[i] = '\0';
+    esadecimale[i] = '\0';
-
+
-    cout << "Numero esadecimale: ";
+    cout << "Numero esadecimale: ";
-    for (int j = i - 1; j >= 0; j--) {
+    for (int j = i - 1; j >= 0; j--) {
-    	cout << esadecimale[j];
+    	cout << esadecimale[j];
-	}
+	}
-    cout << endl;
+    cout << endl;
-	
+	
-	return 0;
+	return 0;
 }

3AIN/sfusi/DEC to OCT.cpp

@@ -1,37 +1,37 @@
-#include <iostream>
+#include <iostream>
-
+
-using namespace std;
+using namespace std;
-
+
-int main(void) {
+int main(void) {
-	int decimale;
+	int decimale;
-	
+	
-	cout << "Inserisci un numero decimale: ";
+	cout << "Inserisci un numero decimale: ";
-	cin >> decimale;
+	cin >> decimale;
-	
+	
-	if (decimale < 0 || decimale > 255) {
+	if (decimale < 0 || decimale > 255) {
-		cout << "Numero non valido!" << endl;
+		cout << "Numero non valido!" << endl;
-		
+		
-		return 0;
+		return 0;
-	}
+	}
-	
+	
-	char ottale[4] = {0};
+	char ottale[4] = {0};
-	int i = 0;
+	int i = 0;
-	
+	
-	if (decimale == 0) {
+	if (decimale == 0) {
-		ottale[i++] = '0';
+		ottale[i++] = '0';
-	}
+	}
-	
+	
-	while (decimale > 0) {
+	while (decimale > 0) {
-		ottale[i++] = '0' + (decimale % 8);
+		ottale[i++] = '0' + (decimale % 8);
-		decimale = decimale / 8;
+		decimale = decimale / 8;
-	}
+	}
-	ottale[i] = '\0';
+	ottale[i] = '\0';
-    
+    
-	cout << "Numero ottale: ";
+	cout << "Numero ottale: ";
-	for (int j = i - 1; j >= 0; j--) {
+	for (int j = i - 1; j >= 0; j--) {
-		cout << ottale[j];
+		cout << ottale[j];
-	}
+	}
-	cout << endl;
+	cout << endl;
-    
+    
-	return 0;	
+	return 0;	
 }

3AIN/sfusi/DeternSommaMaggDiagPrinOSecond.cpp

@@ -1,30 +1,30 @@
-//Patriche Robert Cosmin
+//Patriche Robert Cosmin
-#include <iostream>
+#include <iostream>
-using namespace std;
+using namespace std;
-
+
-void sommaDiagonali(int matrice[3][3], int n) {
+void sommaDiagonali(int matrice[3][3], int n) {
-    int sommaDiagonalePrincipale = 0;
+    int sommaDiagonalePrincipale = 0;
-    int sommaDiagonaleSecondaria = 0;
+    int sommaDiagonaleSecondaria = 0;
-
+
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++) {
-        sommaDiagonalePrincipale += matrice[i][i];
+        sommaDiagonalePrincipale += matrice[i][i];
-        sommaDiagonaleSecondaria += matrice[i][n - 1 - i];
+        sommaDiagonaleSecondaria += matrice[i][n - 1 - i];
-    }
+    }
-
+
-    cout << "Somma della diagonale principale: " << sommaDiagonalePrincipale << endl;
+    cout << "Somma della diagonale principale: " << sommaDiagonalePrincipale << endl;
-    cout << "Somma della diagonale secondaria: " << sommaDiagonaleSecondaria << endl;
+    cout << "Somma della diagonale secondaria: " << sommaDiagonaleSecondaria << endl;
-
+
-    if (sommaDiagonalePrincipale > sommaDiagonaleSecondaria) {
+    if (sommaDiagonalePrincipale > sommaDiagonaleSecondaria) {
-        cout << "La somma della diagonale principale è maggiore." << endl;
+        cout << "La somma della diagonale principale è maggiore." << endl;
-    } else if (sommaDiagonalePrincipale < sommaDiagonaleSecondaria) {
+    } else if (sommaDiagonalePrincipale < sommaDiagonaleSecondaria) {
-        cout << "La somma della diagonale secondaria è maggiore." << endl;
+        cout << "La somma della diagonale secondaria è maggiore." << endl;
-    } else {
+    } else {
-        cout << "Le somme delle diagonali sono uguali." << endl;
+        cout << "Le somme delle diagonali sono uguali." << endl;
-    }
+    }
-}
+}
-
+
-int main() {
+int main() {
-    int matrice[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    int matrice[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
-    sommaDiagonali(matrice, 3);
+    sommaDiagonali(matrice, 3);
-    return 0;
+    return 0;
-}
+}

3AIN/sfusi/ElemPariDispariMedia.cpp

@@ -1,50 +1,50 @@
-//Patriche Robert Cosmin 3Ain
+//Patriche Robert Cosmin 3Ain
-#include <iostream>
+#include <iostream>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-using namespace std;
+using namespace std;
-
+
-void contaPariDispari(int arr[], int size, int &pari, int &dispari, double &mediaPari, double &mediaDispari);
+void contaPariDispari(int arr[], int size, int &pari, int &dispari, double &mediaPari, double &mediaDispari);
-
+
-int main() {
+int main() {
-    const int DIM = 15;
+    const int DIM = 15;
-    int numeri[DIM];
+    int numeri[DIM];
-    srand(time(0));
+    srand(time(0));
-    
+    
-    cout << "Array: ";
+    cout << "Array: ";
-    for (int i = 0; i < DIM; i++) {
+    for (int i = 0; i < DIM; i++) {
-        numeri[i] = rand() % 100 + 1;
+        numeri[i] = rand() % 100 + 1;
-        cout << numeri[i] << " ";
+        cout << numeri[i] << " ";
-    }
+    }
-    cout << endl;
+    cout << endl;
-    
+    
-    int pari = 0, dispari = 0;
+    int pari = 0, dispari = 0;
-    double mediaPari = 0, mediaDispari = 0;
+    double mediaPari = 0, mediaDispari = 0;
-    contaPariDispari(numeri, DIM, pari, dispari, mediaPari, mediaDispari);
+    contaPariDispari(numeri, DIM, pari, dispari, mediaPari, mediaDispari);
-    
+    
-    cout << "Elementi pari: " << pari << ", Media pari: " << mediaPari << endl;
+    cout << "Elementi pari: " << pari << ", Media pari: " << mediaPari << endl;
-    cout << "Elementi dispari: " << dispari << ", Media dispari: " << mediaDispari << endl;
+    cout << "Elementi dispari: " << dispari << ", Media dispari: " << mediaDispari << endl;
-    if (mediaPari > mediaDispari)
+    if (mediaPari > mediaDispari)
-        cout << "La media dei pari è maggiore." << endl;
+        cout << "La media dei pari è maggiore." << endl;
-    else if (mediaDispari > mediaPari)
+    else if (mediaDispari > mediaPari)
-        cout << "La media dei dispari è maggiore." << endl;
+        cout << "La media dei dispari è maggiore." << endl;
-    else
+    else
-        cout << "Le medie sono uguali." << endl;
+        cout << "Le medie sono uguali." << endl;
-
+
-    return 0;
+    return 0;
-}
+}
-
+
-void contaPariDispari(int arr[], int size, int &pari, int &dispari, double &mediaPari, double &mediaDispari) {
+void contaPariDispari(int arr[], int size, int &pari, int &dispari, double &mediaPari, double &mediaDispari) {
-    int sommaPari = 0, sommaDispari = 0;
+    int sommaPari = 0, sommaDispari = 0;
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++) {
-        if (arr[i] % 2 == 0) {
+        if (arr[i] % 2 == 0) {
-            pari++;
+            pari++;
-            sommaPari += arr[i];
+            sommaPari += arr[i];
-        } else {
+        } else {
-            dispari++;
+            dispari++;
-            sommaDispari += arr[i];
+            sommaDispari += arr[i];
-        }
+        }
-    }
+    }
-    if (pari > 0) mediaPari = static_cast<double>(sommaPari) / pari;
+    if (pari > 0) mediaPari = static_cast<double>(sommaPari) / pari;
-    if (dispari > 0) mediaDispari = static_cast<double>(sommaDispari) / dispari;
+    if (dispari > 0) mediaDispari = static_cast<double>(sommaDispari) / dispari;
-}
+}

3AIN/sfusi/ElementiRIspettoAllaMedia.cpp

@@ -1,56 +1,56 @@
-//Patriche Robert Cosmin
+//Patriche Robert Cosmin
-#include <iostream>
+#include <iostream>
-#include <cstdlib>
+#include <cstdlib>
-#include <ctime>
+#include <ctime>
-using namespace std;
+using namespace std;
-
+
-double calcolaMedia(int arr[], int size);
+double calcolaMedia(int arr[], int size);
-int contaMaggiori(int arr[], int size, double media);
+int contaMaggiori(int arr[], int size, double media);
-void trovaMinori(int arr[], int size, double media);
+void trovaMinori(int arr[], int size, double media);
-
+
-int main() {
+int main() {
-    const int DIM = 15;
+    const int DIM = 15;
-    int numeri[DIM];
+    int numeri[DIM];
-    srand(time(0));
+    srand(time(0));
-    
+    
-    cout << "Array: ";
+    cout << "Array: ";
-    for (int i = 0; i < DIM; i++) {
+    for (int i = 0; i < DIM; i++) {
-        numeri[i] = rand() % 100 + 1;
+        numeri[i] = rand() % 100 + 1;
-        cout << numeri[i] << " ";
+        cout << numeri[i] << " ";
-    }
+    }
-    cout << endl;
+    cout << endl;
-    
+    
-    double media = calcolaMedia(numeri, DIM);
+    double media = calcolaMedia(numeri, DIM);
-    cout << "Media: " << media << endl;
+    cout << "Media: " << media << endl;
-    
+    
-    int maggiori = contaMaggiori(numeri, DIM, media);
+    int maggiori = contaMaggiori(numeri, DIM, media);
-    cout << "Elementi maggiori della media: " << maggiori << endl;
+    cout << "Elementi maggiori della media: " << maggiori << endl;
-    
+    
-    cout << "Indici degli elementi minori della media: ";
+    cout << "Indici degli elementi minori della media: ";
-    trovaMinori(numeri, DIM, media);
+    trovaMinori(numeri, DIM, media);
-    cout << endl;
+    cout << endl;
-
+
-    return 0;
+    return 0;
-}
+}
-
+
-double calcolaMedia(int arr[], int size) {
+double calcolaMedia(int arr[], int size) {
-    double somma = 0;
+    double somma = 0;
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++) {
-        somma += arr[i];
+        somma += arr[i];
-    }
+    }
-    return somma / size;
+    return somma / size;
-}
+}
-
+
-int contaMaggiori(int arr[], int size, double media) {
+int contaMaggiori(int arr[], int size, double media) {
-    int count = 0;
+    int count = 0;
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++) {
-        if (arr[i] > media) count++;
+        if (arr[i] > media) count++;
-    }
+    }
-    return count;
+    return count;
-}
+}
-
+
-void trovaMinori(int arr[], int size, double media) {
+void trovaMinori(int arr[], int size, double media) {
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++) {
-        if (arr[i] < media) cout << i << " ";
+        if (arr[i] < media) cout << i << " ";
-    }
+    }
-}
+}

3AIN/sfusi/Esercizi BINARY FILE (Foschini).txt

@@ -1,31 +1,31 @@
-// Esercizi vol2p141 (file binari)
+// Esercizi vol2p141 (file binari)
-
+
-// es01: Scrivi un programma che generi un file (utilizzare il generatore di numeri pseudocasuali) per la rappresentazione di un insieme di 90 numeri (<100 come nel gioco del lotto).
+// es01: Scrivi un programma che generi un file (utilizzare il generatore di numeri pseudocasuali) per la rappresentazione di un insieme di 90 numeri (<100 come nel gioco del lotto).
-
+
-// es02: Scrivi un programma che utilizzi il file dell'esercizio precedente per leggere i numeri del lotto e che, data una coppia di numeri, verifichi se questa corrisponde ad un ambo.
+// es02: Scrivi un programma che utilizzi il file dell'esercizio precedente per leggere i numeri del lotto e che, data una coppia di numeri, verifichi se questa corrisponde ad un ambo.
-
+
-// es03: Scrivi una funzione che preso in ingresso il nome di un file contenente interi, lo modifichi in modo da contenere gli stessi interi ma in ordine decrescente.
+// es03: Scrivi una funzione che preso in ingresso il nome di un file contenente interi, lo modifichi in modo da contenere gli stessi interi ma in ordine decrescente.
-
+
-// es04: Scrivi una funzione che preso in ingresso il nome di due file produca un nuovo file ottenuto dalla concatenazione dei due file.
+// es04: Scrivi una funzione che preso in ingresso il nome di due file produca un nuovo file ottenuto dalla concatenazione dei due file.
-
+
-// es05: Scrivi una funzione che preso in ingresso il nome di due file produca un nuovo file ottenuto dalla concatenazione dei due file escludendo però i numeri duplicati.
+// es05: Scrivi una funzione che preso in ingresso il nome di due file produca un nuovo file ottenuto dalla concatenazione dei due file escludendo però i numeri duplicati.
-
+
-// es06: Scrivi una funzione che preso in ingresso il nome di due file produca un nuovo file ottenuto dalla intersezione dei due file, cioè inserendo solo i numeri in comune presenti nei due file.
+// es06: Scrivi una funzione che preso in ingresso il nome di due file produca un nuovo file ottenuto dalla intersezione dei due file, cioè inserendo solo i numeri in comune presenti nei due file.
-
+
-// es07: Scrivi un programma che legga da un file "numeri.dat" di 10 righe che rappresenti un array di 10 elementi interi, con ogni elemento memorizzato in una riga, e li memorizzi in un array.
+// es07: Scrivi un programma che legga da un file "numeri.dat" di 10 righe che rappresenti un array di 10 elementi interi, con ogni elemento memorizzato in una riga, e li memorizzi in un array.
-
+
-// es08: Scrivi un programma per salvare, giorno per giorno, su un file binario di nome "pioggia.dat" la quantità di mm di pioggia caduta.
+// es08: Scrivi un programma per salvare, giorno per giorno, su un file binario di nome "pioggia.dat" la quantità di mm di pioggia caduta.
-Successivamente leggi i dati registrati nel file "pioggia.dat" e calcola:
+Successivamente leggi i dati registrati nel file "pioggia.dat" e calcola:
-- la quantità di pioggia mediamente caduta al giorno
+- la quantità di pioggia mediamente caduta al giorno
-- la quantità massima di pioggia caduta in un giorno;
+- la quantità massima di pioggia caduta in un giorno;
-- il periodo (numero di giorni consecutivi) più lungo di siccità.
+- il periodo (numero di giorni consecutivi) più lungo di siccità.
-
+
-// es09: Scrivi un programma che generi un numero random (compreso fra 100 e 200) di numeri interi e li salvi su un file formattato. Quindi vengano ripresi da una funzione che li ordini in due nuovi file, una volta in modo crescente e l'altra in modo decrescente.
+// es09: Scrivi un programma che generi un numero random (compreso fra 100 e 200) di numeri interi e li salvi su un file formattato. Quindi vengano ripresi da una funzione che li ordini in due nuovi file, una volta in modo crescente e l'altra in modo decrescente.
-
+
-// es10: In un programma realizza due funzioni, la prima delle quali crei un file in modalità formattata e inserisca nel file valori interi acquisiti da tastiera, fino ad un massimo di 30; la seconda che legga i dati dal file prodotto dalla esecuzione della prima funzione e verifichi che nel file contenente le medie sia presente un numero di valori pari al numero di esecuzioni della coppia di programmi.
+// es10: In un programma realizza due funzioni, la prima delle quali crei un file in modalità formattata e inserisca nel file valori interi acquisiti da tastiera, fino ad un massimo di 30; la seconda che legga i dati dal file prodotto dalla esecuzione della prima funzione e verifichi che nel file contenente le medie sia presente un numero di valori pari al numero di esecuzioni della coppia di programmi.
-
+
-// es11: Dopo aver completato la struttura dati studente, scrivi la funzione inserisciMedia() che legga un file binario contenente i dati di tutti gli studenti di una classe, privi della media dei voti riportati, e lo aggiorni inserendo nell'apposito campo la media suddetta. La funzione dovrà a sua volta far uso di un'ulteriore, appropriataa, funzione che calcoli la media.
+// es11: Dopo aver completato la struttura dati studente, scrivi la funzione inserisciMedia() che legga un file binario contenente i dati di tutti gli studenti di una classe, privi della media dei voti riportati, e lo aggiorni inserendo nell'apposito campo la media suddetta. La funzione dovrà a sua volta far uso di un'ulteriore, appropriataa, funzione che calcoli la media.
-
+
-// es12: Scrivi un programma che legga un file di testo "matrice.dat" contenente 3 righe, con 3 interi separati da uno spazio per ogni riga. Il programma deve leggere il file, creare una matrice 3x3, contenente i dati presenti in "matrice.dat" e stamparne la trasposta.
+// es12: Scrivi un programma che legga un file di testo "matrice.dat" contenente 3 righe, con 3 interi separati da uno spazio per ogni riga. Il programma deve leggere il file, creare una matrice 3x3, contenente i dati presenti in "matrice.dat" e stamparne la trasposta.
-
+
 // es13: Il programma dovrà permettere all'utente di inserire una serie di rilevamenti geografici (latitudine e longitudine). L'inserimento di una latitudine pari a 100 indicherà la fine della fase di inserimento. L'elaboratore salverà i dati in un file binario. Successivamente l'utente inserirà una latitudine e l'elaboratore, cercando nel file, troverà e visualizzerà tutti i rilevamenti, caratterizzati da qual valore di latitudine. Infine l'elaboratore visualizzerà il numero di rilevamenti trovati.

3AIN/sfusi/Esercizi TEXT FILE (Foschini).txt

@@ -1,240 +1,240 @@
-Input/Output carattere per carattere
+Input/Output carattere per carattere
-
+
-es01. (stampavideo1) Scrivere un programma che stampi a video il contenuto del file in.txt.
+es01. (stampavideo1) Scrivere un programma che stampi a video il contenuto del file in.txt.
-
+
-es02. (stampavideo2) Scrivere una funzione che riceva in ingresso il nome di un file e ne stampi a video il contenuto. Utilizzare la funzione per mostrare il contenuto dei file in.txt e in2.txt.
+es02. (stampavideo2) Scrivere una funzione che riceva in ingresso il nome di un file e ne stampi a video il contenuto. Utilizzare la funzione per mostrare il contenuto dei file in.txt e in2.txt.
-
+
-es03. (contacaratteri) Scrivere una funzione che, ricevuto in ingresso il nome di un file, restituisca il conteggio dei caratteri presenti al suo interno oppure -1 nel caso in cui non sia possibile accedere al file. Utilizzare la funzione per mostrare il numero di caratteri dei file in.txt, in2.txt e nonesiste.txt (si supponga che quest'ultimo file non sia presente nel disco), emettendo un apposito messaggio in presenza di errori di apertura dei file.
+es03. (contacaratteri) Scrivere una funzione che, ricevuto in ingresso il nome di un file, restituisca il conteggio dei caratteri presenti al suo interno oppure -1 nel caso in cui non sia possibile accedere al file. Utilizzare la funzione per mostrare il numero di caratteri dei file in.txt, in2.txt e nonesiste.txt (si supponga che quest'ultimo file non sia presente nel disco), emettendo un apposito messaggio in presenza di errori di apertura dei file.
-
+
-es04. (contaparole) Un file di testo contiene un certo numero di parole. Ogni parola (a eccezione dell'ultima) e` separata da quella successiva da un solo carattere di whitespace. Scrivere un programma che, richiesta l'immissione da tastiera del nome del file da elaborare, visualizzi il conteggio delle parole contenute (suggerimento: contare i whitespace...).
+es04. (contaparole) Un file di testo contiene un certo numero di parole. Ogni parola (a eccezione dell'ultima) e` separata da quella successiva da un solo carattere di whitespace. Scrivere un programma che, richiesta l'immissione da tastiera del nome del file da elaborare, visualizzi il conteggio delle parole contenute (suggerimento: contare i whitespace...).
-
+
-es05. (copiafile1) Scrivere una funzione che, ricevuti in ingresso i nomi di due file, effettui la copia carattere per carattere del primo file nel secondo file. La funzione restituisce true se la copia si e` conclusa con successo, false in caso contrario. Utilizzare la funzione per copiare il file in.txt nel file out.txt.
+es05. (copiafile1) Scrivere una funzione che, ricevuti in ingresso i nomi di due file, effettui la copia carattere per carattere del primo file nel secondo file. La funzione restituisce true se la copia si e` conclusa con successo, false in caso contrario. Utilizzare la funzione per copiare il file in.txt nel file out.txt.
-
+
-es06. (copiafile2) Scrivere un programma che effettui la copia un file di testo in un altro file trasformando le lettere minuscole in maiuscole e le maiuscole in minuscole.
+es06. (copiafile2) Scrivere un programma che effettui la copia un file di testo in un altro file trasformando le lettere minuscole in maiuscole e le maiuscole in minuscole.
-
+
-es07. (copialettere) Scrivere un programma che, richiesto da tastiera il nome di un file testo, memorizzi i caratteri dell'alfabeto nel file lettere.txt e tutti gli altri caratteri in altri_car.txt.
+es07. (copialettere) Scrivere un programma che, richiesto da tastiera il nome di un file testo, memorizzi i caratteri dell'alfabeto nel file lettere.txt e tutti gli altri caratteri in altri_car.txt.
-
+
-es08. (accodaparole) Dopo aver creato due file di testo parole1.txt e parole2.txt, ciascuno contenente un elenco di parole separate da uno spazio, scrivere un programma che accodi il contenuto del primo file al secondo file. Alla fine dell'esecuzione, osservare il contenuto del secondo file con un editor testuale.
+es08. (accodaparole) Dopo aver creato due file di testo parole1.txt e parole2.txt, ciascuno contenente un elenco di parole separate da uno spazio, scrivere un programma che accodi il contenuto del primo file al secondo file. Alla fine dell'esecuzione, osservare il contenuto del secondo file con un editor testuale.
-
+
-
+
-
+
-Input/Output per linee di testo
+Input/Output per linee di testo
-
+
-es09. (inverti) Scrivere un programma che inverta ogni riga contenuta nel file righe.txt e riporti il risultato sullo schermo (per esempio, la riga Prova di stampa diventa apmats id avorP).
+es09. (inverti) Scrivere un programma che inverta ogni riga contenuta nel file righe.txt e riporti il risultato sullo schermo (per esempio, la riga Prova di stampa diventa apmats id avorP).
-
+
-es10. (filtralinee) Scrivere una funzione che accetti come parametri d'ingresso due nomi di file e una parola P e memorizzi nel secondo file le sole righe del primo che contengono P (suggerimento: usare la funzione strstr).
+es10. (filtralinee) Scrivere una funzione che accetti come parametri d'ingresso due nomi di file e una parola P e memorizzi nel secondo file le sole righe del primo che contengono P (suggerimento: usare la funzione strstr).
-
+
-es11. (accodalinee) Scrivere un programma che, chiesto in input il nome di un file di testo, accodi le linee del file al file di output risultato.txt, sostituendo le linee più lunghe di 20 caratteri con la stringa --LINEA TROPPO LUNGA--.
+es11. (accodalinee) Scrivere un programma che, chiesto in input il nome di un file di testo, accodi le linee del file al file di output risultato.txt, sostituendo le linee più lunghe di 20 caratteri con la stringa --LINEA TROPPO LUNGA--.
-
+
-es12. (contalinee) Scrivere una funzione che accetti due parametri (un nome di file e una stringa S) e restituisca il conteggio delle righe contenenti S oppure -1 nel caso di errori nella gestione del 
+es12. (contalinee) Scrivere una funzione che accetti due parametri (un nome di file e una stringa S) e restituisca il conteggio delle righe contenenti S oppure -1 nel caso di errori nella gestione del 
-file. Dopo aver creato un file di testo, utilizzare la funzione per contare le linee del file che contengono la parola BIANCO.
+file. Dopo aver creato un file di testo, utilizzare la funzione per contare le linee del file che contengono la parola BIANCO.
-
+
-es13. (paginaweb) Scrivere un programma che generi automaticamente una pagina web di nome test.html avente il seguente contenuto testuale:
+es13. (paginaweb) Scrivere un programma che generi automaticamente una pagina web di nome test.html avente il seguente contenuto testuale:
-<!doctype html>
+<!doctype html>
-<html lang="it">
+<html lang="it">
-	<head>
+	<head>
-		<meta charset='UTF-8'>
+		<meta charset='UTF-8'>
-		<title>Pagina generata automaticamente</title>
+		<title>Pagina generata automaticamente</title>
-	</head>
+	</head>
-	<body>
+	<body>
-		<p style='color: red;'>
+		<p style='color: red;'>
-			Questa pagina &egrave; stata generata automaticamente
+			Questa pagina &egrave; stata generata automaticamente
-			da un programma scritto in linguaggio C.
+			da un programma scritto in linguaggio C.
-		</p>
+		</p>
-	</body>
+	</body>
-</html>
+</html>
-
+
-
+
-
+
-Input/Output formattato
+Input/Output formattato
-
+
-es14. (numeri) Scrivere un programma che memorizzi in un file di testo e su una sola linea i primi 15 numeri pari separati da uno spazio.
+es14. (numeri) Scrivere un programma che memorizzi in un file di testo e su una sola linea i primi 15 numeri pari separati da uno spazio.
-
+
-es15. (multipli) Scrivere una funzione a due parametri interi A e N che memorizzi nel file di testo output.txt i primi N multipli di A (un solo multiplo per ogni riga).
+es15. (multipli) Scrivere una funzione a due parametri interi A e N che memorizzi nel file di testo output.txt i primi N multipli di A (un solo multiplo per ogni riga).
-
+
-es16. (casuali) Scrivere una funzione che, ricevuti in ingresso un nome di file e un numero intero N, memorizzi nel file N numeri casuali disposti a coppie su linee diverse (una coppia per ogni linea).
+es16. (casuali) Scrivere una funzione che, ricevuti in ingresso un nome di file e un numero intero N, memorizzi nel file N numeri casuali disposti a coppie su linee diverse (una coppia per ogni linea).
-
+
-es17. (statistica) Scrivere un programma che, a partire da uno dei file prodotti nell'esercizio precedente, determini, per ogni coppia, una statistica formata dalla somma e dalla media dei due valori, riportando i risultati nel file statistica.txt (una statistica per ogni linea; all'interno della linea, separare la somma dalla media con un tabulatore).
+es17. (statistica) Scrivere un programma che, a partire da uno dei file prodotti nell'esercizio precedente, determini, per ogni coppia, una statistica formata dalla somma e dalla media dei due valori, riportando i risultati nel file statistica.txt (una statistica per ogni linea; all'interno della linea, separare la somma dalla media con un tabulatore).
-
+
-es18. (occorrenze) Scrivere una funzione che, ricevuti in ingresso un nome di file e una parola S, restituisca il numero di occorrenze di S all'interno del file oppure -1 in caso di errore nella gestione del file. La funzione opera sotto le seguenti condizioni: una parola è una sequenza di caratteri priva di whitespace; un file è composto da una sequenza di parole separate da whitespace; la ricerca delle occorrenze è di tipo case insensitive.
+es18. (occorrenze) Scrivere una funzione che, ricevuti in ingresso un nome di file e una parola S, restituisca il numero di occorrenze di S all'interno del file oppure -1 in caso di errore nella gestione del file. La funzione opera sotto le seguenti condizioni: una parola è una sequenza di caratteri priva di whitespace; un file è composto da una sequenza di parole separate da whitespace; la ricerca delle occorrenze è di tipo case insensitive.
-
+
-es19. (maxmin) Scrivere un programma che calcoli il massimo e il minimo di una sequenza di valori interi contenuti in un file numeri.txt e memorizzi i risultati in maxmin.txt su due righe diverse nel seguente formato:
+es19. (maxmin) Scrivere un programma che calcoli il massimo e il minimo di una sequenza di valori interi contenuti in un file numeri.txt e memorizzi i risultati in maxmin.txt su due righe diverse nel seguente formato:
-Valore minimo: ....
+Valore minimo: ....
-Valore massimo: ....
+Valore massimo: ....
-Si ipotizzi di non conoscere a priori ne` il numero esatto di valori contenuti nel file ne` il numero massimo di valori previsto per questo esercizio.
+Si ipotizzi di non conoscere a priori ne` il numero esatto di valori contenuti nel file ne` il numero massimo di valori previsto per questo esercizio.
-
+
-es20. (voti1) Un file di testo voti.txt contiene i voti di un certo numero di studenti secondo il seguente formato:
+es20. (voti1) Un file di testo voti.txt contiene i voti di un certo numero di studenti secondo il seguente formato:
-<cognome> <nome> <N> <voto1> <voto2> ... <votoN>
+<cognome> <nome> <N> <voto1> <voto2> ... <votoN>
-Poiche` ogni studente puo` avere un numero diverso di voti, ogni riga include (dopo il nome) il numero N di voti registrati per quello studente, seguito da un elenco di N voti (approssimati a una cifra decimale). Un possibile esempio di file e` il seguente:
+Poiche` ogni studente puo` avere un numero diverso di voti, ogni riga include (dopo il nome) il numero N di voti registrati per quello studente, seguito da un elenco di N voti (approssimati a una cifra decimale). Un possibile esempio di file e` il seguente:
-Bianchi Paolo 3 7.0 7.5 6.0
+Bianchi Paolo 3 7.0 7.5 6.0
-Rossi Maria 4 8.5 8.0 8.0 9.0
+Rossi Maria 4 8.5 8.0 8.0 9.0
-Scrivere un programma che acquisisca i voti degli studenti e produca in output:
+Scrivere un programma che acquisisca i voti degli studenti e produca in output:
-a) Il file medie.txt contenente le medie (approssimate a due cifre decimali) dei voti di ciascuno studente, nel formato:
+a) Il file medie.txt contenente le medie (approssimate a due cifre decimali) dei voti di ciascuno studente, nel formato:
-<cognome> <nome> <media>
+<cognome> <nome> <media>
-b) Il file esiti.txt contenente l'esito di fine anno scolastico di ogni studente: "debito" se la media e` inferiore a 6, "promosso" in caso contrario. Il formato del file e` <cognome> <nome> <esito>
+b) Il file esiti.txt contenente l'esito di fine anno scolastico di ogni studente: "debito" se la media e` inferiore a 6, "promosso" in caso contrario. Il formato del file e` <cognome> <nome> <esito>
-
+
-es21. (misurecampo) Si vuole realizzare un programma che calcoli il perimetro e l'area di un terreno poligonale.
+es21. (misurecampo) Si vuole realizzare un programma che calcoli il perimetro e l'area di un terreno poligonale.
-Utilizzando un ricevitore GPS si determinano innanzitutto le coordinate x,y degli N vertici del poligono. I dati sono successivamente memorizzati in un file di testo secondo il seguente formato:
+Utilizzando un ricevitore GPS si determinano innanzitutto le coordinate x,y degli N vertici del poligono. I dati sono successivamente memorizzati in un file di testo secondo il seguente formato:
-u_m
+u_m
-N
+N
-x0 y0
+x0 y0
-x1 y1
+x1 y1
-.
+.
-xN-1 yN-1
+xN-1 yN-1
-La prima riga del file contiene una stringa rappresentante l'unita` di misura in cui sono espresse le coordinate; la seconda riga contiene un intero N che indica il numero dei vertici del poligono; le successive N righe contengono le coordinate reali dei vertici (una coppia di coordinate per ogni riga).
+La prima riga del file contiene una stringa rappresentante l'unita` di misura in cui sono espresse le coordinate; la seconda riga contiene un intero N che indica il numero dei vertici del poligono; le successive N righe contengono le coordinate reali dei vertici (una coppia di coordinate per ogni riga).
-Il programma deve svolgere le seguenti operazioni:
+Il programma deve svolgere le seguenti operazioni:
-a) chiedere all'utente il nome del file di input e acquisirne l'intero contenuto, memorizzando le coordinate in un'apposita struttura dati;
+a) chiedere all'utente il nome del file di input e acquisirne l'intero contenuto, memorizzando le coordinate in un'apposita struttura dati;
-b) determinare il perimetro e l'area del terreno utilizzando le seguenti formule:
+b) determinare il perimetro e l'area del terreno utilizzando le seguenti formule:
-perimetro: P = somma{k =0->N-1} (x[(i+1)mod N]-x[i])^2 + (y[(i+1)mod N]-y[i])^2 (somma dei lati)
+perimetro: P = somma{k =0->N-1} (x[(i+1)mod N]-x[i])^2 + (y[(i+1)mod N]-y[i])^2 (somma dei lati)
-area: A = 1/2*|somma{k=0,N-1} (x[i]*y[(i+1) mod N] + x[(i+1) mod N]*y[i])| (formula di Gauss)
+area: A = 1/2*|somma{k=0,N-1} (x[i]*y[(i+1) mod N] + x[(i+1) mod N]*y[i])| (formula di Gauss)
-c) chiedere all'utente il nome di un file di ouput e memorizzare al suo interno i risultati ottenuti (valore e unita` di misura di perimetro e area).
+c) chiedere all'utente il nome di un file di ouput e memorizzare al suo interno i risultati ottenuti (valore e unita` di misura di perimetro e area).
-Per esempio, a partire dal seguente file di input:
+Per esempio, a partire dal seguente file di input:
-dam
+dam
-6
+6
--0.57  -1.05
+-0.57  -1.05
- 4.05   8.19
+ 4.05   8.19
-15.60  10.50
+15.60  10.50
-24.84   3.57
+24.84   3.57
-20.22  -1.05
+20.22  -1.05
- 8.67  -3.36
+ 8.67  -3.36
-il programma deve riportare in un nuovo file i messaggi:
+il programma deve riportare in un nuovo file i messaggi:
-Perimetro: 61.50 dam
+Perimetro: 61.50 dam
-Area: 229.45 dam^2
+Area: 229.45 dam^2
-
+
-es22. (scrivitab) Scrivere un programma che legga da tastiera e memorizzi in un'apposita struttura dati la seguente tabella:
+es22. (scrivitab) Scrivere un programma che legga da tastiera e memorizzi in un'apposita struttura dati la seguente tabella:
-+-----------------+-----------------+-------------+-------------+
++-----------------+-----------------+-------------+-------------+
-| Cognome         | Nome            | Altezza (m) | Peso (kg)   |
+| Cognome         | Nome            | Altezza (m) | Peso (kg)   |
-+-----------------+-----------------+-------------+-------------+
++-----------------+-----------------+-------------+-------------+
-| Rossi           | Mario           |        1.75 |          76 |
+| Rossi           | Mario           |        1.75 |          76 |
-| Ferraro         | Carlo           |        1.84 |          82 |
+| Ferraro         | Carlo           |        1.84 |          82 |
-| Marelli         | Chiara          |        1.65 |          58 |
+| Marelli         | Chiara          |        1.65 |          58 |
-+-----------------+-----------------+-------------+-------------+
++-----------------+-----------------+-------------+-------------+
-Terminato il caricamento, il programma deve memorizzare l'intera tabella nel file di testo tabella.txt (un record per linea, campi separati con un tabulatore; non deve essere memorizzata la riga d'intestazione). Si ipotizzi che tutti i campi testuali siano privi di spazi, che le altezze siano numeri float e i pesi numeri interi.
+Terminato il caricamento, il programma deve memorizzare l'intera tabella nel file di testo tabella.txt (un record per linea, campi separati con un tabulatore; non deve essere memorizzata la riga d'intestazione). Si ipotizzi che tutti i campi testuali siano privi di spazi, che le altezze siano numeri float e i pesi numeri interi.
-
+
-es23. (mostratab) Scrivere un programma che acquisisca da un file di testo la tabella dell'esercizio precedente e la visualizzi sullo schermo nel seguente formato:
+es23. (mostratab) Scrivere un programma che acquisisca da un file di testo la tabella dell'esercizio precedente e la visualizzi sullo schermo nel seguente formato:
-+-----------------+-----------------+-------------+-------------+
++-----------------+-----------------+-------------+-------------+
-| Cognome         | Nome            | Altezza (m) | Peso (kg)   |
+| Cognome         | Nome            | Altezza (m) | Peso (kg)   |
-+-----------------+-----------------+-------------+-------------+
++-----------------+-----------------+-------------+-------------+
-| Rossi           | Mario           |        1.75 |          76 |
+| Rossi           | Mario           |        1.75 |          76 |
-| Ferraro         | Carlo           |        1.84 |          82 |
+| Ferraro         | Carlo           |        1.84 |          82 |
-| Marelli         | Chiara          |        1.65 |          58 |
+| Marelli         | Chiara          |        1.65 |          58 |
-+-----------------+-----------------+-------------+-------------+
++-----------------+-----------------+-------------+-------------+
-
+
-
+
-
+
-Esercizi extra (file di testo)
+Esercizi extra (file di testo)
-// es91: Scrivere un programma che legge da file di testo una sequenza di parole e scrive un nuovo file sostituendo ad alcune parole (presenti in una lista) i loro contrari. Es: odio->amore, guerra->pace, ecc.
+// es91: Scrivere un programma che legge da file di testo una sequenza di parole e scrive un nuovo file sostituendo ad alcune parole (presenti in una lista) i loro contrari. Es: odio->amore, guerra->pace, ecc.
-void uno(char c) {
+void uno(char c) {
-	static char parola[50+1] = "";
+	static char parola[50+1] = "";
-	static char oldc = ' ';
+	static char oldc = ' ';
-	static unsigned i = 0;
+	static unsigned i = 0;
-
+
-	if (isspace(c))
+	if (isspace(c))
-		if (isspace(oldc)) {
+		if (isspace(oldc)) {
-			// due spazi consecutivi
+			// due spazi consecutivi
-			printf("%c", c);
+			printf("%c", c);
-		else {
+		else {
-			// e` appena terminata una parola; se appartiene ad una lista, sostituiscila
+			// e` appena terminata una parola; se appartiene ad una lista, sostituiscila
-			parola[i++] = '\0';
+			parola[i++] = '\0';
-			if (strcmp(parola, "odio"))
+			if (strcmp(parola, "odio"))
-				strcpy(parola, "amore");
+				strcpy(parola, "amore");
-			else if (strcmp(parola, "guerra"))
+			else if (strcmp(parola, "guerra"))
-				strcpy(parola, "pace");
+				strcpy(parola, "pace");
-			printf("%s", parola);
+			printf("%s", parola);
-			i = 0;
+			i = 0;
-		}
+		}
-	}
+	}
-	else
+	else
-		// accodo la lettera in una parola
+		// accodo la lettera in una parola
-		parola[i++] = c;
+		parola[i++] = c;
-	oldc = c;
+	oldc = c;
-}
+}
-
+
-// es92: Scrivere un programma che legge da file di testo una stringa e un carattere e verifica se il carattere e` presente nella stringa. Il risultato viene scritto su un nuovo file: se il carattere e` presente scrive "true", altrimenti scrive "false"
+// es92: Scrivere un programma che legge da file di testo una stringa e un carattere e verifica se il carattere e` presente nella stringa. Il risultato viene scritto su un nuovo file: se il carattere e` presente scrive "true", altrimenti scrive "false"
-bool presente(char str[], char c) {
+bool presente(char str[], char c) {
-	// soluzione1
+	// soluzione1
-	bool result = false;
+	bool result = false;
-	for (unsigned int j = 0; j < strlen(str); j++) {
+	for (unsigned int j = 0; j < strlen(str); j++) {
-		if (str[j]==c) {
+		if (str[j]==c) {
-			result = true;
+			result = true;
-			break;
+			break;
-		}
+		}
-	}
+	}
-	return result;
+	return result;
-
+
-	// soluzione2
+	// soluzione2
-	return (strchr(str, c) != NULL);
+	return (strchr(str, c) != NULL);
-}
+}
-
+
-
+
-// es93: Scrivere un programma che legge da file di testo una stringa e la riscrive su un nuovo file dopo averla ruotata a SX per num volte.
+// es93: Scrivere un programma che legge da file di testo una stringa e la riscrive su un nuovo file dopo averla ruotata a SX per num volte.
-void nshift(char stringa[], unsigned int num) {
+void nshift(char stringa[], unsigned int num) {
-	for (unsigned int j = 0; j < num; j++) {
+	for (unsigned int j = 0; j < num; j++) {
-		char temp = stringa[0];
+		char temp = stringa[0];
-		for (unsigned int i = 0; i < strlen(stringa)-1; i++)
+		for (unsigned int i = 0; i < strlen(stringa)-1; i++)
-			stringa[i] = stringa[i+1];
+			stringa[i] = stringa[i+1];
-		stringa[strlen(stringa)-1] = temp;
+		stringa[strlen(stringa)-1] = temp;
-	}
+	}
-}
+}
-
+
-/*
+/*
-Soluzione impropria (con fread/fwrite) dell'es05(copiafile1).
+Soluzione impropria (con fread/fwrite) dell'es05(copiafile1).
-E' evidente che il file non viene copiato "carattere per carattere" ma "1000 caratteri per 1000 caratteri"
+E' evidente che il file non viene copiato "carattere per carattere" ma "1000 caratteri per 1000 caratteri"
-*/
+*/
-bool es05(const char * filenamein, const char * filenameout) {
+bool es05(const char * filenamein, const char * filenameout) {
-	FILE * fi = fopen(filenamein, "r");
+	FILE * fi = fopen(filenamein, "r");
-	if (fi != NULL) {
+	if (fi != NULL) {
-		FILE * fo = fopen(filenameout, "w");
+		FILE * fo = fopen(filenameout, "w");
-		if (fo != NULL) {
+		if (fo != NULL) {
-			char buffer[MAXBUFFER]; // non e` una stringa, ma una sequenza di bytes...
+			char buffer[MAXBUFFER]; // non e` una stringa, ma una sequenza di bytes...
-			int nr, nw;
+			int nr, nw;
-			while ((nr = fread(buffer, sizeof(buffer[0]), MAXBUFFER, fi)) > 0) {
+			while ((nr = fread(buffer, sizeof(buffer[0]), MAXBUFFER, fi)) > 0) {
-				nw = fwrite(buffer, sizeof(buffer[0]), nr, fo);
+				nw = fwrite(buffer, sizeof(buffer[0]), nr, fo);
-				if (nw < nr)
+				if (nw < nr)
-					return false;
+					return false;
-			}
+			}
-			if (fclose(fo)<0)
+			if (fclose(fo)<0)
-				return false;
+				return false;
-		}
+		}
-		if (fclose(fi)<0)
+		if (fclose(fi)<0)
-			return false;
+			return false;
-	}
+	}
-	return true;
+	return true;
-}
+}
-
+
-/*
+/*
-Soluzione impropria (con fread/fwrite) dell'es10(filtralinee).
+Soluzione impropria (con fread/fwrite) dell'es10(filtralinee).
-Contiene una apertura multipla del file di input, l'utilizzo di un buffer come stringa, e altra brutta roba
+Contiene una apertura multipla del file di input, l'utilizzo di un buffer come stringa, e altra brutta roba
-*/
+*/
-void es10(const char * filenamein, const char * filenameout) {
+void es10(const char * filenamein, const char * filenameout) {
-	char parola[] = "ciao";
+	char parola[] = "ciao";
-
+
-	FILE * fi = fopen(filenamein, "r");
+	FILE * fi = fopen(filenamein, "r");
-	if (fi != NULL) {
+	if (fi != NULL) {
-		FILE * ft = fopen(filenamein, "r"); // ad esclusivo uso della fread
+		FILE * ft = fopen(filenamein, "r"); // ad esclusivo uso della fread
-		int n = 0;
+		int n = 0;
-		int c;
+		int c;
-		while((c=fgetc(fi))!=EOF) {
+		while((c=fgetc(fi))!=EOF) {
-			n++;
+			n++;
-			if (c=='\n'){
+			if (c=='\n'){
-				char frase[n+1];
+				char frase[n+1];
-				int nr = fread(frase, sizeof(frase[0]), n, ft);
+				int nr = fread(frase, sizeof(frase[0]), n, ft);
-				frase[nr] = '\0';
+				frase[nr] = '\0';
-
+
-				if (nr < n)
+				if (nr < n)
-					// TODO: gestire errore
+					// TODO: gestire errore
-					;
+					;
-
+
-				if (strstr(frase, parola)!=NULL) {
+				if (strstr(frase, parola)!=NULL) {
-					// TODO: gestire errori
+					// TODO: gestire errori
-					FILE * fo = fopen(filenameout, "a");
+					FILE * fo = fopen(filenameout, "a");
-					fwrite(frase, sizeof(frase[0]), nr, fo);
+					fwrite(frase, sizeof(frase[0]), nr, fo);
-					fclose(fo);
+					fclose(fo);
-				}
+				}
-				n = 0;
+				n = 0;
-			}
+			}
-		}
+		}
-		fclose(ft);
+		fclose(ft);
-		fclose(fi);
+		fclose(fi);
-	}
+	}
 }

3AIN/sfusi/Esercizio CSV - Tipo 1.cpp

@@ -1,55 +1,55 @@
-/*
+/*
-Nome: Mario
+Nome: Mario
-Cognome: Montanari
+Cognome: Montanari
-Classe: 3AIN
+Classe: 3AIN
-Data: 07/04/2025
+Data: 07/04/2025
-
+
-File di Testo CSV
+File di Testo CSV
-con l'uso di strtok()
+con l'uso di strtok()
-*/
+*/
-
+
-#include <iostream>
+#include <iostream>
-#include <cstring>
+#include <cstring>
-
+
-#define SIZE_LINE 1000+1
+#define SIZE_LINE 1000+1
-
+
-using namespace std;
+using namespace std;
-
+
-void apriFile(const char * nomeFile);
+void apriFile(const char * nomeFile);
-
+
-int main(void) {
+int main(void) {
-	apriFile("File CSV.txt");
+	apriFile("File CSV.txt");
-	
+	
-	return 0;
+	return 0;
-}
+}
-
+
-void apriFile(const char * nomeFile) {
+void apriFile(const char * nomeFile) {
-	FILE * fp = fopen(nomeFile, "rt");
+	FILE * fp = fopen(nomeFile, "rt");
-	
+	
-	if (fp != NULL) {
+	if (fp != NULL) {
-		char *ptr;
+		char *ptr;
-		char str[SIZE_LINE];
+		char str[SIZE_LINE];
-		char nome[SIZE_LINE];
+		char nome[SIZE_LINE];
-		char cognome[SIZE_LINE];
+		char cognome[SIZE_LINE];
-		int i = 0;
+		int i = 0;
-		
+		
-		while (fgets(str, sizeof(str), fp) != NULL) {
+		while (fgets(str, sizeof(str), fp) != NULL) {
-			ptr = strtok(str, " ");
+			ptr = strtok(str, " ");
-			strcpy(nome, ptr);
+			strcpy(nome, ptr);
-			cout << nome << " ";
+			cout << nome << " ";
-			
+			
-			ptr = strtok(NULL, ";");
+			ptr = strtok(NULL, ";");
-			strcpy(cognome, ptr);
+			strcpy(cognome, ptr);
-			cout << cognome << " ";
+			cout << cognome << " ";
-		
+		
-			ptr = strtok(NULL, ";");
+			ptr = strtok(NULL, ";");
-			cout << atoi(ptr) << endl;
+			cout << atoi(ptr) << endl;
-			
+			
-			i++;
+			i++;
-		}
+		}
-				
+				
-		fclose(fp);
+		fclose(fp);
-	} else {
+	} else {
-		perror("Error (soure)");
+		perror("Error (soure)");
-	}
+	}
 }

3AIN/sfusi/Esercizio CSV - Tipo 2.cpp

@@ -1,42 +1,42 @@
-/*
+/*
-Nome: Mario
+Nome: Mario
-Cognome: Montanari
+Cognome: Montanari
-Classe: 3AIN
+Classe: 3AIN
-Data: 07/04/2025
+Data: 07/04/2025
-
+
-File di Testo CSV
+File di Testo CSV
-con l'uso di fscanf()
+con l'uso di fscanf()
-*/
+*/
-
+
-#include <iostream>
+#include <iostream>
-
+
-#define SIZE_LINE 1000+1
+#define SIZE_LINE 1000+1
-
+
-using namespace std;
+using namespace std;
-
+
-void apriFile(const char * nomeFile);
+void apriFile(const char * nomeFile);
-
+
-int main(void) {
+int main(void) {
-	apriFile("File CSV.txt");
+	apriFile("File CSV.txt");
-	
+	
-	return 0;
+	return 0;
-}
+}
-
+
-void apriFile(const char * nomeFile) {
+void apriFile(const char * nomeFile) {
-	FILE * fp = fopen(nomeFile, "rt");
+	FILE * fp = fopen(nomeFile, "rt");
-	
+	
-	if (fp != NULL) {
+	if (fp != NULL) {
-		char nome[SIZE_LINE];
+		char nome[SIZE_LINE];
-		char cognome[SIZE_LINE];
+		char cognome[SIZE_LINE];
-		int eta;
+		int eta;
-		int i = 0;
+		int i = 0;
-		
+		
-		while (fscanf(fp, "%[^ ] %[^;];%d", nome, cognome, &eta) == 3) {
+		while (fscanf(fp, "%[^ ] %[^;];%d", nome, cognome, &eta) == 3) {
-			cout << nome << " " << cognome << " " << eta;
+			cout << nome << " " << cognome << " " << eta;
-		}
+		}
-		
+		
-		fclose(fp);
+		fclose(fp);
-	} else {
+	} else {
-		perror("Error (source)");
+		perror("Error (source)");
-	}
+	}
 }