emmev-code
/
School-Coding-Cpp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Organize repository

This commit is contained in:
Vichingo455 2025-07-31 16:00:16 +02:00
parent b3ffe2f9e2
commit 1ef236a9e1
531 changed files with 38140 additions and 38140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
sfusi/G.c → 2N/G.c
View File

0
sfusi/H.c → 2N/H.c
View File

0
sfusi/I.c → 2N/I.c
View File

0
sfusi/L.c → 2N/L.c
View File

0
sfusi/M.c → 2N/M.c
View File

0
sfusi/N.c → 2N/N.c
View File

0
sfusi/O.c → 2N/O.c
View File

0
sfusi/t.c → 2N/t.c
View File

128
sfusi/v.c → 2N/v.c
View File

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

128
sfusi/z.c → 2N/z.c
View File

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

0
array/array_pari.cpp → 3AIN/array/array_pari.cpp
View File

72
array/array_tutti_pari.cpp → 3AIN/array/array_tutti_pari.cpp
View File

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

398
array/arraytools.h → 3AIN/array/arraytools.h
View File

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

50
array/conta_numeri.cpp → 3AIN/array/conta_numeri.cpp
View File

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

76
array/elimina_pari_vettori.cpp → 3AIN/array/elimina_pari_vettori.cpp
View File

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

92
array/elimina_pari_vettori_memmove.cpp → 3AIN/array/elimina_pari_vettori_memmove.cpp
View File

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

66
array/maggiori_minori_array.cpp → 3AIN/array/maggiori_minori_array.cpp
View File

@ -1,33 +1,33 @@
/*
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.
*/
#include <iostream>
#include <array>
#include <vector>
#include <cstdlib>
#define SIZE 6
using namespace std;
void maggioriMinori(int array[], size_t array_size, int numero) {
int maggiori = 0, minori = 0;
for (int i = 0; i < array_size; i++) {
if (array[i] < numero)
minori++;
else if (array[i] > numero)
maggiori++;
}
cout << "I numeri maggiori di " << numero << " sono " << maggiori << ", mentre quelli minori sono " << minori << endl;
}
int main() {
int array[SIZE],numero;
for (int i = 0; i < SIZE; i++) {
cout << "Inserisci il valore: ";
cin >> array[i];
cout << endl;
}
cout << "Inserisci il numero master: ";
cin >> numero;
cout << endl;
maggioriMinori(array, SIZE, numero);
return 0;
}
/*
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.
*/
#include <iostream>
#include <array>
#include <vector>
#include <cstdlib>
#define SIZE 6
using namespace std;
void maggioriMinori(int array[], size_t array_size, int numero) {
int maggiori = 0, minori = 0;
for (int i = 0; i < array_size; i++) {
if (array[i] < numero)
minori++;
else if (array[i] > numero)
maggiori++;
}
cout << "I numeri maggiori di " << numero << " sono " << maggiori << ", mentre quelli minori sono " << minori << endl;
}
int main() {
int array[SIZE],numero;
for (int i = 0; i < SIZE; i++) {
cout << "Inserisci il valore: ";
cin >> array[i];
cout << endl;
}
cout << "Inserisci il numero master: ";
cin >> numero;
cout << endl;
maggioriMinori(array, SIZE, numero);
return 0;
}

92
array/media_variaz.cpp → 3AIN/array/media_variaz.cpp
View File

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

0
array/medie.cpp → 3AIN/array/medie.cpp
View File

66
array/somma_array_zero.cpp → 3AIN/array/somma_array_zero.cpp
View File

@ -1,33 +1,33 @@
/*
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
*/
#include <iostream>
#include <array>
#include <vector>
#include <cstdlib>
using namespace std;
int sommaNegativi(int array[], size_t size) {
int somma;
for (int i = 0; i < size; i++) {
if (array[i] < 0) {
somma += array[i];
array[i] = 0;
}
}
return somma;
}
int main() {
size_t dimensioneArray;
cout << "Inserisci il numero di valori da memorizzare: ";
cin >> dimensioneArray;
cout << endl;
int array[dimensioneArray];
for (int i = 0; i < dimensioneArray; i++) {
cout << "Inserisci il valore: ";
cin >> array[i];
cout << endl;
}
cout << "La somma dei numeri negativi e': " << sommaNegativi(array,dimensioneArray) << endl;
return 0;
}
/*
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
*/
#include <iostream>
#include <array>
#include <vector>
#include <cstdlib>
using namespace std;
int sommaNegativi(int array[], size_t size) {
int somma;
for (int i = 0; i < size; i++) {
if (array[i] < 0) {
somma += array[i];
array[i] = 0;
}
}
return somma;
}
int main() {
size_t dimensioneArray;
cout << "Inserisci il numero di valori da memorizzare: ";
cin >> dimensioneArray;
cout << endl;
int array[dimensioneArray];
for (int i = 0; i < dimensioneArray; i++) {
cout << "Inserisci il valore: ";
cin >> array[i];
cout << endl;
}
cout << "La somma dei numeri negativi e': " << sommaNegativi(array,dimensioneArray) << endl;
return 0;
}

44
array/somma_positivi.cpp → 3AIN/array/somma_positivi.cpp
View File

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

