From 227586a0af23fa2bdb5edbedb4d9a61a44d17990 Mon Sep 17 00:00:00 2001 From: 2xMarcy <59742831+2xMarcy@users.noreply.github.com> Date: Sun, 12 Jan 2020 00:41:34 +0100 Subject: [PATCH] Add files via upload --- Calcolatrice-Es7.c | 67 +++++++++++++++ Spezza_la_riga-Es8.c | 91 ++++++++++++++++++++ Vettori_con_tappo-Es6-Con_commenti.c | 123 +++++++++++++++++++++++++++ Vettori_con_tappo-Es6.c | 89 +++++++++++++++++++ 4 files changed, 370 insertions(+) create mode 100644 Calcolatrice-Es7.c create mode 100644 Spezza_la_riga-Es8.c create mode 100644 Vettori_con_tappo-Es6-Con_commenti.c create mode 100644 Vettori_con_tappo-Es6.c diff --git a/Calcolatrice-Es7.c b/Calcolatrice-Es7.c new file mode 100644 index 0000000..ebc1eb3 --- /dev/null +++ b/Calcolatrice-Es7.c @@ -0,0 +1,67 @@ +/* +Esercizio 7 + +Scrivere un programma calcolatrice.c che accetti tre parametri a riga di comando: + +- operazione: una stringa "somma", "prodotto", "sottrazione" o "divisione" +- primo operando: un intero +- secondo operando: un intero + +e stampi il risultato dell’operazione. +Il programma deve inoltre controllare che i parametri siano corretti e, in caso contrario, +stampare un messaggio di errore con la sintassi corretta. + + +Esempio 1: + +$ ./calcolatrice somma 13 29 + +La somma è 42. + +Esempio 2: +$ ./calcolatrice pippo 32 23 + +Sintassi: calcolatrice (somma | prodotto | sottrazione | divisione) num1:int num2:int $ + +Esempio 3: + +$ ./calcolatrice divisione 42 0 +Impossibile dividere per zero. +*/ + +#include +#include +#include + +int main (int argc, char* argv[]) +{ + int op1, op2; + if (argc != 4) + printf ("Errore nella sintassi.\nSintassi: %s (somma | prodotto | sottrazione | divisione) num1:int num2:int\n", argv[0]); + else + { + op1 = atoi (argv[2]); + op2 = atoi (argv[3]); + + if (strcmp (argv[1], "somma") == 0) + printf ("La somma e' %d\n", op1 + op2); + else + if (strcmp (argv[1], "prodotto") == 0) + printf ("Il prodotto e' %d\n", op1 * op2); + else + if (strcmp (argv[1], "sottrazione") == 0) + printf ("La differenza e' %d\n", op1 - op2); + else + if (strcmp (argv[1], "divisione") == 0) + { + if (op2 == 0) + printf ("Impossibile dividere per zero.\n"); + else + printf ("Il quoziente e' %d\n", op1 / op2); + } + else + printf ("Errore nella sintassi.\nSintassi: %s (somma | prodotto | sottrazione | divisione) num1:int num2:int\n", argv[0]); + } + + return 0; +} diff --git a/Spezza_la_riga-Es8.c b/Spezza_la_riga-Es8.c new file mode 100644 index 0000000..1a5b1a0 --- /dev/null +++ b/Spezza_la_riga-Es8.c @@ -0,0 +1,91 @@ +/* + +Esercizio 8 + +Scrivere un programma che accetti due parametri, il nome di un file di testo e un numero n, +e che legga, carattere per carattere, il file di testo indicato e spezzi le righe più lunghe di n andando a capo. + +L’output deve essere salvato in un altro file di testo. + +Ad esempio se legge dal file la riga: + +Quel ramo del lago di Como, che volge a mezzogiorno, tra due catene non interrotte di monti, tutto a seni e a golfi + +con n=34, lanciando il programma + +$ ./testoACapo fileInput.txt 34 + + +il file di output dovrà contenere: + +Quel ramo del lago di Como, che vo + +lge a mezzogiorno, tra due catene + +non interrotte di monti, tutto a s + +eni e a golfi + +*/ + +#include +#include + +int main (int argc, char* argv[]) +{ + int i, n; + char c; + + if (argc != 3) + { + printf ("Errore nella sintassi.\nSintassi: %s [nome file] num:int\n", argv[0]); + exit (EXIT_FAILURE); + } + + n = atoi (argv[2]); + if (n <= 0) + { + printf ("Errore! Il valore digitato deve essere maggiore di 0.\n"); + exit (EXIT_FAILURE); + } + + FILE* fpr = fopen (argv[1], "r"); + if (fpr == NULL) + { + printf ("Errore! Il file indicato non esiste.\n"); + exit (EXIT_FAILURE); + } + + FILE* fpw = fopen ("output.txt", "w"); + if (fpw == NULL) + { + printf ("Errore! Il file di output non e' accessibile.\n"); + fclose (fpr); + exit (EXIT_FAILURE); + } + + c = fgetc (fpr); + + for (i = 0; c != EOF; i++) + { + if (c == '\n') + { + c = fgetc (fpr); + i--; + } + else + { + fputc (c, fpw); + + c = fgetc (fpr); + + if ( (i + 1) % n == 0) + fputc ('\n', fpw); + } + } + + fclose (fpr); + fclose (fpw); + + return (EXIT_SUCCESS); +} diff --git a/Vettori_con_tappo-Es6-Con_commenti.c b/Vettori_con_tappo-Es6-Con_commenti.c new file mode 100644 index 0000000..9f61b55 --- /dev/null +++ b/Vettori_con_tappo-Es6-Con_commenti.c @@ -0,0 +1,123 @@ +/* +Esercizio 6 + +Scrivere una funzione che preso in input un vettore con tappo, restituisca +in una variabile passata per riferimento che rappresenta il numero di volte +che il valore massimo nel vettore tappo si presenta. +Restituire -1 se il vettore con tappo è vuoto. +*/ + +#include +#include +#include +#define DIM 11 + +/* Funzione che: + * - riceve in ingresso un vettore di interi; + * - genera una numero casuale tra 0 e DIM -1, che sara' il numero dei valori che verranno inseriti nel vettore; + * - assegna a ciascuna cella del vettore un numero casuale tra 0 e 100, fino al numero di valori prima generato; + * - assegna "-1", ossia il valore tappo, alla cella successiva all'ultimo valore inserito; + * - non restituisce nulla. */ +void vettoreCasuale (int v[]) +{ + int i, nv; + // Genera un numero casuale tra 0 e DIM -1 e lo assegna a nv + nv = ( rand() ) % DIM; + + for (i = 0; i < nv; i++) + // Genera un numero casuale tra 0 e 100 e lo assegna a v[i] + v[i] = ( rand() ) % 101; + + // Assegna -1 alla cella immediatamente successiva all'ultimo valore caricato + v[i] = -1; +} + +/* Funzione che: + * - riceve un vettore di interi; + * - stampa i valori contenuti nel vettore; + * - non restituisce nulla. */ +void stampaVettore (int v[]) +{ + int i; + + // v[i] e' la cella del vettore da stampare: v[0] al primo ciclo, v[1] al secondo, v[2] al terzo... + for (i = 0; v[i] != -1; i++) + printf ("Valore in posizione %d del vettore: %d\n", i, v[i]); +} + +/* Funzione che: + * - riceve in ingresso un vettore; + * - assume come valore massimo quello presente nella prima cella del vettore; + * - se il vettore non e' vuoto (ossia se il valore presente nella prima cella del vettore e' diverso da -1) + * scorre le altre celle per trovare il valore maggiore, fino ad arrivare al tappo; + * - restituisce il valore maggiore (o -1 se il vettore e' vuoto). */ +int calcoloValMax (int v[]) +{ + int i, max; + + max = v[0]; + + if (max != -1) + for (i = 1; v[i] != -1; i++) + if (max < v[i]) + max = v[i]; + + return max; +} + +/* Funzione che: + * - riceve un vettore di interi con tappo, un valore e il puntatore ad una variabile; + * - verifica che il vettore non sia vuoto; se e' vuoto mette -1 nella locazione di memoria puntata dal puntatore; + * - conta le occorrenze del valore e ne pone il numero nella locazione di memoria puntata dal puntatore; + * - non restituisce nulla.*/ +void contaOccorrenze (int v[], int n, int* occ) +{ + int i; + + *occ = 0; + + if (v[0] == -1) + *occ = -1; + else + for (i = 0; v[i] != -1; i++) + if (v[i] == n) + (*occ)++; +} + +/* Funzione main che: + * - dichiara un vettore di interi; + * - ricalcola in base a data e ora il punto di partenza per la generazione di valori casuali (seed rand); + * - richiama la funzione per generare un vettore casuali di interi e lo stampa tramite apposita funzione; + * - richiama la funzione per trovare il valore massimo contenuto nel vettore; + * - richiama la funzione per trovare quante volte ricorra un valore in un vettore + * passando alla funzione come valore da trovare il valore massimo precedentemente trovato; + * - in base al valore restituito dalla funzione stampa il numero delle occorrenze del valore massimo + * o un messaggio che indica che il vettore e' vuoto. */ +int main () +{ + int vett[DIM], valmax, numocc; + + srand (time(NULL)); + + vettoreCasuale (vett); + printf ("Vettore:\n"); + stampaVettore (vett); + + valmax = calcoloValMax (vett); + + contaOccorrenze (vett, valmax, &numocc); + + if (numocc == -1) + printf ("Il vettore e' vuoto\n"); + else + { + printf ("Il valore massimo contenuto nel vettore e' %d\n", valmax); + + if (numocc == 1) + printf ("Il valore massimo %d ricorre %d volta\n", valmax, numocc); + else + printf ("Il valore massimo %d ricorre %d volte\n", valmax, numocc); + } + + return 0; +} diff --git a/Vettori_con_tappo-Es6.c b/Vettori_con_tappo-Es6.c new file mode 100644 index 0000000..521da5e --- /dev/null +++ b/Vettori_con_tappo-Es6.c @@ -0,0 +1,89 @@ +/* +Esercizio 6 + +Scrivere una funzione che preso in input un vettore con tappo, restituisca +in una variabile passata per riferimento che rappresenta il numero di volte +che il valore massimo nel vettore tappo si presenta. +Restituire -1 se il vettore con tappo è vuoto. +*/ + +#include +#include +#include +#define DIM 11 + +void vettoreCasuale (int v[]) +{ + int i, nv; + nv = ( rand() ) % DIM; + + for (i = 0; i < nv; i++) + v[i] = ( rand() ) % 101; + + v[i] = -1; +} + +void stampaVettore (int v[]) +{ + int i; + + for (i = 0; v[i] != -1; i++) + printf ("Valore in posizione %d del vettore: %d\n", i, v[i]); +} + +int calcoloValMax (int v[]) +{ + int i, max; + + max = v[0]; + + if (max != -1) + for (i = 1; v[i] != -1; i++) + if (max < v[i]) + max = v[i]; + + return max; +} + +void contaOccorrenze (int v[], int n, int* occ) +{ + int i; + + *occ = 0; + + if (v[0] == -1) + *occ = -1; + else + for (i = 0; v[i] != -1; i++) + if (v[i] == n) + (*occ)++; +} + +int main () +{ + int vett[DIM], valmax, numocc; + + srand (time(NULL)); + + vettoreCasuale (vett); + printf ("Vettore:\n"); + stampaVettore (vett); + + valmax = calcoloValMax (vett); + + contaOccorrenze (vett, valmax, &numocc); + + if (numocc == -1) + printf ("Il vettore e' vuoto\n"); + else + { + printf ("Il valore massimo contenuto nel vettore e' %d\n", valmax); + + if (numocc == 1) + printf ("Il valore massimo %d ricorre %d volta\n", valmax, numocc); + else + printf ("Il valore massimo %d ricorre %d volte\n", valmax, numocc); + } + + return 0; +}