70
array/stampa_coppie.cpp → 3AIN/array/stampa_coppie.cpp
View File

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

0
cicli_operatori/LunghezzaTipi.cpp → 3AIN/cicli_operatori/LunghezzaTipi.cpp
View File

0
cicli_operatori/README.md → 3AIN/cicli_operatori/README.md
View File

0
cicli_operatori/cifre1.cpp → 3AIN/cicli_operatori/cifre1.cpp
View File

0
cicli_operatori/cifre2.cpp → 3AIN/cicli_operatori/cifre2.cpp
View File

0
cicli_operatori/conta_dispari.cpp → 3AIN/cicli_operatori/conta_dispari.cpp
View File

0
cicli_operatori/controllo.cpp → 3AIN/cicli_operatori/controllo.cpp
View File

0
cicli_operatori/elaborato3.cpp → 3AIN/cicli_operatori/elaborato3.cpp
View File

0
cicli_operatori/esagonali_centrati.cpp → 3AIN/cicli_operatori/esagonali_centrati.cpp
View File

0
cicli_operatori/fizz buzz.cpp → 3AIN/cicli_operatori/fizz buzz.cpp
View File

0
cicli_operatori/hello world.cpp → 3AIN/cicli_operatori/hello world.cpp
View File

0
cicli_operatori/manipulators_WIP.cpp → 3AIN/cicli_operatori/manipulators_WIP.cpp
View File

0
cicli_operatori/moltiplicaz_diversa_1.cpp → 3AIN/cicli_operatori/moltiplicaz_diversa_1.cpp
View File

0
cicli_operatori/num eri.cpp → 3AIN/cicli_operatori/num eri.cpp
View File

0
cicli_operatori/num_short.cpp → 3AIN/cicli_operatori/num_short.cpp
View File

0
cicli_operatori/sensori.cpp → 3AIN/cicli_operatori/sensori.cpp
View File

0
cicli_operatori/sensori2.cpp → 3AIN/cicli_operatori/sensori2.cpp
View File

0
cicli_operatori/somma_diversa_0.cpp → 3AIN/cicli_operatori/somma_diversa_0.cpp
View File

0
cicli_operatori/somma_multipla.cpp → 3AIN/cicli_operatori/somma_multipla.cpp
View File

0
cicli_operatori/temperatura.cpp → 3AIN/cicli_operatori/temperatura.cpp
View File

0
cicli_operatori/test.cpp → 3AIN/cicli_operatori/test.cpp
View File

0
cicli_operatori/tipo di triangolo.cpp → 3AIN/cicli_operatori/tipo di triangolo.cpp
View File

0
cicli_operatori/valore_assoluto.cpp → 3AIN/cicli_operatori/valore_assoluto.cpp
View File

0
file/es1.cpp → 3AIN/file/es1.cpp
View File

84
file/es18_cdoctor.cpp → 3AIN/file/es18_cdoctor.cpp
View File

@ -1,42 +1,42 @@
/*
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.
*/
#include <iostream>
#include <cstring>
#include <cctype>
using namespace std;
int searchWord(const char * fileName, const char * word) {
FILE* file = fopen(fileName,"r");
unsigned occorrenze = 0;
if (file != NULL) {
char buffer[256];
char wordModified[256];
for (size_t i = 0; i < strlen(word); i++) {
if (!isupper(word[i])) {
wordModified[i] = toupper(word[i]);
}
else {
wordModified[i] = word[i];
}
}
while(fgets(buffer,sizeof(buffer),file)) {
for (size_t i = 0; buffer[i] != '\0'; i++) {
if (isalpha(buffer[i]) && !isupper(buffer[i])) {
buffer[i] = toupper(buffer[i]);
}
}
}
fclose(file);
return occorrenze;
}
else {
perror("Errore durante l'apertura del file");
return -1;
}
return -1;
}
int main(void) {
cout << "Occorrenze: " << searchWord("occorrenze.txt","parola") << endl;
return 0;
}
/*
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.
*/
#include <iostream>
#include <cstring>
#include <cctype>
using namespace std;
int searchWord(const char * fileName, const char * word) {
FILE* file = fopen(fileName,"r");
unsigned occorrenze = 0;
if (file != NULL) {
char buffer[256];
char wordModified[256];
for (size_t i = 0; i < strlen(word); i++) {
if (!isupper(word[i])) {
wordModified[i] = toupper(word[i]);
}
else {
wordModified[i] = word[i];
}
}
while(fgets(buffer,sizeof(buffer),file)) {
for (size_t i = 0; buffer[i] != '\0'; i++) {
if (isalpha(buffer[i]) && !isupper(buffer[i])) {
buffer[i] = toupper(buffer[i]);
}
}
}
fclose(file);
return occorrenze;
}
else {
perror("Errore durante l'apertura del file");
return -1;
}
return -1;
}
int main(void) {
cout << "Occorrenze: " << searchWord("occorrenze.txt","parola") << endl;
return 0;
}

74
file/es1_binary.cpp → 3AIN/file/es1_binary.cpp
View File

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

38
file/es2.cpp → 3AIN/file/es2.cpp
View File

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

182
file/es2_binary.cpp → 3AIN/file/es2_binary.cpp
View File

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

170
file/es3_binary.cpp → 3AIN/file/es3_binary.cpp
View File

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

102
file/es6_binary.cpp → 3AIN/file/es6_binary.cpp
View File

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

64
file/es7_binary.cpp → 3AIN/file/es7_binary.cpp
View File

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

130
file/es8_binary.cpp → 3AIN/file/es8_binary.cpp
View File

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

70
file/filtralinee_fauser.cpp → 3AIN/file/filtralinee_fauser.cpp
View File

@ -1,35 +1,35 @@
/*
AUTORE: Manuel Vichi
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
*/
#include <iostream>
#include <cstring>
#include <cctype>
using namespace std;
void filtraLinee(const char* fileNameRead, const char* fileNameWrite, const char* word) {
FILE* file = fopen(fileNameRead,"r");
if (file != NULL) {
FILE* destination = fopen(fileNameWrite,"w");
if (destination != NULL) {
char riga[256];
while (fgets(riga, sizeof(riga),file)) {
if (strstr(riga, word)) {
fputs(riga, destination);
}
}
fclose(destination);
}
else {
perror("Errore nella scrittura del file");
}
fclose(file);
}
else {
perror("Errore nella lettura del file");
}
}
int main(void) {
filtraLinee("righe.txt","righeParole.txt","Moodle");
return 0;
}
/*
AUTORE: Manuel Vichi
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
*/
#include <iostream>
#include <cstring>
#include <cctype>
using namespace std;
void filtraLinee(const char* fileNameRead, const char* fileNameWrite, const char* word) {
FILE* file = fopen(fileNameRead,"r");
if (file != NULL) {
FILE* destination = fopen(fileNameWrite,"w");
if (destination != NULL) {
char riga[256];
while (fgets(riga, sizeof(riga),file)) {
if (strstr(riga, word)) {
fputs(riga, destination);
}
}
fclose(destination);
}
else {
perror("Errore nella scrittura del file");
}
fclose(file);
}
else {
perror("Errore nella lettura del file");
}
}
int main(void) {
filtraLinee("righe.txt","righeParole.txt","Moodle");
return 0;
}

350
file/fsorts.h → 3AIN/file/fsorts.h
View File

@ -1,176 +1,176 @@
/*
AUTORE: Manuel Vichi 3^AIN
Algoritmi sort su file
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
void fSelectionSort(const char *nomeFile) {
FILE *fp = fopen(nomeFile, "r+b");
if (fp == NULL) {
perror("Errore nell'apertura del file");
return;
}
fseek(fp, 0, SEEK_END);
long dimensioneFile = ftell(fp);
fseek(fp, 0, SEEK_SET);
size_t n = dimensioneFile / sizeof(int);
int valoreMin, valoreCorrente;
size_t indiceMin;
int temp;
for (size_t i = 0; i < n - 1; i++) {
indiceMin = i;
fseek(fp, i * sizeof(int), SEEK_SET);
fread(&valoreMin, sizeof(int), 1, fp);
for (size_t j = i + 1; j < n; j++) {
fseek(fp, j * sizeof(int), SEEK_SET);
fread(&valoreCorrente, sizeof(int), 1, fp);
if (valoreCorrente < valoreMin) {
valoreMin = valoreCorrente;
indiceMin = j;
}
}
if (indiceMin != i) {
fseek(fp, i * sizeof(int), SEEK_SET);
fread(&temp, sizeof(int), 1, fp);
int valoreTemp;
fseek(fp, indiceMin * sizeof(int), SEEK_SET);
fread(&valoreTemp, sizeof(int), 1, fp);
fseek(fp, i * sizeof(int), SEEK_SET);
fwrite(&valoreTemp, sizeof(int), 1, fp);
fseek(fp, indiceMin * sizeof(int), SEEK_SET);
fwrite(&temp, sizeof(int), 1, fp);
}
}
fclose(fp);
}
void fBubbleSort(const char *nomeFile) {
FILE *fp = fopen(nomeFile, "r+b");
if (fp == NULL) {
perror("Errore nell'apertura del file");
return;
}
fseek(fp, 0, SEEK_END);
long dimensioneFile = ftell(fp);
fseek(fp, 0, SEEK_SET);
size_t n = dimensioneFile / sizeof(int);
int valore1, valore2;
bool scambiato;
for (size_t i = 0; i < n - 1; i++) {
scambiato = false;
for (size_t j = 0; j < n - i - 1; j++) {
fseek(fp, j * sizeof(int), SEEK_SET);
if (fread(&valore1, sizeof(int), 1, fp) != 1) {
perror("Errore di lettura del file");
fclose(fp);
return;
}
fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
if (fread(&valore2, sizeof(int), 1, fp) != 1) {
perror("Errore di lettura del file");
fclose(fp);
return;
}
if (valore1 > valore2) {
fseek(fp, j * sizeof(int), SEEK_SET);
if (fwrite(&valore2, sizeof(int), 1, fp) != 1) {
perror("Errore di scrittura nel file");
fclose(fp);
return;
}
fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
if (fwrite(&valore1, sizeof(int), 1, fp) != 1) {
perror("Errore di scrittura nel file");
fclose(fp);
return;
}
scambiato = true;
}
}
if (!scambiato) {
break;
}
}
fclose(fp);
}
void swap(FILE *fp, int pos1, int pos2, size_t elementSize) {
int temp1, temp2;
fseek(fp, pos1 * elementSize, SEEK_SET);
fread(&temp1, elementSize, 1, fp);
fseek(fp, pos2 * elementSize, SEEK_SET);
fread(&temp2, elementSize, 1, fp);
fseek(fp, pos1 * elementSize, SEEK_SET);
fwrite(&temp2, elementSize, 1, fp);
fseek(fp, pos2 * elementSize, SEEK_SET);
fwrite(&temp1, elementSize, 1, fp);
}
int partition(FILE *fp, int low, int high, size_t elementSize) {
int pivot;
fseek(fp, high * elementSize, SEEK_SET);
fread(&pivot, elementSize, 1, fp);
int i = low - 1;
for (int j = low; j < high; j++) {
int current;
fseek(fp, j * elementSize, SEEK_SET);
fread(&current, elementSize, 1, fp);
if (current < pivot) {
i++;
swap(fp, i, j, elementSize);
}
}
swap(fp, i + 1, high, elementSize);
return i + 1;
}
/*
Funzione per ordinamento in-place con Quick Sort
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.
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.
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) {
if (low < high) {
int pi = partition(fp, low, high, elementSize);
fQuickSort(fp, low, pi - 1, elementSize);
fQuickSort(fp, pi + 1, high, elementSize);
}
}
// Funzione per ordinare in-place un file binario utilizzando l'Insertion Sort.
// Parametri:
// fp - puntatore ad un file aperto in modalità binaria
// record_size - dimensione in byte di ogni record (ad esempio, sizeof(int))
// cmp - funzione per confrontare due record
void fInsertionSort(FILE *fp, size_t record_size, int (*cmp)(const void *, const void *)) {
fseek(fp, 0, SEEK_END);
long file_size = ftell(fp);
size_t num_records = file_size / record_size;
void *key = malloc(record_size);
void *temp = malloc(record_size);
if (!key || !temp) {
perror("Errore nell'allocazione della memoria");
free(key);
free(temp);
return;
}
for (size_t i = 1; i < num_records; i++) {
fseek(fp, i * record_size, SEEK_SET);
fread(key, record_size, 1, fp);
size_t j = i;
while (j > 0) {
fseek(fp, (j - 1) * record_size, SEEK_SET);
fread(temp, record_size, 1, fp);
if (cmp(temp, key) <= 0) {
break;
}
fseek(fp, j * record_size, SEEK_SET);
fwrite(temp, record_size, 1, fp);
j--;
}
fseek(fp, j * record_size, SEEK_SET);
fwrite(key, record_size, 1, fp);
}
free(key);
free(temp);
/*
AUTORE: Manuel Vichi 3^AIN
Algoritmi sort su file
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
void fSelectionSort(const char *nomeFile) {
FILE *fp = fopen(nomeFile, "r+b");
if (fp == NULL) {
perror("Errore nell'apertura del file");
return;
}
fseek(fp, 0, SEEK_END);
long dimensioneFile = ftell(fp);
fseek(fp, 0, SEEK_SET);
size_t n = dimensioneFile / sizeof(int);
int valoreMin, valoreCorrente;
size_t indiceMin;
int temp;
for (size_t i = 0; i < n - 1; i++) {
indiceMin = i;
fseek(fp, i * sizeof(int), SEEK_SET);
fread(&valoreMin, sizeof(int), 1, fp);
for (size_t j = i + 1; j < n; j++) {
fseek(fp, j * sizeof(int), SEEK_SET);
fread(&valoreCorrente, sizeof(int), 1, fp);
if (valoreCorrente < valoreMin) {
valoreMin = valoreCorrente;
indiceMin = j;
}
}
if (indiceMin != i) {
fseek(fp, i * sizeof(int), SEEK_SET);
fread(&temp, sizeof(int), 1, fp);
int valoreTemp;
fseek(fp, indiceMin * sizeof(int), SEEK_SET);
fread(&valoreTemp, sizeof(int), 1, fp);
fseek(fp, i * sizeof(int), SEEK_SET);
fwrite(&valoreTemp, sizeof(int), 1, fp);
fseek(fp, indiceMin * sizeof(int), SEEK_SET);
fwrite(&temp, sizeof(int), 1, fp);
}
}
fclose(fp);
}
void fBubbleSort(const char *nomeFile) {
FILE *fp = fopen(nomeFile, "r+b");
if (fp == NULL) {
perror("Errore nell'apertura del file");
return;
}
fseek(fp, 0, SEEK_END);
long dimensioneFile = ftell(fp);
fseek(fp, 0, SEEK_SET);
size_t n = dimensioneFile / sizeof(int);
int valore1, valore2;
bool scambiato;
for (size_t i = 0; i < n - 1; i++) {
scambiato = false;
for (size_t j = 0; j < n - i - 1; j++) {
fseek(fp, j * sizeof(int), SEEK_SET);
if (fread(&valore1, sizeof(int), 1, fp) != 1) {
perror("Errore di lettura del file");
fclose(fp);
return;
}
fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
if (fread(&valore2, sizeof(int), 1, fp) != 1) {
perror("Errore di lettura del file");
fclose(fp);
return;
}
if (valore1 > valore2) {
fseek(fp, j * sizeof(int), SEEK_SET);
if (fwrite(&valore2, sizeof(int), 1, fp) != 1) {
perror("Errore di scrittura nel file");
fclose(fp);
return;
}
fseek(fp, (j + 1) * sizeof(int), SEEK_SET);
if (fwrite(&valore1, sizeof(int), 1, fp) != 1) {
perror("Errore di scrittura nel file");
fclose(fp);
return;
}
scambiato = true;
}
}
if (!scambiato) {
break;
}
}
fclose(fp);
}
void swap(FILE *fp, int pos1, int pos2, size_t elementSize) {
int temp1, temp2;
fseek(fp, pos1 * elementSize, SEEK_SET);
fread(&temp1, elementSize, 1, fp);
fseek(fp, pos2 * elementSize, SEEK_SET);
fread(&temp2, elementSize, 1, fp);
fseek(fp, pos1 * elementSize, SEEK_SET);
fwrite(&temp2, elementSize, 1, fp);
fseek(fp, pos2 * elementSize, SEEK_SET);
fwrite(&temp1, elementSize, 1, fp);
}
int partition(FILE *fp, int low, int high, size_t elementSize) {
int pivot;
fseek(fp, high * elementSize, SEEK_SET);
fread(&pivot, elementSize, 1, fp);
int i = low - 1;
for (int j = low; j < high; j++) {
int current;
fseek(fp, j * elementSize, SEEK_SET);
fread(&current, elementSize, 1, fp);
if (current < pivot) {
i++;
swap(fp, i, j, elementSize);
}
}
swap(fp, i + 1, high, elementSize);
return i + 1;
}
/*
Funzione per ordinamento in-place con Quick Sort
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.
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.
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) {
if (low < high) {
int pi = partition(fp, low, high, elementSize);
fQuickSort(fp, low, pi - 1, elementSize);
fQuickSort(fp, pi + 1, high, elementSize);
}
}
// Funzione per ordinare in-place un file binario utilizzando l'Insertion Sort.
// Parametri:
// fp - puntatore ad un file aperto in modalità binaria
// record_size - dimensione in byte di ogni record (ad esempio, sizeof(int))
// cmp - funzione per confrontare due record
void fInsertionSort(FILE *fp, size_t record_size, int (*cmp)(const void *, const void *)) {
fseek(fp, 0, SEEK_END);
long file_size = ftell(fp);
size_t num_records = file_size / record_size;
void *key = malloc(record_size);
void *temp = malloc(record_size);
if (!key || !temp) {
perror("Errore nell'allocazione della memoria");
free(key);
free(temp);
return;
}
for (size_t i = 1; i < num_records; i++) {
fseek(fp, i * record_size, SEEK_SET);
fread(key, record_size, 1, fp);
size_t j = i;
while (j > 0) {
fseek(fp, (j - 1) * record_size, SEEK_SET);
fread(temp, record_size, 1, fp);
if (cmp(temp, key) <= 0) {
break;
}
fseek(fp, j * record_size, SEEK_SET);
fwrite(temp, record_size, 1, fp);
j--;
}
fseek(fp, j * record_size, SEEK_SET);
fwrite(key, record_size, 1, fp);
}
free(key);
free(temp);
}

72
file/inverti_fauser.cpp → 3AIN/file/inverti_fauser.cpp
View File

@ -1,36 +1,36 @@
/*
AUTORE: Manuel Vichi
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).
*/
#include <iostream>
#include <cstring>
#include <cctype>
using namespace std;
void invertiFile(const char* fileName) {
FILE* file = fopen(fileName, "r");
if (file != NULL) {
char riga[256];
while (fgets(riga, sizeof(riga), file)) {
int n = strlen(riga);
if (riga[n - 1] == '\n') {
riga[n - 1] = '\0';
n--;
}
for (int i = 0; i < n / 2; i++) {
char temp = riga[i];
riga[i] = riga[n - i - 1];
riga[n - i - 1] = temp;
}
cout << riga << endl;
}
fclose(file);
}
else {
perror("Errore durante la lettura di un file: ");
}
}
int main(void) {
invertiFile("righe.txt");
return 0;
}
/*
AUTORE: Manuel Vichi
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).
*/
#include <iostream>
#include <cstring>
#include <cctype>
using namespace std;
void invertiFile(const char* fileName) {
FILE* file = fopen(fileName, "r");
if (file != NULL) {
char riga[256];
while (fgets(riga, sizeof(riga), file)) {
int n = strlen(riga);
if (riga[n - 1] == '\n') {
riga[n - 1] = '\0';
n--;
}
for (int i = 0; i < n / 2; i++) {
char temp = riga[i];
riga[i] = riga[n - i - 1];
riga[n - i - 1] = temp;
}
cout << riga << endl;
}
fclose(file);
}
else {
perror("Errore durante la lettura di un file: ");
}
}
int main(void) {
invertiFile("righe.txt");
return 0;
}

46
file/prova_file.cpp → 3AIN/file/prova_file.cpp
View File

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

100
file/read_binary.cpp → 3AIN/file/read_binary.cpp
View File

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

56
file/sort_example.cpp → 3AIN/file/sort_example.cpp
View File

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

40
file/write_binary.cpp → 3AIN/file/write_binary.cpp
View File

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

0
funzioni/30ott.cpp → 3AIN/funzioni/30ott.cpp
View File

120
funzioni/30ott_test.cpp → 3AIN/funzioni/30ott_test.cpp
View File

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

190
funzioni/descrizione_numero.cpp → 3AIN/funzioni/descrizione_numero.cpp
View File

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

0
funzioni/inverti_numero.cpp → 3AIN/funzioni/inverti_numero.cpp
View File

52
funzioni/potenze.cpp → 3AIN/funzioni/potenze.cpp
View File

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

44
funzioni/reLu.cpp → 3AIN/funzioni/reLu.cpp
View File

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

48
funzioni/segno.cpp → 3AIN/funzioni/segno.cpp
View File

@ -1,24 +1,24 @@
/*
AUTORE: Manuel Vichi
Funzione segno
*/
#include <iostream>
#include <array>
#include <vector>
#include <cstdlib>
using namespace std;
signed int sign(int number) {
if (number > 0)
return +1;
else if (number == 0)
return 0;
else
return -1;
}
int main() {
signed int numero;
cout << "Inserisci un 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;
return 0;
}
/*
AUTORE: Manuel Vichi
Funzione segno
*/
#include <iostream>
#include <array>
#include <vector>
#include <cstdlib>
using namespace std;
signed int sign(int number) {
if (number > 0)
return +1;
else if (number == 0)
return 0;
else
return -1;
}
int main() {
signed int numero;
cout << "Inserisci un 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;
return 0;
}

0
funzioni/triangolo.cpp → 3AIN/funzioni/triangolo.cpp
View File

0
menu/menu1_test.cpp → 3AIN/menu/menu1_test.cpp
View File

74
sfusi/3x4.cpp → 3AIN/sfusi/3x4.cpp
View File

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

50
sfusi/4x5SommaEleColVett.cpp → 3AIN/sfusi/4x5SommaEleColVett.cpp
View File

@ -1,25 +1,25 @@
//Patriche Robert Cosmin
#include <iostream>
using namespace std;
void sommaColonne(int matrice[4][5], int righe, int colonne) {
int somma[5] = {0};
for (int i = 0; i < righe; i++) {
for (int j = 0; j < colonne; j++) {
somma[j] += matrice[i][j];
}
}
cout << "Somma per colonna: ";
for (int j = 0; j < colonne; j++) {
cout << somma[j] << " ";
}
cout << endl;
}
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}};
sommaColonne(matrice, 4, 5);
return 0;
}
//Patriche Robert Cosmin
#include <iostream>
using namespace std;
void sommaColonne(int matrice[4][5], int righe, int colonne) {
int somma[5] = {0};
for (int i = 0; i < righe; i++) {
for (int j = 0; j < colonne; j++) {
somma[j] += matrice[i][j];
}
}
cout << "Somma per colonna: ";
for (int j = 0; j < colonne; j++) {
cout << somma[j] << " ";
}
cout << endl;
}
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}};
sommaColonne(matrice, 4, 5);
return 0;
}

0
sfusi/60000_parole_italiane.txt → 3AIN/sfusi/60000_parole_italiane.txt
View File

74
sfusi/BIN to DEC.cpp → 3AIN/sfusi/BIN to DEC.cpp
View File

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

58
sfusi/BubbleSort.cpp → 3AIN/sfusi/BubbleSort.cpp
View File

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

58
sfusi/CalcConfrontiCercareMassRestituireCoord.cpp → 3AIN/sfusi/CalcConfrontiCercareMassRestituireCoord.cpp
View File

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

62
sfusi/CalcProddVettore.cpp → 3AIN/sfusi/CalcProddVettore.cpp
View File

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

98
sfusi/CalcoloMedia.cpp → 3AIN/sfusi/CalcoloMedia.cpp
View File

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

72
sfusi/ContaPosNegNul.cpp → 3AIN/sfusi/ContaPosNegNul.cpp
View File

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

104
sfusi/Copia di One hot.cpp → 3AIN/sfusi/Copia di One hot.cpp
View File

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

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

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

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

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

128
sfusi/Copia di contaPariEDispari.cpp → 3AIN/sfusi/Copia di contaPariEDispari.cpp
View File

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

90
sfusi/Copia di matrice identità.cpp → 3AIN/sfusi/Copia di matrice identità.cpp
View File

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

96
sfusi/Copia di matrice triangolare.cpp → 3AIN/sfusi/Copia di matrice triangolare.cpp
View File

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

86
sfusi/Copia di mettiAZeroPariDispari - Copia.cpp → 3AIN/sfusi/Copia di mettiAZeroPariDispari - Copia.cpp
View File

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

146
sfusi/Copia di ruota il bordo di una matrice.cpp → 3AIN/sfusi/Copia di ruota il bordo di una matrice.cpp
View File

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

84
sfusi/Copia di tavola pitagorica.cpp → 3AIN/sfusi/Copia di tavola pitagorica.cpp
View File

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

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

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

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

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

70
sfusi/DEC to BIN.cpp → 3AIN/sfusi/DEC to BIN.cpp
View File

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

74
sfusi/DEC to HEX.cpp → 3AIN/sfusi/DEC to HEX.cpp
View File

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

72
sfusi/DEC to OCT.cpp → 3AIN/sfusi/DEC to OCT.cpp
View File

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

60
sfusi/DeternSommaMaggDiagPrinOSecond.cpp → 3AIN/sfusi/DeternSommaMaggDiagPrinOSecond.cpp
View File

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

100
sfusi/ElemPariDispariMedia.cpp → 3AIN/sfusi/ElemPariDispariMedia.cpp
View File

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

112
sfusi/ElementiRIspettoAllaMedia.cpp → 3AIN/sfusi/ElementiRIspettoAllaMedia.cpp
View File

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

60
sfusi/Esercizi BINARY FILE (Foschini).txt → 3AIN/sfusi/Esercizi BINARY FILE (Foschini).txt
View File

@ -1,31 +1,31 @@
// 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).
// 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.
// 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.
// 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.
// 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:
- la quantità di pioggia mediamente caduta al giorno
- la quantità massima di pioggia caduta in un giorno;
- 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.
// 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.
// 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.
// 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).
// 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.
// 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.
// 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.
// 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:
- la quantità di pioggia mediamente caduta al giorno
- la quantità massima di pioggia caduta in un giorno;
- 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.
// 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.
// 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.

2330
sfusi/Esercizi STRING (Foschini).txt → 3AIN/sfusi/Esercizi STRING (Foschini).txt
View File

File diff suppressed because it is too large Load Diff

478
sfusi/Esercizi TEXT FILE (Foschini).txt → 3AIN/sfusi/Esercizi TEXT FILE (Foschini).txt
View File

@ -1,240 +1,240 @@
Input/Output carattere per carattere
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.
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...).
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.
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.
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).
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--.
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.
es13. (paginaweb) Scrivere un programma che generi automaticamente una pagina web di nome test.html avente il seguente contenuto testuale:
<!doctype html>
<html lang="it">
<head>
<meta charset='UTF-8'>
<title>Pagina generata automaticamente</title>
</head>
<body>
<p style='color: red;'>
Questa pagina &egrave; stata generata automaticamente
da un programma scritto in linguaggio C.
</p>
</body>
</html>
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.
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).
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.
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 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.
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>
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
Rossi Maria 4 8.5 8.0 8.0 9.0
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:
<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>
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:
u_m
N
x0 y0
x1 y1
.
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).
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;
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)
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).
Per esempio, a partire dal seguente file di input:
dam
6
-0.57 -1.05
4.05 8.19
15.60 10.50
24.84 3.57
20.22 -1.05
8.67 -3.36
il programma deve riportare in un nuovo file i messaggi:
Perimetro: 61.50 dam
Area: 229.45 dam^2
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) |
+-----------------+-----------------+-------------+-------------+
| Rossi | Mario | 1.75 | 76 |
| Ferraro | Carlo | 1.84 | 82 |
| 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.
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) |
+-----------------+-----------------+-------------+-------------+
| Rossi | Mario | 1.75 | 76 |
| Ferraro | Carlo | 1.84 | 82 |
| Marelli | Chiara | 1.65 | 58 |
+-----------------+-----------------+-------------+-------------+
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.
void uno(char c) {
static char parola[50+1] = "";
static char oldc = ' ';
static unsigned i = 0;
if (isspace(c))
if (isspace(oldc)) {
// due spazi consecutivi
printf("%c", c);
else {
// e` appena terminata una parola; se appartiene ad una lista, sostituiscila
parola[i++] = '\0';
if (strcmp(parola, "odio"))
strcpy(parola, "amore");
else if (strcmp(parola, "guerra"))
strcpy(parola, "pace");
printf("%s", parola);
i = 0;
}
}
else
// accodo la lettera in una parola
parola[i++] = 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"
bool presente(char str[], char c) {
// soluzione1
bool result = false;
for (unsigned int j = 0; j < strlen(str); j++) {
if (str[j]==c) {
result = true;
break;
}
}
return result;
// soluzione2
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.
void nshift(char stringa[], unsigned int num) {
for (unsigned int j = 0; j < num; j++) {
char temp = stringa[0];
for (unsigned int i = 0; i < strlen(stringa)-1; i++)
stringa[i] = stringa[i+1];
stringa[strlen(stringa)-1] = temp;
}
}
/*
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"
*/
bool es05(const char * filenamein, const char * filenameout) {
FILE * fi = fopen(filenamein, "r");
if (fi != NULL) {
FILE * fo = fopen(filenameout, "w");
if (fo != NULL) {
char buffer[MAXBUFFER]; // non e` una stringa, ma una sequenza di bytes...
int nr, nw;
while ((nr = fread(buffer, sizeof(buffer[0]), MAXBUFFER, fi)) > 0) {
nw = fwrite(buffer, sizeof(buffer[0]), nr, fo);
if (nw < nr)
return false;
}
if (fclose(fo)<0)
return false;
}
if (fclose(fi)<0)
return false;
}
return true;
}
/*
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
*/
void es10(const char * filenamein, const char * filenameout) {
char parola[] = "ciao";
FILE * fi = fopen(filenamein, "r");
if (fi != NULL) {
FILE * ft = fopen(filenamein, "r"); // ad esclusivo uso della fread
int n = 0;
int c;
while((c=fgetc(fi))!=EOF) {
n++;
if (c=='\n'){
char frase[n+1];
int nr = fread(frase, sizeof(frase[0]), n, ft);
frase[nr] = '\0';
if (nr < n)
// TODO: gestire errore
;
if (strstr(frase, parola)!=NULL) {
// TODO: gestire errori
FILE * fo = fopen(filenameout, "a");
fwrite(frase, sizeof(frase[0]), nr, fo);
fclose(fo);
}
n = 0;
}
}
fclose(ft);
fclose(fi);
}
Input/Output carattere per carattere
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.
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...).
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.
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.
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).
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--.
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.
es13. (paginaweb) Scrivere un programma che generi automaticamente una pagina web di nome test.html avente il seguente contenuto testuale:
<!doctype html>
<html lang="it">
<head>
<meta charset='UTF-8'>
<title>Pagina generata automaticamente</title>
</head>
<body>
<p style='color: red;'>
Questa pagina &egrave; stata generata automaticamente
da un programma scritto in linguaggio C.
</p>
</body>
</html>
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.
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).
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.
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 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.
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>
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
Rossi Maria 4 8.5 8.0 8.0 9.0
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:
<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>
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:
u_m
N
x0 y0
x1 y1
.
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).
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;
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)
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).
Per esempio, a partire dal seguente file di input:
dam
6
-0.57 -1.05
4.05 8.19
15.60 10.50
24.84 3.57
20.22 -1.05
8.67 -3.36
il programma deve riportare in un nuovo file i messaggi:
Perimetro: 61.50 dam
Area: 229.45 dam^2
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) |
+-----------------+-----------------+-------------+-------------+
| Rossi | Mario | 1.75 | 76 |
| Ferraro | Carlo | 1.84 | 82 |
| 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.
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) |
+-----------------+-----------------+-------------+-------------+
| Rossi | Mario | 1.75 | 76 |
| Ferraro | Carlo | 1.84 | 82 |
| Marelli | Chiara | 1.65 | 58 |
+-----------------+-----------------+-------------+-------------+
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.
void uno(char c) {
static char parola[50+1] = "";
static char oldc = ' ';
static unsigned i = 0;
if (isspace(c))
if (isspace(oldc)) {
// due spazi consecutivi
printf("%c", c);
else {
// e` appena terminata una parola; se appartiene ad una lista, sostituiscila
parola[i++] = '\0';
if (strcmp(parola, "odio"))
strcpy(parola, "amore");
else if (strcmp(parola, "guerra"))
strcpy(parola, "pace");
printf("%s", parola);
i = 0;
}
}
else
// accodo la lettera in una parola
parola[i++] = 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"
bool presente(char str[], char c) {
// soluzione1
bool result = false;
for (unsigned int j = 0; j < strlen(str); j++) {
if (str[j]==c) {
result = true;
break;
}
}
return result;
// soluzione2
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.
void nshift(char stringa[], unsigned int num) {
for (unsigned int j = 0; j < num; j++) {
char temp = stringa[0];
for (unsigned int i = 0; i < strlen(stringa)-1; i++)
stringa[i] = stringa[i+1];
stringa[strlen(stringa)-1] = temp;
}
}
/*
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"
*/
bool es05(const char * filenamein, const char * filenameout) {
FILE * fi = fopen(filenamein, "r");
if (fi != NULL) {
FILE * fo = fopen(filenameout, "w");
if (fo != NULL) {
char buffer[MAXBUFFER]; // non e` una stringa, ma una sequenza di bytes...
int nr, nw;
while ((nr = fread(buffer, sizeof(buffer[0]), MAXBUFFER, fi)) > 0) {
nw = fwrite(buffer, sizeof(buffer[0]), nr, fo);
if (nw < nr)
return false;
}
if (fclose(fo)<0)
return false;
}
if (fclose(fi)<0)
return false;
}
return true;
}
/*
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
*/
void es10(const char * filenamein, const char * filenameout) {
char parola[] = "ciao";
FILE * fi = fopen(filenamein, "r");
if (fi != NULL) {
FILE * ft = fopen(filenamein, "r"); // ad esclusivo uso della fread
int n = 0;
int c;
while((c=fgetc(fi))!=EOF) {
n++;
if (c=='\n'){
char frase[n+1];
int nr = fread(frase, sizeof(frase[0]), n, ft);
frase[nr] = '\0';
if (nr < n)
// TODO: gestire errore
;
if (strstr(frase, parola)!=NULL) {
// TODO: gestire errori
FILE * fo = fopen(filenameout, "a");
fwrite(frase, sizeof(frase[0]), nr, fo);
fclose(fo);
}
n = 0;
}
}
fclose(ft);
fclose(fi);
}
}

108
sfusi/Esercizio CSV - Tipo 1.cpp → 3AIN/sfusi/Esercizio CSV - Tipo 1.cpp
View File

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

82
sfusi/Esercizio CSV - Tipo 2.cpp → 3AIN/sfusi/Esercizio CSV - Tipo 2.cpp
View File

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

Some files were not shown because too many files have changed in this diff Show More