├── codice ├── l04 │ ├── valore-assoluto.c │ ├── touppercase-v2.c │ ├── touppercase.c │ ├── radice-quadrata.c │ └── radice-quadrata-double.c ├── l06 │ ├── Esercizio2.txt │ ├── 20211108_p2.pdf │ └── d2.c ├── l07 │ ├── minimo.in │ ├── voti.in │ ├── elenco.txt │ ├── crea_input.c │ └── minimo.c ├── 155_make │ ├── file1.h │ ├── file2.h │ ├── file3.h │ ├── file3.c │ ├── radice_quadrata │ │ ├── radice-quadrata.h │ │ ├── eseguibile │ │ ├── radice-quadrata.c │ │ ├── funzioni-aritmetiche.h │ │ ├── Makefile │ │ ├── funzioni-aritmetiche.c │ │ └── main.c │ ├── main.c │ ├── prog │ ├── file1.c │ ├── file2.c │ └── Makefile ├── 200_adt │ ├── figure-adt │ │ ├── figure.c │ │ ├── .vscode │ │ │ └── settings.json │ │ ├── Makefile │ │ └── main.c │ ├── contatore │ │ ├── contatore.h │ │ ├── .vscode │ │ │ └── settings.json │ │ ├── esempio_contatore │ │ ├── main.c │ │ ├── programma.c │ │ ├── contatore.c │ │ └── Makefile │ └── contatore-adt │ │ ├── .vscode │ │ └── settings.json │ │ ├── esempio_contatore │ │ ├── programma.c │ │ ├── Makefile │ │ ├── contatore.h │ │ ├── main.c │ │ └── contatore.c ├── 230_liste_collegate │ ├── esempioInserimentoTesta.c │ ├── stampa.h │ ├── elim1.h │ ├── elimTesta.h │ ├── insOrd.h │ ├── elimTutti.h │ ├── insTesta.h │ ├── calorie │ │ ├── pasto.txt │ │ ├── calorie.dat │ │ ├── Makefile │ │ └── listaAlimento.h │ ├── piena.c │ ├── seq │ │ └── 20170622 │ │ │ ├── input.in │ │ │ ├── listino.dat │ │ │ ├── 20170622_p1.pdf │ │ │ ├── Makefile │ │ │ └── listino.h │ ├── generatoreListe.h │ ├── vuota.c │ ├── nuovaLista.c │ ├── lunghezza-di-una-lista │ │ ├── .vscode │ │ │ └── settings.json │ │ ├── lunghezza-di-una-lista │ │ ├── Makefile │ │ ├── main.c │ │ └── lista.h │ ├── tipi.h │ ├── elimTesta.c │ ├── azzeramento-lista │ │ ├── main.c │ │ ├── Makefile │ │ └── lista.h │ ├── reverse │ │ ├── Makefile │ │ ├── lista.h │ │ └── main.c │ ├── stampa.c │ ├── reduce.c │ ├── stampa-seq.c │ ├── es-elim1.c │ ├── es-elim-testa.c │ ├── es-elimTutti.c │ ├── es-ins-testa.c │ ├── es-ins-ord.c │ ├── es-stampa.c │ ├── insCoda.c │ ├── insTesta.c │ ├── insertionSort.c │ ├── insOrd.c │ ├── esempio1.c │ ├── elimTutti.c │ ├── elim1.c │ ├── ricerca.c │ ├── listaCollegata.h │ └── lunghezza-di-una-lista.c ├── 130_file_di_testo │ ├── prova.txt │ ├── people.txt │ ├── stampa.c │ ├── copia.c │ ├── infinito.txt │ └── input-persone.c ├── l10 │ └── 20170130 │ │ ├── pasto.txt │ │ ├── calorie │ │ ├── calorie.dat │ │ ├── 20170130_p1.pdf │ │ ├── Makefile │ │ ├── listaCalorie.h │ │ └── listaCalorie.c ├── 210_liste_sequenziali │ ├── calorie │ │ ├── pasto.txt │ │ ├── calorie.dat │ │ ├── Makefile │ │ ├── listaAlimento.h │ │ └── listaAlimento.c │ ├── lunghezza.c │ ├── vuota.c │ ├── nuova-lista.c │ ├── lista-ordinata │ │ ├── lista_ordinata │ │ ├── Makefile │ │ ├── lista.h │ │ ├── main.c │ │ └── lista.c │ ├── piena.c │ ├── stampa.c │ ├── ricerca.c │ ├── insTesta.c │ ├── elimTutti.c │ ├── lista-sequenziale.h │ ├── elim1.c │ └── insOrd.c ├── l11 │ ├── 20170130-pratica-totale │ │ ├── pasto.txt │ │ ├── calorie │ │ ├── calorie.dat │ │ ├── 20170130_p1.pdf │ │ ├── Makefile │ │ ├── listaCalorie.h │ │ └── listaCalorie.c │ ├── 20220131-pratica-totale │ │ ├── .vscode │ │ │ └── settings.json │ │ ├── esami │ │ ├── prove.dat │ │ ├── 20220131_p1.pdf │ │ ├── Makefile │ │ ├── listaEsami.h │ │ └── main.c │ ├── 20220118-pratica-parziale │ │ ├── .vscode │ │ │ └── settings.json │ │ ├── frequenze │ │ ├── 20220118_p1.pdf │ │ ├── testo.txt │ │ ├── Makefile │ │ └── listaParole.h │ └── 20220622-teoria │ │ └── 20220622_t1_corretto.pdf ├── 100_strutture_typedef_enum │ ├── nome.c │ ├── paga.c │ └── persone.c ├── 160_argomenti_linea_comando │ ├── .gitignore │ ├── nome_eseguibile.c │ ├── stampa_argomenti.c │ ├── infinito.txt │ └── stampa.c ├── 150_progetti_multifile │ ├── media.c │ ├── .vscode │ │ └── settings.json │ ├── eseguibile │ ├── radice-quadrata │ ├── radice-quadrata.c │ └── main.c ├── 050_controllo_di_flusso │ ├── star5.c │ ├── saluto.c │ ├── star-loop.c │ ├── star-for.c │ ├── positivo.c │ ├── elenco-quozienti-do.c │ ├── pin.c │ ├── star5-do-while.c │ ├── elenco-quozienti-goto.c │ ├── star5-salto.c │ ├── input-denominatore.c │ ├── inversione-cifre.c │ ├── compreso-con-and.c │ ├── pin-goto.c │ ├── doppio.c │ ├── pin-else.c │ ├── input-denominatore-corretto.c │ ├── input-denominatore-scorretto.c │ ├── tavola-pitagorica-2.c │ ├── somma-input.c │ ├── pin-e-non.c │ ├── tavola-pitagorica-con-allineamento.c │ ├── doppio2.c │ ├── maggiore.c │ ├── tavola-pitagorica.c │ ├── compreso.c │ ├── somma-interi-difettoso.c │ ├── maggiore-di-tre.c │ ├── somma-interi-do.c │ ├── operatori-relazionali.c │ ├── somma-interi-break.c │ ├── somma-interi-corretto.c │ ├── somma-interi-do-goto.c │ ├── uscita-doppio-goto.c │ ├── somma-interi-positivi.c │ ├── uscita-doppio-break.c │ ├── somma-interi-goto.c │ ├── triangolo-rettangolo.c │ ├── triangolo-con-connettivi-v2.c │ ├── uscita-doppio.c │ ├── divisione.c │ ├── triangolo-con-connettivi-no-isoscele.c │ ├── moltiplicazione.c │ ├── triangolo-rettangolo-senza-ripetizione.c │ ├── somma-interi-while.c │ ├── triangolo-con-connettivi.c │ ├── pin-do-2.c │ ├── rubrica-pin.c │ ├── giorno-settimana-if.c │ ├── rubrica-pin-blocco.c │ ├── rubrica-pin-else.c │ ├── bimbum.c │ ├── bimbum2.c │ ├── rubrica-pin-salto.c │ ├── triangolo.c │ ├── uscita-doppio-flag.c │ ├── giorno-settimana-switch.c │ ├── pin-do.c │ ├── rubrica-pin-molti-if.c │ ├── rubrica-pin-blocco-else.c │ ├── somma-interi.c │ └── primo.c ├── 115_array_e_funzioni │ ├── persona.c │ ├── campo.c │ ├── return-array.c │ ├── somma-elementi.c │ ├── valore-ritorno.c │ ├── array-parametro-output.c │ ├── stampa-stringa.c │ ├── somma-elementi-dimensione-variabile.c │ ├── azzera-array.c │ ├── somma-elementi-macro.c │ ├── 20190222-t1.c │ ├── indice-massimo.c │ ├── procedura-insertion-sort.c │ └── eliminazione-ripetuti.c ├── 030_introduzione_al_c │ ├── 23273 │ │ ├── helloWorld.c │ │ └── helloWorld │ ├── helloWorld.c │ ├── helloWorld2.c │ ├── espressioni_intere │ │ └── modulo.c │ └── operazioni.c ├── l09 │ └── .vscode │ │ └── settings.json ├── 060_espressioni │ ├── char1000.c │ ├── tabulazione.c │ ├── mille.c │ ├── input-output-caratteri.c │ ├── stampa-alfabeto.c │ ├── media.c │ ├── media-float.c │ ├── media-int.c │ └── tipo-carattere.c ├── 140_file_binari │ ├── people.dat │ ├── crea_stipendi │ ├── stipendi.dat │ ├── stampa_stipendi │ ├── aggiorna_stipendi │ ├── stampa_stipendi.c │ ├── aggiorna_stipendi.c │ ├── lettura_binario_come_testo.c │ ├── crea_stipendi.c │ ├── aggiorna_stipendi_ftell.c │ ├── lettura_binaria.c │ └── lettura_binaria_v2.c ├── 055_sequenze │ ├── creazione-di-sequenze-do.c │ ├── creazione-di-sequenze.c │ ├── doppio.c │ ├── numeri-pari.c │ ├── prodotto.c │ └── quadrati-dei-numeri-pari.c ├── 040_variabili │ ├── undef.c │ ├── non-inizializzata.c │ ├── quoziente-resto-costanti.c │ ├── commenti.c │ ├── doppio.c │ ├── assegnamento-distruttivo.c │ ├── somma.c │ ├── quoziente-resto-variabile.c │ ├── quoziente-resto-due-var.c │ ├── doppio-con-variabile.c │ ├── quoziente-resto-input.c │ ├── quadrato.c │ └── somma-due-variabili.c ├── 070_funzioni │ ├── scope-blocco.c │ ├── stesso-nome-stesso-scope.c │ ├── scope-domanda1.c │ ├── scope-domanda2.c │ ├── stesso-nome-scope-diversi.c │ ├── valore-assoluto.c │ ├── variabile-globale.c │ ├── asterischi.c │ ├── fattoriale.c │ ├── scope-for.c │ ├── fattoriale-versione2.c │ ├── potenza.c │ ├── record-attivazione.c │ ├── massimo.c │ ├── logo.c │ ├── rettangolo-di-asterischi.c │ ├── subroutine-funzione.c │ ├── logo2.c │ ├── rettangolo-di-asterischi-funzione.c │ ├── subroutine-goto.c │ ├── subroutine-funzione-param.c │ ├── subroutine-funzione-riga.c │ ├── massimo-di-tre.c │ ├── differenza-fra-date-funzione-sottrazione.c │ ├── differenza-fra-date-funzione.c │ ├── domani.c │ └── differenza-fra-date.c ├── 090_array │ ├── init.c │ ├── input.c │ ├── stampa.c │ ├── swap-1.c │ ├── bounds.c │ ├── foreach.c │ ├── doppio.c │ ├── foreach-indietro.c │ ├── map-in-place.c │ ├── map.c │ ├── map-int-char.c │ ├── swap.c │ ├── cinque-a2.c │ ├── positivi-map.c │ ├── ricerca-break.c │ ├── 20190121-t1.c │ ├── doppio-con-funzione.c │ ├── massimo.c │ ├── cinque-macro.c │ ├── somma-elementi.c │ ├── cinque-var.c │ ├── progressivi.c │ ├── ricerca-flag.c │ ├── ricerca-massimo.c │ ├── cinque.c │ ├── progressivi-v2.c │ ├── reduce.c │ ├── positivi.c │ ├── filter.c │ ├── stampa-ordine.c │ ├── insertion-sort.c │ ├── ricerca-elemento.c │ ├── stampa-array-inizializzato.c │ ├── inserimento-ordinato.c │ ├── cinque-a1.c │ ├── parabola.c │ └── insertion-sort-per-quadrato.c ├── 045_debugger │ ├── bug.c │ ├── launch.json │ └── .vscode │ │ └── launch.json ├── 180_ricorsione │ ├── printf_ricorsiva.c │ └── fattoriale.c ├── 110_puntatori │ ├── stampa-stringa.c │ ├── riferimento.c │ ├── stampa-stringa-2.c │ ├── swap.c │ ├── analisi.c │ ├── azzera.c │ ├── intero-vs-puntatore.c │ ├── puntatore.c │ ├── rappresentazione-puntatori.c │ ├── swap-procedura.c │ ├── array-e-puntatori-2.c │ ├── assegnamento-1.c │ ├── assegnamento-2.c │ ├── array-e-puntatori.c │ ├── swap-puntatori.c │ ├── 20190206-t1.c │ ├── divisione-con-procedura.c │ ├── variabile-configurabile.c │ ├── ordina-due.c │ ├── funzione │ ├── divisione-con-controllo-errore-funzione │ ├── divisione-con-controllo-errore-funzione-stile-unix │ └── divisione-con-controllo-errore.c ├── 097_numeri_casuali │ ├── temperature.c │ ├── dado.c │ ├── funzioni-casuali.c │ ├── numeri-casuali.c │ └── dado-seed.c ├── 062_espressione_condizionale │ └── valore-assoluto.c ├── 095_stringhe │ ├── lunghezza.c │ ├── copia.c │ ├── compare.c │ ├── confronto_alfabetico.c │ ├── to_uppercase.c │ ├── to_uppercase_versione_2.c │ └── to_uppercase_versione_3.c ├── 220_allocazione_dinamica │ ├── esempio-malloc.c │ ├── array-dimensione-dinamica.c │ ├── stringa-dinamica.c │ └── alloca.c ├── 001_informazioni_generali │ └── somma.c ├── l05 │ ├── giorno-della-settimana.c │ ├── maiuscole.c │ ├── potenza-v2.c │ ├── potenza-v3.c │ ├── potenza-v4.c │ ├── radice-quadrata.c │ └── potenza.c ├── l02 │ ├── bisestile.c │ └── giorni-del-mese.c ├── l03 │ ├── divisori.c │ ├── divisori-v2.c │ ├── terne-pitagoriche.c │ └── divisori-primi.c ├── 120_vettori_multidimensionali │ ├── identita.c │ └── simmetrica.c └── l08 │ └── frazioni-1.c ├── README.md ├── tutorato ├── tutorato_10 │ ├── file.txt │ ├── main │ ├── prog │ ├── myinclude.h │ ├── iterativa.c │ ├── ricorsiva.c │ └── Makefile ├── tutorato_09 │ ├── corrispondenze.txt │ ├── output.bin │ ├── libretto1.bin │ ├── libretto2.bin │ └── messaggi.txt ├── tutorato_11 │ ├── 20210204_p1.pdf │ ├── rilevazioni.dat │ ├── Makefile │ ├── listaPazienti.h │ └── main.c ├── tutorato_08 │ └── input.txt ├── tutorato_02 │ ├── watch.c │ ├── valore_assoluto.c │ └── frazioni.c ├── tutorato_01 │ ├── pari_dispari.c │ ├── divisibili.c │ ├── esiti.c │ ├── scacchiera.c │ ├── regine.c │ ├── coordinate.c │ └── tris.c ├── tutorato_07 │ ├── strlen.c │ └── find_replace.c ├── tutorato_03 │ ├── piramide.c │ ├── numero_perfetto.c │ ├── algoritmo_euclideo.c │ ├── palindromo.c │ ├── collatz.c │ └── input.c ├── tutorato_05 │ ├── num_perfetti.c │ ├── area_perimetro.c │ └── celsius.c ├── tutorato_04 │ ├── pi.c │ └── pi_v2.c └── tutorato_06 │ └── istogrammi.c └── esami ├── 20200203 ├── codicifiscali.dat ├── 20200203_p1.pdf ├── Makefile └── listaUtenti.h ├── 20200219 ├── piani.dat ├── utenti.dat ├── 20200219_p1.pdf ├── Makefile └── listaUtenti.h ├── prove_teoriche ├── 20180723_t1.pdf ├── 20190121_t1.pdf ├── 20190206_t1.pdf └── 20190618_t1.pdf ├── 20221108-parziale ├── 20221108_p1.pdf ├── 20221108_p2.pdf ├── d1.c ├── d2.c ├── Esercizio1-turno1.c └── Esercizio1-turno2.c ├── 20200122-parziale ├── turno1 │ ├── accessi.dat │ ├── 20200122_p1.pdf │ ├── Makefile │ └── listaVeicoli.h └── turno2 │ ├── vaccini.dat │ ├── 20200122_p2.pdf │ ├── Makefile │ └── listaCani.h └── 20191119-parziale ├── turno1 ├── 20191119_p1.pdf └── d1.c ├── turno2 ├── 20191119_p2.pdf └── d2.c └── turno3 ├── 20191119_p3.pdf ├── d3.c └── Esercizio1.c /codice/l04/valore-assoluto.c: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Programmazione2022 -------------------------------------------------------------------------------- /codice/l06/Esercizio2.txt: -------------------------------------------------------------------------------- 1 | 185621 -------------------------------------------------------------------------------- /codice/l07/minimo.in: -------------------------------------------------------------------------------- 1 | -2 -1 5 -4 6 -------------------------------------------------------------------------------- /tutorato/tutorato_10/file.txt: -------------------------------------------------------------------------------- 1 | Hnft -------------------------------------------------------------------------------- /codice/155_make/file1.h: -------------------------------------------------------------------------------- 1 | void p(int i); -------------------------------------------------------------------------------- /codice/155_make/file2.h: -------------------------------------------------------------------------------- 1 | void q(char); -------------------------------------------------------------------------------- /codice/155_make/file3.h: -------------------------------------------------------------------------------- 1 | char f(char x); -------------------------------------------------------------------------------- /codice/200_adt/figure-adt/figure.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /codice/230_liste_collegate/esempioInserimentoTesta.c: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /codice/155_make/file3.c: -------------------------------------------------------------------------------- 1 | int f(char x) 2 | { return x+3; } -------------------------------------------------------------------------------- /codice/230_liste_collegate/stampa.h: -------------------------------------------------------------------------------- 1 | void stampa(Lista l); -------------------------------------------------------------------------------- /codice/230_liste_collegate/elim1.h: -------------------------------------------------------------------------------- 1 | int elim1(Lista* pl, int d); -------------------------------------------------------------------------------- /codice/130_file_di_testo/prova.txt: -------------------------------------------------------------------------------- 1 | Ferrara 2 | Bologna 3 | FINE 4 | -------------------------------------------------------------------------------- /codice/230_liste_collegate/elimTesta.h: -------------------------------------------------------------------------------- 1 | void elimTesta(Lista* pl); -------------------------------------------------------------------------------- /codice/230_liste_collegate/insOrd.h: -------------------------------------------------------------------------------- 1 | void insOrd(Lista* pl, int d); -------------------------------------------------------------------------------- /codice/l10/20170130/pasto.txt: -------------------------------------------------------------------------------- 1 | Pane 80 2 | Camembert 40 3 | Mela 200 -------------------------------------------------------------------------------- /codice/155_make/radice_quadrata/radice-quadrata.h: -------------------------------------------------------------------------------- 1 | float radq(float a); -------------------------------------------------------------------------------- /codice/230_liste_collegate/elimTutti.h: -------------------------------------------------------------------------------- 1 | void elimTutti(Lista* pl, int d); -------------------------------------------------------------------------------- /codice/230_liste_collegate/insTesta.h: -------------------------------------------------------------------------------- 1 | void insTesta(Lista* pl, Dato d); 2 | -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/calorie/pasto.txt: -------------------------------------------------------------------------------- 1 | Pane 80 2 | Fontina 40 3 | Mela 200 -------------------------------------------------------------------------------- /codice/230_liste_collegate/calorie/pasto.txt: -------------------------------------------------------------------------------- 1 | Pane 80 2 | Fontina 40 3 | Mela 200 -------------------------------------------------------------------------------- /codice/l11/20170130-pratica-totale/pasto.txt: -------------------------------------------------------------------------------- 1 | Pane 80 2 | Camembert 40 3 | Mela 200 -------------------------------------------------------------------------------- /codice/100_strutture_typedef_enum/nome.c: -------------------------------------------------------------------------------- 1 | typedef char Stringa[100]; 2 | Stringa nome; -------------------------------------------------------------------------------- /codice/130_file_di_testo/people.txt: -------------------------------------------------------------------------------- 1 | Rossi Mario M 1980 2 | Bianchi Giovanna F 1985 3 | -------------------------------------------------------------------------------- /codice/160_argomenti_linea_comando/.gitignore: -------------------------------------------------------------------------------- 1 | pippo 2 | stampa 3 | eseguibile 4 | hello -------------------------------------------------------------------------------- /codice/155_make/main.c: -------------------------------------------------------------------------------- 1 | #include "file1.h" 2 | #include "file2.h" 3 | int main() 4 | { p(1); q(2); } -------------------------------------------------------------------------------- /codice/200_adt/contatore/contatore.h: -------------------------------------------------------------------------------- 1 | void inizializza(); 2 | void incrementa(); 3 | void stampa(); -------------------------------------------------------------------------------- /codice/150_progetti_multifile/media.c: -------------------------------------------------------------------------------- 1 | float media(float y, float z) { 2 | return (y + z) / 2; 3 | } -------------------------------------------------------------------------------- /codice/155_make/prog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/155_make/prog -------------------------------------------------------------------------------- /codice/230_liste_collegate/piena.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | 3 | int piena(Lista l) { 4 | return 0; 5 | } -------------------------------------------------------------------------------- /esami/20200203/codicifiscali.dat: -------------------------------------------------------------------------------- 1 | HVVFPL60A25L248HCNZVVF49M48E182XLPNVRR74D54A850WZVDVFZ62P51D595R -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/star5.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | printf("*****\n"); 5 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/persona.c: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | char nome[30]; 3 | int eta; 4 | } Persona; -------------------------------------------------------------------------------- /codice/030_introduzione_al_c/helloWorld.c: -------------------------------------------------------------------------------- 1 | #include 2 | main() { 3 | printf("Hello, World!\n"); 4 | } -------------------------------------------------------------------------------- /codice/155_make/file1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "file3.h" 3 | void p(int i) 4 | { printf("%d",f(i)); 5 | } -------------------------------------------------------------------------------- /codice/l06/20211108_p2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l06/20211108_p2.pdf -------------------------------------------------------------------------------- /esami/20200219/piani.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200219/piani.dat -------------------------------------------------------------------------------- /esami/20200219/utenti.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200219/utenti.dat -------------------------------------------------------------------------------- /tutorato/tutorato_09/corrispondenze.txt: -------------------------------------------------------------------------------- 1 | H GgG 2 | d gGg 3 | e ggG 4 | l GGg 5 | o gGG 6 | r Ggg 7 | w ggg -------------------------------------------------------------------------------- /tutorato/tutorato_10/main: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/tutorato/tutorato_10/main -------------------------------------------------------------------------------- /tutorato/tutorato_10/prog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/tutorato/tutorato_10/prog -------------------------------------------------------------------------------- /codice/155_make/file2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "file3.h" 3 | void q(char i) 4 | { printf("%c",f(i)); 5 | } -------------------------------------------------------------------------------- /codice/l10/20170130/calorie: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l10/20170130/calorie -------------------------------------------------------------------------------- /codice/030_introduzione_al_c/23273/helloWorld.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | printf("Hello, World!\n"); 5 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/seq/20170622/input.in: -------------------------------------------------------------------------------- 1 | 1 2 | 2 3 | 0 4 | 2 5 | 3 6 | 0 7 | 4 8 | 2 9 | 1 10 | 0 11 | -1 -------------------------------------------------------------------------------- /codice/l09/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "campo-minato-casuale": "cpp" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/l10/20170130/calorie.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l10/20170130/calorie.dat -------------------------------------------------------------------------------- /esami/20200203/20200203_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200203/20200203_p1.pdf -------------------------------------------------------------------------------- /esami/20200219/20200219_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200219/20200219_p1.pdf -------------------------------------------------------------------------------- /tutorato/tutorato_09/output.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/tutorato/tutorato_09/output.bin -------------------------------------------------------------------------------- /codice/060_espressioni/char1000.c: -------------------------------------------------------------------------------- 1 | #include 2 | main() { 3 | char c; 4 | c = 1000; 5 | printf("%d\n", c); 6 | } -------------------------------------------------------------------------------- /codice/140_file_binari/people.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/140_file_binari/people.dat -------------------------------------------------------------------------------- /codice/150_progetti_multifile/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "math.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "contatore.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/200_adt/figure-adt/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "figura.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/generatoreListe.h: -------------------------------------------------------------------------------- 1 | void listaNonOrdinata(Lista* pl, int n); 2 | void listaOrdinata(Lista* pl, int n); -------------------------------------------------------------------------------- /codice/030_introduzione_al_c/helloWorld2.c: -------------------------------------------------------------------------------- 1 | #include 2 | main() { 3 | printf("Hello,"); 4 | printf(" World!\n"); 5 | } -------------------------------------------------------------------------------- /codice/140_file_binari/crea_stipendi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/140_file_binari/crea_stipendi -------------------------------------------------------------------------------- /codice/140_file_binari/stipendi.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/140_file_binari/stipendi.dat -------------------------------------------------------------------------------- /codice/200_adt/contatore-adt/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "contatore.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/l10/20170130/20170130_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l10/20170130/20170130_p1.pdf -------------------------------------------------------------------------------- /esami/prove_teoriche/20180723_t1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/prove_teoriche/20180723_t1.pdf -------------------------------------------------------------------------------- /esami/prove_teoriche/20190121_t1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/prove_teoriche/20190121_t1.pdf -------------------------------------------------------------------------------- /esami/prove_teoriche/20190206_t1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/prove_teoriche/20190206_t1.pdf -------------------------------------------------------------------------------- /esami/prove_teoriche/20190618_t1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/prove_teoriche/20190618_t1.pdf -------------------------------------------------------------------------------- /tutorato/tutorato_09/libretto1.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/tutorato/tutorato_09/libretto1.bin -------------------------------------------------------------------------------- /tutorato/tutorato_09/libretto2.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/tutorato/tutorato_09/libretto2.bin -------------------------------------------------------------------------------- /tutorato/tutorato_09/messaggi.txt: -------------------------------------------------------------------------------- 1 | GgGggGGGgGGggGG 2 | GGggGGGgggGggGGgggGGg 3 | gGGGGggGgGggggGgGggGGgggGGg 4 | GGggGGgGGgGGGGg -------------------------------------------------------------------------------- /tutorato/tutorato_11/20210204_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/tutorato/tutorato_11/20210204_p1.pdf -------------------------------------------------------------------------------- /tutorato/tutorato_11/rilevazioni.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/tutorato/tutorato_11/rilevazioni.dat -------------------------------------------------------------------------------- /codice/030_introduzione_al_c/espressioni_intere/modulo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | printf("%d = %d\n", 7 % 3, 1); 5 | } -------------------------------------------------------------------------------- /codice/140_file_binari/stampa_stipendi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/140_file_binari/stampa_stipendi -------------------------------------------------------------------------------- /codice/230_liste_collegate/vuota.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | 4 | int vuota(Lista l) { 5 | return l == NULL; 6 | } -------------------------------------------------------------------------------- /codice/l11/20220131-pratica-totale/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "listaesami.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/055_sequenze/creazione-di-sequenze-do.c: -------------------------------------------------------------------------------- 1 | main() { 2 | int n; 3 | 4 | n = 1; 5 | do 6 | n = n + 1; 7 | while (n < 10); 8 | } -------------------------------------------------------------------------------- /codice/140_file_binari/aggiorna_stipendi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/140_file_binari/aggiorna_stipendi -------------------------------------------------------------------------------- /codice/150_progetti_multifile/eseguibile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/150_progetti_multifile/eseguibile -------------------------------------------------------------------------------- /codice/230_liste_collegate/nuovaLista.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | 4 | void nuovaLista(Lista* pl) { 5 | *pl = NULL; 6 | } -------------------------------------------------------------------------------- /codice/l11/20220118-pratica-parziale/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "listaparole.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/l11/20220131-pratica-totale/esami: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20220131-pratica-totale/esami -------------------------------------------------------------------------------- /esami/20221108-parziale/20221108_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20221108-parziale/20221108_p1.pdf -------------------------------------------------------------------------------- /esami/20221108-parziale/20221108_p2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20221108-parziale/20221108_p2.pdf -------------------------------------------------------------------------------- /codice/040_variabili/undef.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a = 5; 5 | printf("%d\n", a += a = 4); 6 | printf("%d\n", a); 7 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/saluto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | saluto: 5 | printf("Hello, world!\n"); 6 | goto saluto; 7 | } -------------------------------------------------------------------------------- /codice/070_funzioni/scope-blocco.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | {int i = 1;} 5 | printf("%d\n", i); 6 | return 0; 7 | } -------------------------------------------------------------------------------- /codice/155_make/radice_quadrata/eseguibile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/155_make/radice_quadrata/eseguibile -------------------------------------------------------------------------------- /codice/200_adt/contatore/esempio_contatore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/200_adt/contatore/esempio_contatore -------------------------------------------------------------------------------- /codice/230_liste_collegate/lunghezza-di-una-lista/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "stdio.h": "c" 4 | } 5 | } -------------------------------------------------------------------------------- /codice/l11/20170130-pratica-totale/calorie: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20170130-pratica-totale/calorie -------------------------------------------------------------------------------- /esami/20200122-parziale/turno1/accessi.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200122-parziale/turno1/accessi.dat -------------------------------------------------------------------------------- /esami/20200122-parziale/turno2/vaccini.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200122-parziale/turno2/vaccini.dat -------------------------------------------------------------------------------- /codice/030_introduzione_al_c/23273/helloWorld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/030_introduzione_al_c/23273/helloWorld -------------------------------------------------------------------------------- /codice/150_progetti_multifile/radice-quadrata: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/150_progetti_multifile/radice-quadrata -------------------------------------------------------------------------------- /codice/160_argomenti_linea_comando/nome_eseguibile.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]){ 4 | printf("%s\n", argv[0]); 5 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore-adt/esempio_contatore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/200_adt/contatore-adt/esempio_contatore -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/lunghezza.c: -------------------------------------------------------------------------------- 1 | int lunghezza(Lista l) { 2 | // Corrisponde alla dimensione logica della lista 3 | return l.n_elementi; 4 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/vuota.c: -------------------------------------------------------------------------------- 1 | int vuota(Lista l) 2 | { 3 | // e' vuota se la dimensione logica e' 0 4 | return l.n_elementi == 0; 5 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/calorie/calorie.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/230_liste_collegate/calorie/calorie.dat -------------------------------------------------------------------------------- /codice/l11/20170130-pratica-totale/calorie.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20170130-pratica-totale/calorie.dat -------------------------------------------------------------------------------- /codice/l11/20220118-pratica-parziale/frequenze: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20220118-pratica-parziale/frequenze -------------------------------------------------------------------------------- /codice/l11/20220131-pratica-totale/prove.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20220131-pratica-totale/prove.dat -------------------------------------------------------------------------------- /esami/20191119-parziale/turno1/20191119_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20191119-parziale/turno1/20191119_p1.pdf -------------------------------------------------------------------------------- /esami/20191119-parziale/turno2/20191119_p2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20191119-parziale/turno2/20191119_p2.pdf -------------------------------------------------------------------------------- /esami/20191119-parziale/turno3/20191119_p3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20191119-parziale/turno3/20191119_p3.pdf -------------------------------------------------------------------------------- /esami/20200122-parziale/turno1/20200122_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200122-parziale/turno1/20200122_p1.pdf -------------------------------------------------------------------------------- /esami/20200122-parziale/turno2/20200122_p2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/esami/20200122-parziale/turno2/20200122_p2.pdf -------------------------------------------------------------------------------- /codice/040_variabili/non-inizializzata.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a; 5 | // manca inizializzazione di a! 6 | printf("%d\n", a); 7 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/star-loop.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | scrivi: 5 | printf("*"); 6 | goto scrivi; 7 | printf("\n"); 8 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/calorie/calorie.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/210_liste_sequenziali/calorie/calorie.dat -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/nuova-lista.c: -------------------------------------------------------------------------------- 1 | void nuova_lista(Lista* pl) { 2 | // imposto a 0 la dimensione logica della lista 3 | pl->n_elementi = 0; 4 | } -------------------------------------------------------------------------------- /codice/060_espressioni/tabulazione.c: -------------------------------------------------------------------------------- 1 | // stampa il codice ASCII della tabulazione 2 | 3 | #include 4 | 5 | main() { 6 | printf("%d\n", '\t'); 7 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/seq/20170622/listino.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/230_liste_collegate/seq/20170622/listino.dat -------------------------------------------------------------------------------- /codice/230_liste_collegate/tipi.h: -------------------------------------------------------------------------------- 1 | typedef int Dato; 2 | typedef struct nodo { 3 | Dato dato; 4 | struct nodo* next; 5 | } Nodo; 6 | 7 | typedef Nodo* Lista; -------------------------------------------------------------------------------- /codice/l11/20170130-pratica-totale/20170130_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20170130-pratica-totale/20170130_p1.pdf -------------------------------------------------------------------------------- /codice/l11/20220131-pratica-totale/20220131_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20220131-pratica-totale/20220131_p1.pdf -------------------------------------------------------------------------------- /codice/l11/20220622-teoria/20220622_t1_corretto.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20220622-teoria/20220622_t1_corretto.pdf -------------------------------------------------------------------------------- /tutorato/tutorato_10/myinclude.h: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 1000 3 | 4 | int ricorsiva(int *a, int n, int posizione); 5 | int iterativa(int *a, int n); -------------------------------------------------------------------------------- /codice/040_variabili/quoziente-resto-costanti.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | printf("Quoziente: %d\n", 20 / 7); 5 | printf("Resto: %d\n", 20 % 7); 6 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/star-for.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i; 5 | for (i = 0; i < 5; i++) 6 | printf("*"); 7 | printf("\n"); 8 | } -------------------------------------------------------------------------------- /codice/055_sequenze/creazione-di-sequenze.c: -------------------------------------------------------------------------------- 1 | main() { 2 | int n; 3 | 4 | n = 1; 5 | incremento: 6 | n = n + 1; 7 | if (n < 10) 8 | goto incremento; 9 | } -------------------------------------------------------------------------------- /codice/060_espressioni/mille.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | unsigned char i; 5 | for (i = 1; i <= 1000; i++) 6 | printf("%d ciao\n", i); 7 | } -------------------------------------------------------------------------------- /codice/070_funzioni/stesso-nome-stesso-scope.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int i; 5 | int i = 1; 6 | printf("%d\n", i); 7 | return 0; 8 | } -------------------------------------------------------------------------------- /codice/090_array/init.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM]; 6 | int i; 7 | for (i = 0; i < DIM; i++) 8 | a[i] = 0; 9 | } -------------------------------------------------------------------------------- /codice/l11/20220118-pratica-parziale/20220118_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/l11/20220118-pratica-parziale/20220118_p1.pdf -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/positivo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int n; 5 | scanf("%d", &n); 6 | if (n > 0) 7 | printf("positivo\n"); 8 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/seq/20170622/20170622_p1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/230_liste_collegate/seq/20170622/20170622_p1.pdf -------------------------------------------------------------------------------- /codice/045_debugger/bug.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | scanf("%d%d", &a, &b); 6 | c = a += b; 7 | printf("%d + %d = %d\n", a, b, c); 8 | } -------------------------------------------------------------------------------- /codice/090_array/input.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM]; 6 | int i; 7 | for (i = 0; i < DIM; i++) 8 | scanf("%d", &a[i]); 9 | } -------------------------------------------------------------------------------- /codice/090_array/stampa.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM]; 6 | int i; 7 | for (i = 0; i < DIM; i++) 8 | printf("%d\n", a[i]); 9 | } -------------------------------------------------------------------------------- /codice/090_array/swap-1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int a, b; 5 | scanf("%d%d", &a, &b); 6 | b = a; 7 | a = b; 8 | printf("%d %d\n", a, b); 9 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/lista-ordinata/lista_ordinata: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/210_liste_sequenziali/lista-ordinata/lista_ordinata -------------------------------------------------------------------------------- /codice/090_array/bounds.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a[] = {2, 5, 3, 4, 1}, i = 0; 5 | while (1) { 6 | printf("%d\n", a[i]); 7 | i++; 8 | } 9 | } -------------------------------------------------------------------------------- /codice/l07/voti.in: -------------------------------------------------------------------------------- 1 | 10 2 | 5 3 | 3 4 | 7 5 | 19 6 | 18 7 | 7 8 | 12 9 | 17 10 | 22 11 | 29 12 | 13 13 | 23 14 | 6 15 | 30 16 | 5 17 | 29 18 | 29 19 | 4 20 | 7 21 | -1 22 | -------------------------------------------------------------------------------- /codice/040_variabili/commenti.c: -------------------------------------------------------------------------------- 1 | #include 2 | main() { // Un commento monolinea 3 | printf("Hello,"); 4 | /* Un commento 5 | 6 | multilinea */ printf(" World!\n"); 7 | } -------------------------------------------------------------------------------- /codice/040_variabili/doppio.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int v; // definizione 5 | v = 4; // assegnamento 6 | printf("%d\n", v * 2); // stampa dell'espressione 7 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/piena.c: -------------------------------------------------------------------------------- 1 | int piena(Lista l) 2 | { 3 | // e' piena se la dimensione logica e' pari alla dimensione massima 4 | return l.n_elementi == DIMENSIONE; 5 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/elimTesta.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | 4 | void elimTesta(Lista* pl) { 5 | Nodo* aux = *pl; 6 | *pl = (*pl)->next; 7 | free(aux); 8 | } -------------------------------------------------------------------------------- /codice/040_variabili/assegnamento-distruttivo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a; 5 | a = 2; 6 | printf("%d\n", a); 7 | a = 3; 8 | printf("%d\n", a); 9 | } 10 | -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/elenco-quozienti-do.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i = 1; 5 | do { 6 | printf("%d\n", 100 / i); 7 | i++; 8 | } while (i <= 10); 9 | } -------------------------------------------------------------------------------- /codice/060_espressioni/input-output-caratteri.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | char c; 5 | scanf("%c", &c); 6 | printf("Il codice ASCII del carattere %c e` %d\n", c, c); 7 | } -------------------------------------------------------------------------------- /codice/180_ricorsione/printf_ricorsiva.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void f(){ 4 | printf("Hello\n"); 5 | f(); // chiamata ricorsiva 6 | } 7 | 8 | int main(){ 9 | f(); 10 | } -------------------------------------------------------------------------------- /codice/030_introduzione_al_c/operazioni.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | printf("%d\n", 5 + 2); 5 | printf("%d\n", 5 - 2); 6 | printf("%d\n", 5 * 2); 7 | printf("%d\n", 5 / 2); 8 | } -------------------------------------------------------------------------------- /codice/040_variabili/somma.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | printf("Digita tre numeri interi\n"); 6 | scanf("%d%d%d", &a, &b, &c); 7 | printf("Somma: %d\n", a + b + c); 8 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/pin.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin; 5 | scanf("%d", &pin); 6 | 7 | if (pin == 44122) 8 | 9 | printf("Accesso consentito\n"); 10 | } 11 | -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/star5-do-while.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i = 1; 5 | do { 6 | printf("*"); 7 | i++; 8 | } while (i <= 5); 9 | printf("\n"); 10 | } -------------------------------------------------------------------------------- /codice/110_puntatori/stampa-stringa.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void f(char* s) { 4 | while (*s) 5 | printf("%c", *s++); 6 | } 7 | 8 | int main() { 9 | f("Hello\n"); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/azzeramento-lista/main.c: -------------------------------------------------------------------------------- 1 | #include "lista.h" 2 | 3 | int main() { 4 | Lista l; 5 | listaNonOrdinata(&l, 6); 6 | 7 | azzera(l); 8 | stampa(l); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/lunghezza-di-una-lista/lunghezza-di-una-lista: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lbrmrc/Programmazione2022/HEAD/codice/230_liste_collegate/lunghezza-di-una-lista/lunghezza-di-una-lista -------------------------------------------------------------------------------- /codice/l07/elenco.txt: -------------------------------------------------------------------------------- 1 | total 24 2 | -rwxr-xr-x 1 marco marco 18088 Nov 17 11:10 a.out 3 | -rw-r--r-- 1 marco marco 0 Nov 17 11:18 elenco.txt 4 | -rw-r--r-- 1 marco marco 402 Nov 17 11:10 minimo.c 5 | -------------------------------------------------------------------------------- /esami/20221108-parziale/d1.c: -------------------------------------------------------------------------------- 1 | int main(void) { 2 | int m = 1000000; 3 | do { 4 | if (!(m % 2)) 5 | m -= 3; 6 | else 7 | m /= 3; 8 | } while (m >= 0); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /tutorato/tutorato_08/input.txt: -------------------------------------------------------------------------------- 1 | 3 2 | audi 3 | 1000 4 | 2015 5 | pippo 6 | mirto 7 | ford 8 | 1000 9 | 2012 10 | Rossi 11 | Carlo 12 | audi 13 | 2000 14 | 2015 15 | Verdi 16 | Mario 17 | audi 18 | 2015 -------------------------------------------------------------------------------- /codice/090_array/foreach.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM]; 6 | int i; 7 | for (i = 0; i < DIM; i++) { 8 | // istruzione o istruzioni su a[i] 9 | } 10 | } -------------------------------------------------------------------------------- /codice/110_puntatori/riferimento.c: -------------------------------------------------------------------------------- 1 | ... f(...,T *pa, ...) { 2 | ... 3 | *pa = ... 4 | ... 5 | } 6 | 7 | ...g(...) { 8 | T a; 9 | ... 10 | ... f(..., &a, ...) ... 11 | ... 12 | } -------------------------------------------------------------------------------- /codice/110_puntatori/stampa-stringa-2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void f(int* s) { 4 | while (*s) 5 | printf("%c", *s++); 6 | } 7 | 8 | int main() { 9 | f("Hello\n"); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/swap.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a = 2, b = 3, t; 5 | 6 | t = a; 7 | a = b; 8 | b = t; 9 | printf("%d %d\n", a, b); // stampa 3 2 10 | } -------------------------------------------------------------------------------- /codice/l04/touppercase-v2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | char c; 5 | do { 6 | scanf("%c", &c); 7 | printf("%c", c - (c >= 'a' && c <= 'z') * ('a'- 'A')); 8 | } while (c != '\n'); 9 | } -------------------------------------------------------------------------------- /codice/l04/touppercase.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | char c; 5 | do { 6 | scanf("%c", &c); 7 | printf("%c", c >= 'a' && c <= 'z' ? c - ('a' - 'A') : c); 8 | } while (c != '\n'); 9 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/elenco-quozienti-goto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i = 1; 5 | ciclo: 6 | printf("%d\n", 100 / i); 7 | i++; 8 | if (i <= 10) 9 | goto ciclo; 10 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/star5-salto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i = 0; 5 | scrivi: 6 | printf("*\n"); 7 | i++; 8 | if (i < 5) 9 | goto scrivi; 10 | printf("\n"); 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/analisi.c: -------------------------------------------------------------------------------- 1 | void g(int* h) { 2 | (*h)++; 3 | } 4 | int f(int a, int* b) { 5 | g(b); 6 | return a + (*b); 7 | } 8 | main() { 9 | int c = 1, d = 3, s = 6; 10 | s = f(c, &d); 11 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/reverse/Makefile: -------------------------------------------------------------------------------- 1 | reverse: main.o lista.o 2 | gcc -g -o reverse main.o lista.o 3 | 4 | main.o: main.c lista.h 5 | gcc -g -c main.c 6 | 7 | lista.o: lista.c lista.h 8 | gcc -g -c lista.c -------------------------------------------------------------------------------- /codice/l06/d2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int a = 0; 5 | do { 6 | if (a % 3) 7 | a += 4; 8 | else 9 | a += 5; 10 | } while (1); 11 | 12 | return 0; 13 | } -------------------------------------------------------------------------------- /codice/040_variabili/quoziente-resto-variabile.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int dividendo; 5 | dividendo = 15; 6 | printf("Quoz.: %d\n", dividendo / 7); 7 | printf("Resto: %d\n", dividendo % 7); 8 | } -------------------------------------------------------------------------------- /codice/110_puntatori/azzera.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void azzera (int *p){ 4 | *p = 0; 5 | } 6 | 7 | int main(){ 8 | int a = 2; 9 | azzera(&a); 10 | printf("%d\n", a); // stampa 0 11 | } 12 | -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/campo.c: -------------------------------------------------------------------------------- 1 | void f(Persona p) { 2 | p.nome[0] = 'A'; 3 | } 4 | 5 | int main() { 6 | Persona per = {"Mario", 25}; 7 | f(per); // per.nome rimane invariato 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /codice/230_liste_collegate/stampa.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | 4 | void stampa(Lista l) { 5 | while (l) { 6 | printf("%d ", l->dato); 7 | l = l->next; 8 | } 9 | printf("\n"); 10 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/input-denominatore.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int denominatore; 5 | scanf("%d", &denominatore); 6 | if (10 / denominatore > 2) 7 | printf("Verificato\n"); 8 | } -------------------------------------------------------------------------------- /codice/090_array/doppio.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | int main(void) { 4 | int i, a[] = {2, 4, 1, 6, 2}, b[5]; 5 | 6 | for (i = 0; i < DIM; i++) { 7 | b[i] = 2 * a[i]; 8 | } 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/090_array/foreach-indietro.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM]; 6 | int i; 7 | for (i = DIM - 1; i >= 0; i--) { 8 | // istruzione o istruzioni su a[i] 9 | } 10 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/reduce.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | 4 | int somma(Lista l) { 5 | int s = 0; 6 | while (l) { 7 | s += l->dato; 8 | l = l->next; 9 | } 10 | return s; 11 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/stampa-seq.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "lista-seq.h" 3 | void stampa(Lista l) { 4 | int i; 5 | for (i = 0; i < (l.n_elementi); i++) 6 | printf("%d ", l.dati[i]); 7 | printf("\n"); 8 | } -------------------------------------------------------------------------------- /codice/097_numeri_casuali/temperature.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) { 5 | int i; 6 | for (i = 0; i < 10; i++) 7 | printf("%f\n", 15.0 + 10.0 * rand() / RAND_MAX); 8 | return 0; 9 | } -------------------------------------------------------------------------------- /codice/110_puntatori/intero-vs-puntatore.c: -------------------------------------------------------------------------------- 1 | #include 2 | main() { 3 | int i = 100; 4 | int* p = (int*)100; 5 | printf("i vale %d; i + 1 vale %d\n", i, i + 1); 6 | printf("p vale %d; p + 1 vale %d\n", p, p + 1); 7 | } -------------------------------------------------------------------------------- /codice/110_puntatori/puntatore.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a = 2; 5 | int *pa; 6 | 7 | pa = &a; 8 | a = 12; 9 | scanf("%d", pa); 10 | printf("%d\n", *pa); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /codice/110_puntatori/rappresentazione-puntatori.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a = 2, b = 10, *p; 5 | p = &a; 6 | printf("%d\n", *p); 7 | p = p - 4; 8 | printf("%d\n", *p); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "contatore.h" 4 | 5 | int main() { 6 | inizializza(); 7 | stampa(); 8 | incrementa(); 9 | incrementa(); 10 | stampa(); 11 | return 0; 12 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/azzeramento-lista/Makefile: -------------------------------------------------------------------------------- 1 | azzeramento: main.o lista.o 2 | gcc -g -o azzeramento main.o lista.o 3 | 4 | main.o: main.c lista.h 5 | gcc -c -g main.c 6 | 7 | lista.o: lista.c lista.h 8 | gcc -c -g lista.c -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/inversione-cifre.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n; 5 | scanf("%d", &n); 6 | while (n > 0) { 7 | printf("%d", n % 10); 8 | n = n / 10; 9 | } 10 | printf("\n"); 11 | } -------------------------------------------------------------------------------- /codice/060_espressioni/stampa-alfabeto.c: -------------------------------------------------------------------------------- 1 | // stampa l'alfabeto maiuscolo su una riga 2 | 3 | #include 4 | 5 | main() { 6 | char c; 7 | for (c = 'A'; c <= 'Z'; c++) 8 | printf("%c", c); 9 | printf("\n"); 10 | } -------------------------------------------------------------------------------- /codice/097_numeri_casuali/dado.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) { 5 | int i; 6 | for (i = 0; i < 10; i++) 7 | printf("%d ", 1 + rand() % 6); 8 | printf("\n"); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/180_ricorsione/fattoriale.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int fact(int n) { 4 | if (n == 0) 5 | return 1; 6 | else 7 | return n * fact(n - 1); 8 | } 9 | 10 | int main(){ 11 | printf("%d\n", fact(5)); 12 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore/programma.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int cont; 5 | cont = 0; 6 | printf("%d\n", cont); 7 | cont++; 8 | cont++; 9 | printf("%d\n", cont); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/lista-ordinata/Makefile: -------------------------------------------------------------------------------- 1 | lista_ordinata: main.o lista.o 2 | gcc -g -o lista_ordinata main.o lista.o 3 | 4 | main.o: main.c lista.h 5 | gcc -g -c main.c 6 | 7 | lista.o: lista.c lista.h 8 | gcc -g -c lista.c -------------------------------------------------------------------------------- /codice/230_liste_collegate/es-elim1.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | #include "generatoreListe.h" 3 | #include "elim1.h" 4 | 5 | int main(void) { 6 | Lista l; 7 | listaNonOrdinata(&l, 4); 8 | elim1(&l, 2); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/seq/20170622/Makefile: -------------------------------------------------------------------------------- 1 | scontrini: listino.o main.o 2 | gcc -g -o scontrini listino.o main.o 3 | 4 | listino.o: listino.c listino.h 5 | gcc -g -c listino.c 6 | 7 | main.o: main.c listino.h 8 | gcc -g -c main.c -------------------------------------------------------------------------------- /esami/20200219/Makefile: -------------------------------------------------------------------------------- 1 | utenti: main.o listaUtenti.o 2 | gcc -g -o utenti main.o listaUtenti.o 3 | 4 | listaUtenti.o: listaUtenti.c listaUtenti.h 5 | gcc -g -c listaUtenti.c 6 | 7 | main.o: main.c listaUtenti.h 8 | gcc -g -c main.c -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/compreso-con-and.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a; 5 | scanf("%d", &a); 6 | if (a >= 2 && a <= 5) 7 | printf("Compreso\n"); 8 | else 9 | printf("Non compreso\n"); 10 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/pin-goto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin; 5 | richiesta: 6 | scanf("%d", &pin); 7 | if (pin != 44122) 8 | goto richiesta; 9 | printf("Accesso consentito\n"); 10 | } 11 | -------------------------------------------------------------------------------- /codice/070_funzioni/scope-domanda1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int a = 1; 4 | 5 | int main() { 6 | while (a--) { 7 | { 8 | int a = 3; 9 | printf("%d\n", a); 10 | } 11 | printf("%d\n", a); 12 | } 13 | } -------------------------------------------------------------------------------- /codice/090_array/map-in-place.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | int main(void) { 4 | int i, a[] = {2, 4, 1, 6, 2}; 5 | 6 | for (i = 0; i < DIM; i++) { 7 | a[i] = // espressione con a[i]; 8 | } 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/090_array/map.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | int main(void) { 4 | int i, a[] = {2, 4, 1, 6, 2}, b[DIM]; 5 | 6 | for (i = 0; i < DIM; i++) { 7 | b[i] = // espressione con a[i]; 8 | } 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore-adt/programma.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | int cont; 5 | cont = 0; 6 | printf("%d\n", cont); 7 | cont++; 8 | cont++; 9 | printf("%d\n", cont); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/l11/20220118-pratica-parziale/testo.txt: -------------------------------------------------------------------------------- 1 | Nory was a Catholic because her mother was a catholic and her mother was a Catholic because her father was a catholic and her father was a Catholic because his mother was a Catholic or had been -------------------------------------------------------------------------------- /esami/20221108-parziale/d2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int n; 5 | scanf("%d", &n); 6 | do { 7 | if (n % 2) 8 | n--; 9 | else 10 | n /= 2; 11 | } while (n > 0); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /tutorato/tutorato_10/iterativa.c: -------------------------------------------------------------------------------- 1 | int iterativa(int *a, int n){ 2 | int i; 3 | int count=0; 4 | for(i=0; i0){ 6 | count++; 7 | } 8 | } 9 | 10 | return count; 11 | } -------------------------------------------------------------------------------- /codice/062_espressione_condizionale/valore-assoluto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int n; 5 | printf("Inserisci un intero\n"); 6 | scanf("%d", &n); 7 | // |-5| = 5 8 | printf("|%d| = %d\n", n, (n < 0 ? -n : n)); 9 | } -------------------------------------------------------------------------------- /codice/070_funzioni/scope-domanda2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | while (a--) { 5 | { 6 | int a = 3; 7 | printf("%d\n", a); 8 | } 9 | printf("%d\n", a); 10 | } 11 | } 12 | 13 | int a = 1; 14 | -------------------------------------------------------------------------------- /codice/090_array/map-int-char.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | int main(void) { 4 | int i, a[] = {2, 4, 1, 6, 2}; 5 | char b[5]; 6 | 7 | for (i = 0; i < DIM; i++) { 8 | b[i] = '0' + a[i]; 9 | } 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/090_array/swap.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int a, b; 5 | scanf("%d%d", &a, &b); 6 | 7 | { 8 | int temp = b; 9 | b = a; 10 | a = temp; 11 | } 12 | 13 | printf("%d %d\n", a, b); 14 | } -------------------------------------------------------------------------------- /codice/097_numeri_casuali/funzioni-casuali.c: -------------------------------------------------------------------------------- 1 | int rnd_int(int min, int max) { 2 | return min + rand() % (max - min + 1); 3 | } 4 | 5 | double rnd_double(double min, double max) { 6 | return min + (double)rand() / RAND_MAX * (max - min); 7 | } -------------------------------------------------------------------------------- /codice/160_argomenti_linea_comando/stampa_argomenti.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char* argv[]) { 4 | int i; 5 | printf("Numero argomenti: %d\n", argc); 6 | for (i = 0; i < argc; i++) 7 | printf("%s\n", argv[i]); 8 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore/contatore.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int cont; 4 | 5 | void inizializza() { 6 | cont = 0; 7 | } 8 | 9 | void incrementa() { 10 | cont++; 11 | } 12 | 13 | void stampa() { 14 | printf("%d\n", cont); 15 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/es-elim-testa.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | #include "generatoreListe.h" 3 | #include "elimTesta.h" 4 | 5 | int main(void) { 6 | Lista l; 7 | listaNonOrdinata(&l, 3); 8 | elimTesta(&l); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/es-elimTutti.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | #include "generatoreListe.h" 3 | #include "elimTutti.h" 4 | 5 | int main(void) { 6 | Lista l; 7 | listaNonOrdinata(&l, 4); 8 | elimTutti(&l, 2); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/es-ins-testa.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | #include "generatoreListe.h" 3 | #include "insTesta.h" 4 | 5 | int main(void) { 6 | Lista l; 7 | listaNonOrdinata(&l, 3); 8 | insTesta(&l, 5); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/l11/20220131-pratica-totale/Makefile: -------------------------------------------------------------------------------- 1 | esami: main.o listaEsami.o 2 | gcc -g -o esami main.o listaEsami.o 3 | 4 | main.o: main.c listaEsami.h 5 | gcc -g -c main.c 6 | 7 | listaEsami.o: listaEsami.c listaEsami.h 8 | gcc -g -c listaEsami.c -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/doppio.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n; 5 | richiesta: 6 | scanf("%d", &n); 7 | if (n >= 0) { 8 | printf("%d\n", n * 2); 9 | goto richiesta; 10 | } 11 | printf("Fine\n"); 12 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/pin-else.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin; 5 | scanf("%d", &pin); 6 | if (pin == 44122) 7 | printf("Accesso consentito\n"); 8 | else 9 | printf("Accesso negato\n"); 10 | } 11 | -------------------------------------------------------------------------------- /codice/070_funzioni/stesso-nome-scope-diversi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int i = 0; 4 | 5 | int main(void) { 6 | int i = 1; 7 | { 8 | int i = 2; 9 | printf("%d\n", i); 10 | } 11 | printf("%d\n", i); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore/Makefile: -------------------------------------------------------------------------------- 1 | esempio_contatore: main.o contatore.o 2 | gcc -o esempio_contatore -g main.o contatore.o 3 | 4 | main.o: main.c contatore.h 5 | gcc -c -g main.c 6 | 7 | contatore.o: contatore.c contatore.h 8 | gcc -c -g contatore.c -------------------------------------------------------------------------------- /esami/20191119-parziale/turno2/d2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int a; 5 | scanf("%d", &a); 6 | do { 7 | if (a % 3) 8 | a--; 9 | else 10 | a /= 2; 11 | } while (1); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /esami/20200122-parziale/turno2/Makefile: -------------------------------------------------------------------------------- 1 | vaccinazioni: main.o listaCani.o 2 | gcc -g -o vaccinazioni main.o listaCani.o 3 | 4 | main.o: main.c listaCani.h 5 | gcc -g -c main.c 6 | 7 | listaCani.o: listaCani.c listaCani.h 8 | gcc -g -c listaCani.c -------------------------------------------------------------------------------- /codice/040_variabili/quoziente-resto-due-var.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int dividendo, divisore; 5 | scanf("%d%d", ÷ndo, &divisore); 6 | printf("Q: %d\n", dividendo / divisore); 7 | printf("R: %d\n", dividendo % divisore); 8 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/input-denominatore-corretto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int denominatore; 5 | scanf("%d", &denominatore); 6 | if (denominatore != 0 && 10 / denominatore > 2) 7 | printf("Verificato\n"); 8 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/input-denominatore-scorretto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int denominatore; 5 | scanf("%d", &denominatore); 6 | if (10 / denominatore > 2 && denominatore != 0) 7 | printf("Verificato\n"); 8 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/tavola-pitagorica-2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, j; 5 | for (i = 1; i <= 10; i++) { 6 | for (j = i; j <= i * 10; j = j + i) 7 | printf("%d ", j); 8 | printf("\n"); 9 | } 10 | } -------------------------------------------------------------------------------- /codice/070_funzioni/valore-assoluto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int valore_assoluto(int n) { 4 | return n < 0 ? -n : n; 5 | } 6 | 7 | int main() { 8 | int a; 9 | scanf("%d", &a); 10 | printf("|%d| = %d\n", a, valore_assoluto(a)); 11 | } -------------------------------------------------------------------------------- /codice/090_array/cinque-a2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int numeri[5]; 5 | int i; 6 | for (i = 0; i < 5; i++) 7 | scanf("%d", &numeri[i]); 8 | 9 | for (i = 4; i >= 0; i--) 10 | printf("%d\n", numeri[i]); 11 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore-adt/Makefile: -------------------------------------------------------------------------------- 1 | esempio_contatore: main.o contatore.o 2 | gcc -o esempio_contatore -g main.o contatore.o 3 | 4 | main.o: main.c contatore.h 5 | gcc -c -g main.c 6 | 7 | contatore.o: contatore.c contatore.h 8 | gcc -c -g contatore.c -------------------------------------------------------------------------------- /codice/200_adt/figure-adt/Makefile: -------------------------------------------------------------------------------- 1 | esempio_figure: main.o figura.o 2 | gcc -o esempio_figure -g main.o figura.o -lm 3 | 4 | main.o: main.c figura.h 5 | gcc -c -g main.c 6 | 7 | figura.o: figura.c figura.h 8 | gcc -c -g figura.c 9 | 10 | 11 | -------------------------------------------------------------------------------- /codice/l10/20170130/Makefile: -------------------------------------------------------------------------------- 1 | calorie: main.o listaCalorie.o 2 | gcc -g -o calorie main.o listaCalorie.o 3 | 4 | main.o: main.c listaCalorie.h 5 | gcc -c -g main.c 6 | 7 | listaCalorie.o: listaCalorie.c listaCalorie.h 8 | gcc -c -g listaCalorie.c 9 | -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-input.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i; 5 | int n; 6 | int s; 7 | s = 0; 8 | for (i = 1; i <= 5; i++) { 9 | scanf("%d", &n); 10 | s = s + n; 11 | } 12 | printf("%d\n", s); 13 | } -------------------------------------------------------------------------------- /codice/070_funzioni/variabile-globale.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int a; 4 | 5 | void incrementa() { 6 | a++; 7 | } 8 | 9 | int main() { 10 | a = 1; 11 | printf("%d\n", a); 12 | incrementa(); 13 | printf("%d\n", a); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /codice/095_stringhe/lunghezza.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 6 3 | 4 | int main() { 5 | char s[DIM]; 6 | int count; 7 | scanf("%s", s); 8 | count = 0; 9 | while (s[count] != '\0') 10 | count++; 11 | printf("%d\n", count); 12 | } -------------------------------------------------------------------------------- /codice/097_numeri_casuali/numeri-casuali.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | int i; 7 | srand(time(NULL)); 8 | for (i = 0; i < 10; i++) 9 | printf("%d\n", rand()); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/swap-procedura.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void swap(int m, int n) { 4 | int t; 5 | t = m; 6 | m = n; 7 | n = t; 8 | } 9 | 10 | int main() { 11 | int a = 2, b = 3; 12 | swap(a, b); 13 | printf("%d %d\n", a, b); 14 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/stampa.c: -------------------------------------------------------------------------------- 1 | void stampa(Lista l) { 2 | int i; 3 | // stampo tutti gli elementi, separati da spazi 4 | for (i = 0; i < (l.n_elementi); i++) { 5 | printf("%d ", l.dati[i]); 6 | } 7 | // vado a capo 8 | printf("\n"); 9 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/es-ins-ord.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | #include "insOrd.h" 3 | 4 | int main(void) { 5 | Lista l; 6 | nuovaLista(&l); 7 | insOrd(&l, 3); 8 | insOrd(&l, 1); 9 | insOrd(&l, 4); 10 | insOrd(&l, 2); 11 | return 0; 12 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/es-stampa.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | #include "generatoreListe.h" 4 | #include "stampa.h" 5 | 6 | int main(void) { 7 | Lista l; 8 | listaNonOrdinata(&l, 3); 9 | stampa(l); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/lunghezza-di-una-lista/Makefile: -------------------------------------------------------------------------------- 1 | lunghezza-di-una-lista: main.o lista.o 2 | gcc -g -o lunghezza-di-una-lista main.o lista.o 3 | 4 | main.o: main.c lista.h 5 | gcc -c -g main.c 6 | 7 | lista.o: lista.c lista.h 8 | gcc -c -g lista.c -------------------------------------------------------------------------------- /codice/l11/20220118-pratica-parziale/Makefile: -------------------------------------------------------------------------------- 1 | frequenze: main.o listaParole.o 2 | gcc -g -o frequenze main.o listaParole.o 3 | 4 | main.o: main.c listaParole.h 5 | gcc -g -c main.c 6 | 7 | listaParole.o: listaParole.c listaParole.h 8 | gcc -g -c listaParole.c -------------------------------------------------------------------------------- /esami/20200122-parziale/turno1/Makefile: -------------------------------------------------------------------------------- 1 | fatture: main.o listaVeicoli.o 2 | gcc -g -o fatture main.o listaVeicoli.o 3 | 4 | main.o: main.c listaVeicoli.h 5 | gcc -g -c main.c 6 | 7 | listaVeicoli.o: listaVeicoli.c listaVeicoli.h 8 | gcc -g -c listaVeicoli.c -------------------------------------------------------------------------------- /esami/20200203/Makefile: -------------------------------------------------------------------------------- 1 | palestra: listaUtenti.o main.o 2 | gcc -g -o palestra listaUtenti.o main.o 3 | 4 | main.o: main.c listaUtenti.o 5 | gcc -g -c main.c 6 | 7 | listaUtenti.o: listaUtenti.c listaUtenti.h 8 | gcc -g -c listaUtenti.c 9 | 10 | -------------------------------------------------------------------------------- /tutorato/tutorato_11/Makefile: -------------------------------------------------------------------------------- 1 | pazienti: main.o listaPazienti.o 2 | gcc -g -o pazienti main.o listaPazienti.o 3 | 4 | main.o: main.c listaPazienti.h 5 | gcc -c -g main.c 6 | 7 | listaPazienti.o: listaPazienti.c listaPazienti.h 8 | gcc -c -g listaPazienti.c -------------------------------------------------------------------------------- /codice/040_variabili/doppio-con-variabile.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int v; // definizione MEMORIA CENTRALE 5 | printf("Inserisci un intero\n"); 6 | scanf("%d", &v); // input 7 | printf("Il doppio e` %d\n", v * 2); // output e CPU 8 | } -------------------------------------------------------------------------------- /codice/040_variabili/quoziente-resto-input.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int dividendo; 5 | printf("Inserisci un numero intero\n"); 6 | scanf("%d", ÷ndo); 7 | printf("Q: %d\n", dividendo / 7); 8 | printf("R: %d\n", dividendo % 7); 9 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/pin-e-non.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin; 5 | scanf("%d", &pin); 6 | if (pin == 44122) 7 | printf("Accesso consentito\n"); 8 | if (pin != 44122) 9 | printf("Accesso negato\n"); 10 | } 11 | -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/tavola-pitagorica-con-allineamento.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, j; 5 | for (i = 1; i <= 10; i++) { 6 | for (j = 1; j <= 10; j++) 7 | printf("%4d", i * j); 8 | printf("\n"); 9 | } 10 | } -------------------------------------------------------------------------------- /codice/110_puntatori/array-e-puntatori-2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a[10], *p, i; 5 | for (i = 0, p = a; i < 10; i++, p++) 6 | *p = i; 7 | for (i = 0, p = a; i < 10; i++, p++) 8 | printf("%d\n", *p); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/110_puntatori/assegnamento-1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a = 1, b = 2; 5 | int *pa = &a, *pb = &b; 6 | *pa = *pb; 7 | printf("%d %d\n", *pa, *pb); 8 | *pa = 3; 9 | printf("%d %d\n", *pa, *pb); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/assegnamento-2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a = 1, b = 2; 5 | int *pa = &a, *pb = &b; 6 | pa = pb; 7 | printf("%d %d\n", *pa, *pb); 8 | *pa = 3; 9 | printf("%d %d\n", *pa, *pb); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/l11/20170130-pratica-totale/Makefile: -------------------------------------------------------------------------------- 1 | calorie: main.o listaCalorie.o 2 | gcc -g -o calorie main.o listaCalorie.o 3 | 4 | main.o: main.c listaCalorie.h 5 | gcc -c -g main.c 6 | 7 | listaCalorie.o: listaCalorie.c listaCalorie.h 8 | gcc -c -g listaCalorie.c 9 | -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/doppio2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n; 5 | richiesta: 6 | scanf("%d", &n); 7 | printf("%d\n", n * 2); // stampa anche il doppio dei negativi 8 | if (n >= 0) 9 | goto richiesta; 10 | printf("Fine\n"); 11 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/maggiore.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b; 5 | printf("Inserisci due interi\n"); 6 | scanf("%d%d", &a, &b); 7 | 8 | if (a > b) 9 | printf("%d\n", a); 10 | else 11 | printf("%d\n", b); 12 | 13 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/tavola-pitagorica.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, j; 5 | for (i = 1; i <= 10; i++) { 6 | for (j = 1; j <= 10; j++) 7 | printf("%d ", i * j); 8 | if (i * j > 50) 9 | printf("\n"); 10 | } 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/array-e-puntatori.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a[10], i; 5 | for (i = 0; i < 10; i++) 6 | *(a + i) = i; // equivalente ad a[i] = i; 7 | for (i = 0; i < 10; i++) 8 | printf("%d\n", *(a + i)); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore-adt/contatore.h: -------------------------------------------------------------------------------- 1 | // ADT Contatore - Interfaccia 2 | 3 | // tipo di dato 4 | typedef int Contatore; 5 | 6 | // dichiarazione delle funzioni esposte 7 | void inizializza(Contatore *pc); 8 | void incrementa(Contatore *pc); 9 | void stampa(Contatore c); -------------------------------------------------------------------------------- /codice/220_allocazione_dinamica/esempio-malloc.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | double* pd; 6 | pd = (double*)malloc(sizeof(double)); 7 | scanf("%lf", pd); 8 | printf("%lf\n", *pd); 9 | free(pd); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/001_informazioni_generali/somma.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, c; 5 | printf("Immetti due numeri interi:\n"); 6 | scanf("%d%d", &a, &b); 7 | c = a + b; 8 | printf("La somma di %d e %d e` %d\n", a, b, c); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /codice/090_array/positivi-map.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM], b[DIM], i, j = 0; 6 | 7 | for (i = 0; i < DIM; i++) 8 | scanf("%d", &a[i]); 9 | for (i = 0; i < DIM; i++) 10 | if (a[i] > 0) 11 | b[i] = a[i]; 12 | } -------------------------------------------------------------------------------- /codice/090_array/ricerca-break.c: -------------------------------------------------------------------------------- 1 | #define DIM 10 2 | int main() { 3 | int a[DIM]; 4 | int i; 5 | 6 | for (i = 0; i < DIM; i++) 7 | if (/* proprieta` desiderata di a[i] */) 8 | break; 9 | 10 | if (i < DIM) 11 | /* fai qualcosa con i o a[i] */ 12 | } -------------------------------------------------------------------------------- /codice/l04/radice-quadrata.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | main() { 5 | float a; 6 | float x; 7 | scanf("%f", &a); 8 | x = 1.0; 9 | while (fabsf(x * x - a) / a > 1e-5) { 10 | x = (x + a / x) / 2.0; 11 | } 12 | printf("%f\n", x); 13 | } -------------------------------------------------------------------------------- /tutorato/tutorato_10/ricorsiva.c: -------------------------------------------------------------------------------- 1 | int ricorsiva(int *a,int n, int i){ 2 | if(i==n){ 3 | return 0; 4 | } 5 | else if(a[i] > 0){ 6 | return 1 + ricorsiva(a,n,i+1); 7 | } 8 | else{ 9 | return 0 + ricorsiva(a,n,i+1); 10 | } 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/swap-puntatori.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void swap(int *pm, int *pn) { 4 | int t; 5 | t = *pm; 6 | *pm = *pn; 7 | *pn = t; 8 | } 9 | 10 | int main() { 11 | int a = 2, b = 3; 12 | swap(&a, &b); 13 | printf("%d %d\n", a, b); // stampa 3 2 14 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/return-array.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | char* indirizzo() { 4 | char s[] = "Via Saragat, 1 - 44122 Ferrara"; 5 | return s; 6 | } 7 | 8 | int main(void) { 9 | char* ind; 10 | ind = indirizzo(); 11 | printf("%s\n", ind); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/lunghezza-di-una-lista/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "lista.h" 4 | 5 | int main() { 6 | Lista l; 7 | listaNonOrdinata(&l, 6); 8 | printf("Lunghezza: %d\n", lunghezza(l)); 9 | printf("Massimo: %d\n", massimo(l)); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/l05/giorno-della-settimana.c: -------------------------------------------------------------------------------- 1 | int giorno_giuliano(int g, int m, int a) { 2 | int N0, N1, N2, N3; 3 | N0 = (m - 14) / 12; 4 | N1 = 1461 * (a + 4800 + N0) / 4; 5 | N2 = 367 * (m - 2 - 12 * N0) / 12; 6 | N3 = 3 * (a + 4900 + N0) / 400; 7 | return N1 + N2 - N3 + g - 32075; 8 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/compreso.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a; 5 | scanf("%d", &a); 6 | if (a >= 2) 7 | if (a <= 5) 8 | printf("Compreso\n"); 9 | else 10 | printf("Non compreso\n"); 11 | else 12 | printf("Non compreso\n"); 13 | } -------------------------------------------------------------------------------- /codice/l02/bisestile.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int anno; 5 | printf("Inserisci un anno\n"); 6 | scanf("%d", &anno); 7 | if ((anno % 4 == 0 && anno % 100 != 0) || (anno % 400 == 0)) 8 | printf("Bisestile\n"); 9 | else 10 | printf("Non bisestile\n"); 11 | } -------------------------------------------------------------------------------- /codice/l04/radice-quadrata-double.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | main() { 5 | double a; 6 | double x; 7 | scanf("%lf", &a); 8 | x = 1.0; 9 | while (fabs(x * x - a) / a > 1e-10) { 10 | x = (x + a / x) / 2.0; 11 | } 12 | printf("%.10lf\n", x); 13 | } -------------------------------------------------------------------------------- /tutorato/tutorato_10/Makefile: -------------------------------------------------------------------------------- 1 | prog: main.o iterativa.o ricorsiva.o 2 | gcc -o prog main.o iterativa.o ricorsiva.o 3 | 4 | main.o: main.c myinclude.h 5 | gcc -c main.c 6 | 7 | iterativa.o: iterativa.c 8 | gcc -c iterativa.c 9 | 10 | ricorsiva.o: ricorsiva.c 11 | gcc -c ricorsiva.c -------------------------------------------------------------------------------- /codice/090_array/20190121-t1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int f(int d); 4 | 5 | int main() { 6 | int a = 0, i[] = {1, 1, 1}; 7 | while (a < 2) 8 | i[a] = f(++a); 9 | 10 | for (i[0] = 2; i[0] >= 0; i[0]--) 11 | printf("%d ", i[i[0]]); 12 | printf("\n"); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /codice/090_array/doppio-con-funzione.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int f(int m){ 5 | return 2 * m; 6 | } 7 | 8 | int main(void) { 9 | int i, a[] = {2, 4, 1, 6, 2}, b[5]; 10 | 11 | for (i = 0; i < DIM; i++) { 12 | b[i] = f(a[i]); 13 | } 14 | return 0; 15 | } -------------------------------------------------------------------------------- /codice/097_numeri_casuali/dado-seed.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | int i; 7 | srand(time(NULL)); 8 | for (i = 0; i < 10; i++) { 9 | printf("%d ", 1 + rand() % 6); 10 | } 11 | printf("\n"); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/calorie/Makefile: -------------------------------------------------------------------------------- 1 | calcolo-calorie-pasto: main.o listaAlimento.o 2 | gcc -g -o calcolo-calorie-pasto main.o listaAlimento.o 3 | 4 | main.o: main.c listaAlimento.h 5 | gcc -g -c main.c 6 | 7 | listaAlimento.o: listaAlimento.c listaAlimento.h 8 | gcc -g -c listaAlimento.c -------------------------------------------------------------------------------- /codice/230_liste_collegate/calorie/Makefile: -------------------------------------------------------------------------------- 1 | calcolo-calorie-pasto: main.o listaAlimento.o 2 | gcc -g -o calcolo-calorie-pasto main.o listaAlimento.o 3 | 4 | main.o: main.c listaAlimento.h 5 | gcc -g -c main.c 6 | 7 | listaAlimento.o: listaAlimento.c listaAlimento.h 8 | gcc -g -c listaAlimento.c -------------------------------------------------------------------------------- /codice/230_liste_collegate/insCoda.c: -------------------------------------------------------------------------------- 1 | #include "insTesta.h" 2 | #include "tipi.h" 3 | 4 | Lista* ricerca(Lista* pl, int d) { 5 | while (*pl) 6 | pl = &(*pl)->next; 7 | return pl; 8 | } 9 | 10 | void insCoda(Lista* pl, int d) { 11 | pl = ricerca(pl, d); 12 | insTesta(pl, d); 13 | } -------------------------------------------------------------------------------- /codice/l07/crea_input.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int rnd_int(int a, int b) { 5 | return a + rand() % (b - a + 1); 6 | } 7 | 8 | int main(){ 9 | int i; 10 | for (i =0; i < 20; i++) 11 | printf("%d\n", rnd_int(0,30)); 12 | printf("-1\n"); 13 | } -------------------------------------------------------------------------------- /codice/070_funzioni/asterischi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | riga() { // definizione di funzione 4 | int i; 5 | for (i = 0; i < 20; i++) 6 | printf("*"); 7 | printf("\n"); 8 | } 9 | 10 | main() { 11 | int j; 12 | for (j = 0; j < 5; j++) 13 | riga(); // chiamata a funzione 14 | } -------------------------------------------------------------------------------- /codice/090_array/massimo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 10 3 | 4 | main() { 5 | int a[DIM], i, m; 6 | 7 | for (i = 0; i < DIM; i++) 8 | scanf("%d", &a[i]); 9 | m = 0; 10 | for (i = 1; i < DIM; i++) 11 | if (a[i] > a[m]) 12 | m = i; 13 | 14 | printf("%d\n", m); 15 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/somma-elementi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int somma(int v[5]) { 4 | int i, s = 0; 5 | for (i = 0; i < 5; i++) 6 | s += v[i]; 7 | return s; 8 | } 9 | 10 | int main(void) { 11 | int a[5] = {4, 1, 0, 8, 5}; 12 | printf("%d\n", somma(a)); // stampa 18 13 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/valore-ritorno.c: -------------------------------------------------------------------------------- 1 | Persona leggiPersona() { 2 | Persona p; 3 | scanf("%s%d", p.nome, &p.eta); 4 | return p; // corretto: il valore di ritorno e` una copia di p 5 | } 6 | 7 | int main() { 8 | Persona per; 9 | per = leggiPersona(); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /codice/230_liste_collegate/insTesta.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | 4 | void insTesta(Lista* pl, Dato d) { 5 | Nodo* aux = (Nodo*)malloc(sizeof(Nodo)); 6 | if (aux == NULL) exit(100); // allocazione non riuscita 7 | aux->dato = d; 8 | aux->next = *pl; 9 | *pl = aux; 10 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/lunghezza-di-una-lista/lista.h: -------------------------------------------------------------------------------- 1 | typedef int Dato; 2 | 3 | typedef struct nodo { 4 | Dato dato; 5 | struct nodo* next; 6 | } Nodo; 7 | 8 | typedef Nodo* Lista; 9 | 10 | void listaNonOrdinata(Lista* pl, int n); 11 | int lunghezza(Lista l); 12 | int massimo(Lista l); -------------------------------------------------------------------------------- /codice/090_array/cinque-macro.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int main(void) { 5 | int numeri[DIM]; 6 | int i; 7 | for (i = 0; i < DIM; i++) 8 | scanf("%d", &numeri[i]); 9 | 10 | for (i = DIM - 1; i >= 0; i--) 11 | printf("%d\n", numeri[i]); 12 | 13 | return 0; 14 | } -------------------------------------------------------------------------------- /codice/090_array/somma-elementi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM], i, s; 6 | 7 | for (i = 0; i < DIM; i++) 8 | scanf("%d", &a[i]); 9 | s = 0; 10 | for (i = 0; i < DIM; i++) 11 | s = s + a[i]; 12 | 13 | printf("La somma e` %d\n", s); 14 | } -------------------------------------------------------------------------------- /codice/150_progetti_multifile/radice-quadrata.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | float media(float y, float z); 4 | 5 | float radq(float a) { 6 | float x; // accumulatore 7 | x = 1.0; 8 | while (fabsf(x * x - a) / a > 1e-5) 9 | x = media(x, a / x); // media 10 | return x; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /codice/070_funzioni/fattoriale.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int fattoriale(int n) { 4 | int i; 5 | int prod = 1; 6 | 7 | for (i = 1; i <= n; i++) 8 | prod *= i; 9 | 10 | return prod; 11 | } 12 | 13 | main() { 14 | int a; 15 | scanf("%d", &a); 16 | printf("%d\n", fattoriale(a)); 17 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/array-parametro-output.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void indirizzo(char *s) { 5 | strcpy(s,"Via Saragat, 1 - 44122 Ferrara"); 6 | } 7 | 8 | int main(void) { 9 | char ind[100]; 10 | indirizzo(ind); 11 | printf("%s\n", ind); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/insertionSort.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | #include "elimTesta.h" 3 | #include "insOrd.h" 4 | 5 | void insertionSort(Lista* pl1) { 6 | Lista l2; 7 | nuovaLista(&l2); 8 | while (*pl1) { 9 | insOrd(&l2, (*pl1)->dato); 10 | elimTesta(pl1); 11 | } 12 | *pl1 = l2; 13 | } -------------------------------------------------------------------------------- /codice/070_funzioni/scope-for.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | char risposta; 5 | printf("Stampare?\n"); 6 | scanf("%c", &risposta); 7 | if (risposta == 's') { 8 | int i; 9 | for (i = 0; i < 10; i++) 10 | printf("*"); 11 | printf("\n"); 12 | } 13 | return 0; 14 | } -------------------------------------------------------------------------------- /codice/095_stringhe/copia.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 10 3 | 4 | int main() { 5 | char s1[DIM], s2[DIM]; 6 | int i; 7 | scanf("%s", s1); 8 | i = 0; 9 | while (s1[i] != '\0') { 10 | s2[i] = s1[i]; 11 | i++; 12 | } 13 | s2[i] = '\0'; 14 | printf("%s\n", s2); 15 | return 0; 16 | } -------------------------------------------------------------------------------- /codice/155_make/radice_quadrata/radice-quadrata.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "funzioni-aritmetiche.h" 4 | 5 | float radq(float a) { 6 | float x; // accumulatore 7 | x = 1.0; 8 | while (fabsf(quadrato(x) - a) / a > 1e-5) 9 | x = media(x, a / x); // media 10 | return x; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /codice/070_funzioni/fattoriale-versione2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int fattoriale(int n) { 4 | int prod = 1; 5 | 6 | while (n > 0) { 7 | prod *= n; 8 | n--; 9 | } 10 | 11 | return prod; 12 | } 13 | 14 | main() { 15 | int a; 16 | scanf("%d", &a); 17 | printf("%d\n", fattoriale(a)); 18 | } -------------------------------------------------------------------------------- /codice/090_array/cinque-var.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int DIM; 5 | scanf("%d", &DIM); 6 | int numeri[DIM]; 7 | int i; 8 | for (i = 0; i < DIM; i++) 9 | scanf("%d", &numeri[i]); 10 | 11 | for (i = DIM - 1; i >= 0; i--) 12 | printf("%d\n", numeri[i]); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/lista-ordinata/lista.h: -------------------------------------------------------------------------------- 1 | // Interfaccia ADT lista 2 | 3 | #define DIMENSIONE 50 4 | 5 | typedef struct { 6 | int n_elementi; 7 | int dati[DIMENSIONE]; 8 | } Lista; 9 | 10 | void nuova(Lista *pl); 11 | int piena(Lista *pl); 12 | void ins_ord(Lista *pl, int n); 13 | void stampa(Lista l); -------------------------------------------------------------------------------- /tutorato/tutorato_02/watch.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int a; 5 | int b; 6 | 7 | printf("Inserire a\n"); 8 | scanf("%d",&a); 9 | 10 | printf("Inserire b\n"); 11 | scanf("%d",&b); 12 | 13 | a += 1; 14 | b=a; 15 | 16 | a= 3+5; 17 | 18 | printf("%d", a); 19 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-difettoso.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, somma = 0; 5 | do { 6 | printf("Digita un intero (negativo termina):\n"); 7 | scanf("%d", &numero); 8 | somma += numero; 9 | } while (numero >= 0); 10 | printf("La somma e` %d\n", somma); 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/20190206-t1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int f(int d); 4 | 5 | int main(int argc, char* argv[]) { 6 | char s[] = "ABCDEFGHIJKLMNOPQRSTUVQXYZ"; 7 | int i = 1; 8 | while (i < 7) { 9 | printf("%c", *((char*)((int*)s + i))); 10 | i += f(i) ? f(i) : 1; 11 | } 12 | printf("\n"); 13 | } -------------------------------------------------------------------------------- /tutorato/tutorato_02/valore_assoluto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int n; 5 | 6 | printf("Inserire il numero:\n"); 7 | scanf("%d", &n); 8 | 9 | printf("Il valore assoluto di %n e' ", n); 10 | 11 | if(n>=0) 12 | printf("%d",n); 13 | else 14 | printf("%d", -n); 15 | } -------------------------------------------------------------------------------- /codice/040_variabili/quadrato.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int lato; 5 | int area; 6 | int perimetro; 7 | printf("Inserisci il lato\n"); 8 | scanf("%d", &lato); 9 | perimetro = 4 * lato; 10 | printf("perimetro = %d\n", perimetro); 11 | area = lato * lato; 12 | printf("area = %d\n", area); 13 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/stampa-stringa.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void stampa_stringa(char s[]) { 4 | int i; 5 | for (i = 0; s[i] != '\0'; i++) 6 | printf("%c", s[i]); 7 | } 8 | 9 | int main(void) { 10 | char parola[10] = "Ferrara"; 11 | stampa_stringa(parola); 12 | printf("\n"); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /tutorato/tutorato_01/pari_dispari.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int a; 5 | 6 | printf("Inserire un numero intero da tastiera: "); 7 | scanf("%d", &a); 8 | 9 | if(a%2 == 0) 10 | printf("Il numero inserito è pari\n"); 11 | else 12 | printf("Il numero inserito è dispari\n"); 13 | } -------------------------------------------------------------------------------- /tutorato/tutorato_07/strlen.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | char parola[21]; 5 | int i=0; 6 | 7 | printf("Inserire una stringa max 20 caratteri\n"); 8 | scanf("%s", parola); 9 | 10 | while(parola[i]!='\0'){ 11 | i++; 12 | } 13 | 14 | printf("La parola è lunga %d\n",i); 15 | } -------------------------------------------------------------------------------- /codice/090_array/progressivi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | int a[10]; 6 | int i; 7 | 8 | scanf("%d", &n); 9 | 10 | for (i = 0; i < 10; i++) 11 | a[i] = i + n + 1; 12 | // ForEach (printf, a) 13 | for (i = 0; i < 10; i++) 14 | printf("%d\n", a[i]); 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /codice/090_array/ricerca-flag.c: -------------------------------------------------------------------------------- 1 | #define DIM 10 2 | int main() { 3 | int a[DIM]; 4 | int trovato = 0, i; 5 | 6 | i = 0; 7 | while (!trovato && i < DIM) 8 | if (/* proprieta` desiderata di a[i] */) 9 | trovato = 1; 10 | else 11 | i++; 12 | 13 | if (trovato) 14 | /* fai qualcosa con i o a[i] */ 15 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/somma-elementi-dimensione-variabile.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int somma(int v[], int dl) { 4 | int i, s = 0; 5 | for (i = 0; i < dl; i++) 6 | s += v[i]; 7 | return s; 8 | } 9 | 10 | int main(void) { 11 | int a[5] = {4, 1, 0, 8, 5}; 12 | printf("%d\n", somma(a, 5)); // stampa 18 13 | } -------------------------------------------------------------------------------- /codice/090_array/ricerca-massimo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 10 3 | 4 | main() { 5 | int a[DIM], i, m; 6 | 7 | // ... 8 | m = 0; 9 | for (i = 1; i < DIM; i++) 10 | if (/* a[i] supera a[m] secondo 11 | la proprieta` desiderata */) 12 | m = i; 13 | 14 | // l'elemento massimo e` all'indice m 15 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/maggiore-di-tre.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | scanf("%d%d%d", &a, &b, &c); 6 | if (a > b) 7 | if (a > c) 8 | printf("%d\n", a); 9 | else 10 | printf("%d\n", c); 11 | else if (b > c) 12 | printf("%d\n", b); 13 | else 14 | printf("%d\n", c); 15 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-do.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, somma = 0; 5 | do { 6 | printf("Digita un intero (negativo termina):\n"); 7 | scanf("%d", &numero); 8 | if (numero >= 0) 9 | somma += numero; 10 | } while (numero >= 0); 11 | printf("La somma e` %d\n", somma); 12 | } -------------------------------------------------------------------------------- /codice/070_funzioni/potenza.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int potenza(int base, int esp) { 4 | int cont, prod = 1; 5 | for (cont = 0; cont < esp; cont++) 6 | prod *= base; 7 | return prod; 8 | } 9 | 10 | main() { 11 | int a = 3; 12 | int b = 2; 13 | printf("%d\n", potenza(a, b)); 14 | printf("%d\n", potenza(b, a)); 15 | } -------------------------------------------------------------------------------- /codice/070_funzioni/record-attivazione.c: -------------------------------------------------------------------------------- 1 | int R(int A) { 2 | int x = 2, y; 3 | y = x + A; 4 | return y; 5 | } 6 | int Q(int x) { 7 | int y; 8 | y = 2 * R(x); 9 | return y; 10 | } 11 | int P(void) { 12 | int a = 10, b; 13 | b = Q(a); 14 | return b; 15 | } 16 | main() { 17 | int x = 1; 18 | int y; 19 | y = x + P(); 20 | } -------------------------------------------------------------------------------- /codice/090_array/cinque.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c, d, e; 5 | scanf("%d", &a); 6 | scanf("%d", &b); 7 | scanf("%d", &c); 8 | scanf("%d", &d); 9 | scanf("%d", &e); 10 | 11 | printf("%d\n", e); 12 | printf("%d\n", d); 13 | printf("%d\n", c); 14 | printf("%d\n", b); 15 | printf("%d\n", a); 16 | } -------------------------------------------------------------------------------- /codice/155_make/Makefile: -------------------------------------------------------------------------------- 1 | prog: main.o file1.o file2.o file3.o 2 | gcc -g -o prog main.o file1.o file2.o file3.o 3 | 4 | main.o: main.c file1.h file2.h 5 | gcc -g -c main.c 6 | 7 | file1.o: file1.c file3.h 8 | gcc -g -c file1.c 9 | 10 | file2.o: file2.c file3.h 11 | gcc -g -c file2.c 12 | 13 | file3.o: file3.c 14 | gcc -g -c file3.c -------------------------------------------------------------------------------- /codice/l05/maiuscole.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | char toUppercase(char c) { 4 | if (c >= 'a' && c <= 'z') 5 | return c - ('a' - 'A'); 6 | else 7 | return c; 8 | } 9 | 10 | int main() { 11 | char c; 12 | do { 13 | scanf("%c", &c); 14 | printf("%c", toUppercase(c)); 15 | } while (c != '\n'); 16 | return 0; 17 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/operatori-relazionali.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a = 2, b = -3; 5 | 6 | // a > b 7 | printf("%d\n", a > b); 8 | printf("%d\n", a > 0); 9 | printf("%d\n", a + b >= 0); 10 | printf("%d\n", a = b); 11 | a = 2; 12 | printf("%d\n", a == b); 13 | printf("%d\n", a + b != b + a); 14 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-break.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, somma = 0; 5 | while (1) { 6 | printf("Digita un intero (negativo termina):\n"); 7 | scanf("%d", &numero); 8 | if (numero < 0) 9 | break; 10 | somma += numero; 11 | } 12 | printf("La somma e` %d\n", somma); 13 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-corretto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, somma = 0; 5 | do { 6 | printf("Digita un intero (negativo termina):\n"); 7 | scanf("%d", &numero); 8 | if (numero >= 0) 9 | somma += numero; 10 | } while (numero >= 0); 11 | printf("La somma e` %d\n", somma); 12 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/ricerca.c: -------------------------------------------------------------------------------- 1 | int ricerca(Lista l, int numero) { 2 | int i; 3 | // scorro tutti gli elementi della lista 4 | for (i = 0; i < l.n_elementi; i++) { 5 | // se trovo il numero cercato, ritorno 1 6 | if (l.dati[i] == numero) 7 | return 1; 8 | } 9 | // la lista e' finita: ritorno 0 10 | return 0; 11 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-do-goto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, somma = 0; 5 | do { 6 | printf("Digita un intero (negativo termina):\n"); 7 | scanf("%d", &numero); 8 | if (numero < 0) 9 | break; 10 | somma += numero; 11 | } while (1); 12 | printf("La somma e` %d\n", somma); 13 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/uscita-doppio-goto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, j; 5 | 6 | for (i = 1; i <= 10; i++) { 7 | for (j = 1; j <= 10; j++) { 8 | printf("%3d ", i * j); 9 | if (i * j > 50) 10 | goto finito; 11 | } 12 | printf("\n"); 13 | } 14 | finito: 15 | printf("Finito\n"); 16 | } -------------------------------------------------------------------------------- /codice/090_array/progressivi-v2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | int a[10]; 6 | int i; 7 | 8 | scanf("%d", &n); 9 | 10 | for (i = 0; i < 10; i++) { 11 | n++; 12 | a[i] = n; 13 | } 14 | // ForEach (printf, a) 15 | for (i = 0; i < 10; i++) 16 | printf("%d\n", a[i]); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /codice/230_liste_collegate/insOrd.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | #include "insTesta.h" 3 | 4 | Lista* ricerca(Lista* pl, int d) { 5 | while (*pl) { 6 | if ((*pl)->dato > d) 7 | break; 8 | pl = &(*pl)->next; 9 | } 10 | return pl; 11 | } 12 | 13 | void insOrd(Lista* pl, int d) { 14 | pl = ricerca(pl, d); 15 | insTesta(pl, d); 16 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-positivi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, numero, somma = 0; 5 | for (i = 0; i < 5; i++) { 6 | printf("Digita un intero:\n"); 7 | scanf("%d", &numero); 8 | 9 | if (numero <= 0) 10 | continue; 11 | somma += numero; 12 | } 13 | printf("La somma e` %d\n", somma); 14 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/uscita-doppio-break.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, j; 5 | 6 | int finito = 0; 7 | for (i = 1; i <= 10; i++) { 8 | for (j = 1; j <= 10; j++) { 9 | printf("%3d ", i * j); 10 | if (i * j > 50) 11 | break; 12 | } 13 | printf("\n"); 14 | } 15 | printf("Finito\n"); 16 | } -------------------------------------------------------------------------------- /codice/090_array/reduce.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 10 3 | 4 | main() { 5 | int a[DIM], i, s; 6 | // ... 7 | s = 0; // inizializzazione accumulatore 8 | for (i = 0; i < DIM; i++) 9 | s = /* aggiornamento accumulatore 10 | al risultato dell'operazione su se 11 | stesso (s) e l'elemento corrente (a[i]) */ 12 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/azzera-array.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void azzera(int v[], int dl) { 4 | int i; 5 | for (i = 0; i < dl; i++) 6 | v[i] = 0; 7 | } 8 | 9 | int main(void) { 10 | int i = 0, a[3] = {1, 2, 3}; 11 | azzera(a, 3); 12 | for (i = 0; i < 3; i++) 13 | printf("%d ", a[i]); 14 | printf("\n"); 15 | return 0; 16 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/reverse/lista.h: -------------------------------------------------------------------------------- 1 | // Interfaccia ADT lista 2 | 3 | typedef float Dato; 4 | 5 | typedef struct nodo { 6 | Dato dato; 7 | struct nodo* next; 8 | } Nodo; 9 | 10 | typedef Nodo *Lista; 11 | 12 | void nuovaLista(Lista *pl); 13 | void insTesta(Lista *pl, Dato d); 14 | void reverse(Lista l1, Lista *pl2); 15 | void stampa(Lista l); -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-goto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, somma = 0; 5 | richiedi: 6 | printf("Digita un intero (negativo termina):\n"); 7 | scanf("%d", &numero); 8 | if (numero < 0) 9 | goto fine; 10 | somma += numero; 11 | goto richiedi; 12 | fine: 13 | printf("La somma e` %d\n", somma); 14 | } -------------------------------------------------------------------------------- /codice/070_funzioni/massimo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int massimo(int a, int b) { 4 | if (a > b) 5 | return a; 6 | else 7 | return b; 8 | // return a > b ? a : b; 9 | } 10 | 11 | int main() { 12 | int a, b; 13 | printf("inserisci due interi\n"); 14 | scanf("%d%d", &a, &b); 15 | printf("Il massimo è %d\n", massimo(a, b)); 16 | } 17 | -------------------------------------------------------------------------------- /codice/090_array/positivi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | main() { 5 | int a[DIM], b[DIM], i, dl = 0; 6 | 7 | for (i = 0; i < DIM; i++) 8 | scanf("%d", &a[i]); 9 | for (i = 0; i < DIM; i++) 10 | if (a[i] > 0) { 11 | b[dl] = a[i]; 12 | dl++; 13 | } 14 | for (i = 0; i < dl; i++) 15 | printf("%d\n", b[i]); 16 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/somma-elementi-macro.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int somma(int v[DIM]) { 5 | int i, s = 0; 6 | for (i = 0; i < DIM; i++) 7 | s += v[i]; 8 | return s; 9 | } 10 | 11 | int main(void) { 12 | int a[DIM] = {4, 1, 0, 8, 5}; 13 | printf("%d\n", sizeof(a)); 14 | printf("%d\n", somma(a)); // stampa 18 15 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/triangolo-rettangolo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | printf("Inserisci i tre lati\n"); 6 | scanf("%d%d%d", &a, &b, &c); // supponiamo che c sia il più grande 7 | if (a * a + b * b == c * c ) // teorema di Pitagora 8 | printf("Rettangolo\n"); 9 | else 10 | printf("Non rettangolo\n"); 11 | } -------------------------------------------------------------------------------- /codice/110_puntatori/divisione-con-procedura.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void divisione(int dividendo, int divisore, int *pq, int *pr){ 4 | *pq = dividendo / divisore; 5 | *pr = dividendo % divisore; 6 | } 7 | 8 | int main(void){ 9 | int q, r; 10 | divisione(15, 7, &q, &r); 11 | printf("%d, %d\n", q, r); // stampa 2,1 12 | return 0; 13 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/triangolo-con-connettivi-v2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | printf("Inserisci i tre lati\n"); 6 | scanf("%d%d%d", &a, &b, &c); 7 | if (a == b && a == c) 8 | printf("Equilatero\n"); 9 | else if (a == b || a == c || b == c) 10 | printf("Isoscele\n"); 11 | else 12 | printf("Scaleno\n"); 13 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/uscita-doppio.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, j; 5 | 6 | for (i = 1; i <= 10; i++) { 7 | for (j = 1; j <= 10; j++) { 8 | printf("%3d ", i * j); 9 | if (i * j > 50) 10 | // qui vorrei terminare l'esecuzione 11 | ; 12 | } 13 | printf("\n"); 14 | } 15 | printf("Finito\n"); 16 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/azzeramento-lista/lista.h: -------------------------------------------------------------------------------- 1 | // interfaccia dell'ADT Lista di interi con implementazione collegata 2 | 3 | typedef int Dato; 4 | 5 | typedef struct nodo { 6 | Dato dato; 7 | struct nodo* next; 8 | } Nodo; 9 | 10 | typedef Nodo *Lista; 11 | 12 | void azzera(Lista l); 13 | void stampa(Lista l); 14 | void listaNonOrdinata(Lista* pl, int n); -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/divisione.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int m, n; 5 | int q; 6 | printf("Inserisci dividendo e divisore\n"); 7 | scanf("%d%d", &m, &n); 8 | q = 0; 9 | while (m - n >= 0) { 10 | m = m - n; // aggiorno m 11 | q++; // aggiorno q 12 | } 13 | printf("Quoziente: %d, Resto: %d\n", q, m); 14 | } -------------------------------------------------------------------------------- /codice/060_espressioni/media.c: -------------------------------------------------------------------------------- 1 | // scrivere un programma che richiede all'utente due numeri reali e stampa la 2 | // loro media 3 | 4 | // es. input 2.3 2.7, output 2.5 5 | 6 | #include 7 | 8 | main() { 9 | float a, b, m; 10 | printf("Inserisci due numeri reali\n"); 11 | scanf("%f%f", &a, &b); 12 | m = (a + b) / 2.0; 13 | printf("Media: %f\n", m); 14 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/triangolo-con-connettivi-no-isoscele.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | printf("Inserisci i tre lati\n"); 6 | scanf("%d%d%d", &a, &b, &c); 7 | if (a == b && a == c) 8 | printf("Equilatero\n"); 9 | else if (a != b && a != c && b != c) 10 | printf("Scaleno\n"); 11 | else 12 | printf("Isoscele\n"); 13 | } -------------------------------------------------------------------------------- /codice/060_espressioni/media-float.c: -------------------------------------------------------------------------------- 1 | // scrivere un programma che richiede all'utente due numeri reali e stampa la 2 | // loro media 3 | 4 | // es. input 2.3 2.7, output 2.5 5 | 6 | #include 7 | 8 | main() { 9 | float a, b, m; 10 | printf("Inserisci due numeri reali\n"); 11 | scanf("%f%f", &a, &b); 12 | m = (a + b) / 2.0; 13 | printf("Media: %f\n", m); 14 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/moltiplicazione.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int m, n, i, p; 5 | printf("Inserisci due interi\n"); 6 | scanf("%d%d", &m, &n); 7 | 8 | p = 0; 9 | for (i = 1; i <= n; i++) { 10 | // S1: m assume la sequenza di n elementi uguali a m 11 | p = p + m; //aggiornamento accumulatore 12 | } 13 | printf("Prodotto: %d\n", p); 14 | } -------------------------------------------------------------------------------- /codice/155_make/radice_quadrata/funzioni-aritmetiche.h: -------------------------------------------------------------------------------- 1 | // Header di funzioni aritmetiche 2 | 3 | // definizioni dei tipi 4 | 5 | typedef struct { 6 | int numeratore, denominatore; 7 | } Frazione; 8 | 9 | // dichiarazione delle funzioni esposte 10 | 11 | float media(float y, float z); 12 | float media_geometrica(float y, float z); 13 | float quadrato(float y); 14 | float cubo(float x); -------------------------------------------------------------------------------- /codice/220_allocazione_dinamica/array-dimensione-dinamica.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | int dim, i; 6 | int *a; 7 | printf("Dimensione array?\n"); 8 | scanf("%d", &dim); 9 | a = (int*)malloc(dim*sizeof(int)); 10 | for (i = 0; i < dim; i++) 11 | a[i] = i; // oppure *(a+i) = i; 12 | free(a); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /codice/l03/divisori.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n, i; 5 | printf("Inserisci un numero naturale\n"); 6 | scanf("%d", &n); 7 | for (i = 1; i <= n; i++) { 8 | // S1 : i assume valori compresi fra 1 e n 9 | if (n % i == 0) 10 | { 11 | // output: i assume i valori divisori di n compresi fra 1 e n 12 | printf("%d\n", i); 13 | } 14 | } 15 | } -------------------------------------------------------------------------------- /codice/l11/20220118-pratica-parziale/listaParole.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | char parola[31]; 3 | int frequenza; 4 | } Dato; 5 | 6 | typedef struct nodo { 7 | Dato dato; 8 | struct nodo* next; 9 | } Nodo; 10 | 11 | typedef Nodo* Lista; 12 | 13 | void nuova_lista(Lista *pl); 14 | void aggiorna(Lista *pl, char *s); 15 | void stampa(Lista l); 16 | void elimina_parola(Lista* pl, char* s); -------------------------------------------------------------------------------- /esami/20191119-parziale/turno3/d3.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int h(int n) { 4 | return 1; 5 | } 6 | 7 | int g(int n) { 8 | if (n < 5) return 1; 9 | else return h(n - 2); 10 | } 11 | 12 | int f(int n) { 13 | if (n < 5) return 1; 14 | else return g(n - 2); 15 | } 16 | 17 | int main(void) { 18 | int m; 19 | scanf("%d", &m); 20 | printf("%d\n", f(m)); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/triangolo-rettangolo-senza-ripetizione.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | printf("Inserisci i tre lati\n"); 6 | scanf("%d%d%d", &a, &b, &c); // supponiamo che c sia il più grande 7 | if (!(a * a + b * b == c * c)) // teorema di Pitagora 8 | printf("Non r"); 9 | else 10 | printf("R"); 11 | printf("ettangolo\n"); 12 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi-while.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, somma = 0; 5 | printf("Digita un intero (negativo termina):\n"); 6 | scanf("%d", &numero); 7 | while (numero >= 0) { 8 | somma += numero; 9 | printf("Digita un intero (negativo termina):\n"); 10 | scanf("%d", &numero); 11 | } 12 | printf("La somma e` %d\n", somma); 13 | } -------------------------------------------------------------------------------- /codice/055_sequenze/doppio.c: -------------------------------------------------------------------------------- 1 | main() { 2 | int n, d; 3 | 4 | n = 0; 5 | do { 6 | n = n + 1; 7 | // S1: n assume la sequenza dei valori compresi fra 1 e 10 8 | d = n * 2; 9 | // S2: d assume la sequenza dei doppi dei numeri compresi fra 1 e 10 10 | printf("%d\n", d); 11 | // Output: assume la sequenza dei doppi dei numeri compresi fra 1 e 10 12 | } while (n < 10); 13 | } -------------------------------------------------------------------------------- /codice/060_espressioni/media-int.c: -------------------------------------------------------------------------------- 1 | // scrivere un programma che richiede all'utente due numeri reali e stampa la 2 | // loro media 3 | 4 | // es. input 2.3 2.7, output 2.5 5 | 6 | #include 7 | 8 | main() { 9 | int a, b; 10 | float m; 11 | printf("Inserisci due numeri interi\n"); 12 | scanf("%d%d", &a, &b); 13 | m = ((float)(a + b) / 2); 14 | printf("Media: %f\n", m); 15 | } -------------------------------------------------------------------------------- /codice/090_array/filter.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 10 3 | 4 | main() { 5 | int a[DIM], b[DIM], i, j; 6 | // ... 7 | j = 0; 8 | for (i = 0; i < DIM; i++) 9 | if (/* proprieta` desiderata di a[i] */) { 10 | b[j] = a[i]; 11 | j++; 12 | } 13 | // qui b ha dimensione logica j e contiene 14 | // tutti gli elementi di a con la 15 | // proprieta` desiderata 16 | } -------------------------------------------------------------------------------- /codice/150_progetti_multifile/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | float radq(float a); 5 | 6 | int main(void) { 7 | float a; 8 | printf("Digita un numero\n"); 9 | scanf("%f", &a); 10 | if (a <= 0) { 11 | printf("%f e` negativo o nullo\n", a); 12 | return -1; 13 | } 14 | printf("La radice quadrata di %.2f e` circa %f\n", a, radq(a)); 15 | return 0; 16 | } -------------------------------------------------------------------------------- /codice/045_debugger/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "0.2.0", 3 | "configurations": [ 4 | { 5 | "name": "C++ Launch", 6 | "type": "cppdbg", 7 | "request": "launch", 8 | "program": "${workspaceRoot}/a.out", 9 | "args":[], 10 | "stopAtEntry": false, 11 | "cwd": "${workspaceRoot}" 12 | } 13 | ] 14 | } -------------------------------------------------------------------------------- /codice/045_debugger/.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": "0.2.0", 3 | "configurations": [ 4 | { 5 | "name": "C++ Launch", 6 | "type": "cppdbg", 7 | "request": "launch", 8 | "program": "${workspaceRoot}/a.out", 9 | "args":[], 10 | "stopAtEntry": false, 11 | "cwd": "${workspaceRoot}" 12 | } 13 | ] 14 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/20190222-t1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int f(int d); 4 | 5 | void g(int a[]) { 6 | int i; 7 | for (i = 0; i < 3; i++) 8 | *(a + f(a[f(i)])) = f(i); 9 | } 10 | 11 | int main(int argc, char* argv[]) { 12 | int i, a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 13 | g(a); 14 | for (i = 0; i < 10; i++) 15 | printf("%d ", a[i]); 16 | printf("\n"); 17 | return 0; 18 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/lista-ordinata/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "lista.h" 4 | 5 | int main() { 6 | Lista l; 7 | int numero; 8 | nuova(&l); 9 | 10 | while (!piena(&l)) { 11 | printf("Inserisci un intero\n"); 12 | scanf("%d", &numero); 13 | if (numero <= 0) 14 | break; 15 | ins_ord(&l, numero); 16 | } 17 | 18 | stampa(l); 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /codice/055_sequenze/numeri-pari.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i; 5 | for (i = 1; // init 6 | i <= 20; // cond 7 | i++ // update 8 | ) { 9 | // S1: valori assunti da i, tutti quelli fra 1 e 20 10 | if (i % 2 == 0) { 11 | // S2: i assume i valori pari fra 1 e 20 12 | printf("%d\n", i); 13 | // output: i valori pari fra 1 e 20 14 | } 15 | } 16 | } -------------------------------------------------------------------------------- /codice/090_array/stampa-ordine.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int main(void) { 5 | int m, a[DIM], dl, i, j; 6 | 7 | for (dl = 0; dl < DIM; dl++) { 8 | scanf("%d", &m); 9 | j = dl; 10 | while (j > 0 && m < a[j - 1]) { 11 | a[j] = a[j - 1]; 12 | j--; 13 | } 14 | a[j] = m; 15 | } 16 | for (i = 0; i < dl; i++) 17 | printf("%d ", a[i]); 18 | printf("\n"); 19 | } -------------------------------------------------------------------------------- /codice/110_puntatori/variabile-configurabile.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int a, b; 5 | char ch; 6 | int* p; 7 | printf("a o b?\n"); scanf("%c", &ch); 8 | if (ch == 'a') 9 | p = &a; 10 | else 11 | p = &b; 12 | a = 1; b = 2; 13 | // *p (stessa espressione) coincide con a oppure con b; 14 | // si decide a tempo di esecuzione 15 | printf("%d\n", *p); 16 | return 0; 17 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/calorie/listaAlimento.h: -------------------------------------------------------------------------------- 1 | #define DIMENSIONE 1000 2 | 3 | // record 4 | typedef struct { 5 | char nome[31]; 6 | float calorie; // 100 grammi dell'alimento 7 | } Alimento; 8 | 9 | typedef struct { 10 | int n_elementi; 11 | Alimento dati[DIMENSIONE]; 12 | } Lista; 13 | 14 | void caricaCalorie(char nomeFileBinario[], Lista *pl); 15 | float calorieAlimento(char nomeAlimento[], Lista l); -------------------------------------------------------------------------------- /codice/230_liste_collegate/esempio1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef int *PuntatoreAIntero; 4 | 5 | int main() { 6 | int* p1; 7 | int* p2; 8 | int* p3; 9 | PuntatoreAIntero indirizzi[mk; 10 | 11 | 12 | indirizzi[0] = (int*)malloc(sizeof(int)); 13 | *(indirizzi[0]) = 2; 14 | p2 = (int*)malloc(sizeof(int)); 15 | *p2 = 3; 16 | p3 = (int*)malloc(sizeof(int)); 17 | *p3 = 5; 18 | free(p2); 19 | } -------------------------------------------------------------------------------- /codice/l03/divisori-v2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n, i; 5 | printf("Inserisci un numero naturale\n"); 6 | scanf("%d", &n); 7 | for (i = 1; i <= n/2; i++) { 8 | // S1 : i assume valori compresi fra 1 e n 9 | if (n % i == 0) 10 | { 11 | // output: i assume i valori divisori di n compresi fra 1 e n 12 | printf("%d\n", i); 13 | } 14 | } 15 | printf("%d\n", n); 16 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/triangolo-con-connettivi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | printf("Inserisci i tre lati\n"); 6 | scanf("%d%d%d", &a, &b, &c); 7 | if (a == b && a == c) 8 | printf("Equilatero\n"); 9 | if ((a == b && a != c) || (a == c && a != b) || (b == c && a != b)) 10 | printf("Isoscele\n"); 11 | if (a != b && a != c && b != c) 12 | printf("Scaleno\n"); 13 | } -------------------------------------------------------------------------------- /codice/090_array/insertion-sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int main(void) { 5 | int a[] = {4, 1, 8, 0, 5}, i, dlo; 6 | 7 | for (dlo = 0; dlo < DIM; dlo++) { 8 | int j = dlo, m = a[dlo]; 9 | while (j > 0 && m < a[j - 1]) { 10 | a[j] = a[j - 1]; 11 | j--; 12 | } 13 | a[j] = m; 14 | } 15 | for (i = 0; i < DIM; i++) 16 | printf("%d ", a[i]); 17 | printf("\n"); 18 | } -------------------------------------------------------------------------------- /codice/090_array/ricerca-elemento.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int main() { 5 | int a[] = {4, 3, 8, 5, 1}; 6 | int trovato = 0, i, elemento; 7 | 8 | scanf("%d", &elemento); 9 | i = 0; 10 | while (!trovato && i < DIM) 11 | if (a[i] == elemento) 12 | trovato = 1; 13 | else 14 | i++; 15 | if (trovato) 16 | printf("Elemento trovato all'indice %d\n", i); 17 | return 0; 18 | } -------------------------------------------------------------------------------- /codice/090_array/stampa-array-inizializzato.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int main() { 5 | float a[] = {2.4, 1.0, -3.4, 5.6, 6 | 2.7}; // definire e inizializzare un array di 5 elementi 7 | int i; 8 | // stampa di tutti gli elementi dell'array 9 | 10 | for (i = 0; i < DIM; i++) 11 | // i varia su tutti gli indici validi 12 | printf("%f\n", a[i]); 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /tutorato/tutorato_03/piramide.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int rows, i, j, space; 5 | 6 | printf("Inserire il numero di righe\n"); 7 | scanf("%d", &rows); 8 | 9 | for(i=rows; i>= 1; i--){ 10 | for(space=0; space < rows-i; ++space) 11 | printf(" "); 12 | for(j=0; j<= 2*(i-1); ++j) 13 | printf("* "); 14 | printf("\n"); 15 | } 16 | 17 | 18 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/pin-do-2.c: -------------------------------------------------------------------------------- 1 | // ERRATO 2 | 3 | #include 4 | 5 | main() { 6 | int pin; 7 | int n_tentativi = 0; // numero tentativi effettuati 8 | if (pin != 44122) 9 | do { 10 | scanf("%d", &pin); 11 | n_tentativi++; 12 | } while (n_tentativi < 13 | 3); // l'utente ha sbagliato e ha tentato meno di 3 volte 14 | else 15 | printf("Accesso negato\n"); 16 | } 17 | -------------------------------------------------------------------------------- /codice/070_funzioni/logo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int scelta; 5 | printf("*** Rubrica ***\n"); 6 | printf("1. Tizio 335-1234567\n"); 7 | printf("2. Caio 347-1234567\n"); 8 | printf("Scegliere un contatto\n"); 9 | scanf("%d", &scelta); 10 | if (scelta > 0) { 11 | printf("*** Rubrica ***\n"); 12 | printf("Chiamata del contatto %d in corso\n", scelta); 13 | } 14 | printf("Fine\n"); 15 | } -------------------------------------------------------------------------------- /codice/090_array/inserimento-ordinato.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int main(void) { 5 | int m, a[DIM], dl, j; 6 | 7 | for (dl = 0; dl < DIM; i++) { 8 | scanf("%d", &m); 9 | j = dl; 10 | while (j > 0 && /* m precede a[j-1] secondo il criterio usato*/) { 11 | a[j] = a[j - 1]; 12 | j--; 13 | } 14 | a[j] = m; 15 | } 16 | // l'array e` ordinato secondo il criterio usato 17 | } -------------------------------------------------------------------------------- /codice/110_puntatori/ordina-due.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void swap(int* pm, int* pn) { 4 | int t = *pm; 5 | *pm = *pn; 6 | *pn = t; 7 | } 8 | 9 | void ordina2(int* pm, int* pn) { 10 | if (*pm > *pn) 11 | swap(pm, pn); 12 | } 13 | 14 | int main() { 15 | int a, b; 16 | scanf("%d%d", &a, &b); 17 | ordina2(&a, &b); 18 | printf("%d %d\n", a, b); // stampa numeri in ordine crescente 19 | return 0; 20 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/rubrica-pin.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin, scelta; 5 | scanf("%d", &pin); 6 | if (pin == 44122) 7 | printf("Accesso consentito\n"); 8 | printf("1. Tizio 335-1234567\n"); 9 | printf("2. Caio 347-1234567\n"); 10 | printf("Scegliere un contatto\n"); 11 | scanf("%d", &scelta); 12 | printf("Chiamata al contatto %d in corso\n", scelta); 13 | printf("Fine\n"); 14 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/elimTutti.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | #include "elimTesta.h" 4 | 5 | Lista* ricerca(Lista* pl, int d) { 6 | while (*pl) { 7 | if ((*pl)->dato == d) 8 | break; 9 | pl = &(*pl)->next; 10 | } 11 | return pl; 12 | } 13 | 14 | void elimTutti(Lista* pl, int d) { 15 | while (*pl) { 16 | pl = ricerca(pl, d); 17 | if (*pl) 18 | elimTesta(pl); 19 | } 20 | } -------------------------------------------------------------------------------- /codice/l10/20170130/listaCalorie.h: -------------------------------------------------------------------------------- 1 | #define DIM 1000 2 | 3 | typedef struct{ 4 | char nome[31]; 5 | float calorie100grammi; 6 | } Record; 7 | 8 | // interfaccia lista sequenziale di Record 9 | typedef struct { 10 | Record dati[DIM]; 11 | int n_elementi; 12 | } Lista; 13 | 14 | void lista_vuota(Lista *pl); 15 | int piena(Lista l); 16 | void insCoda(Lista *pl, Record r); 17 | float calorie100grammi(Lista l, char nome[]); -------------------------------------------------------------------------------- /codice/230_liste_collegate/calorie/listaAlimento.h: -------------------------------------------------------------------------------- 1 | #define DIMENSIONE 1000 2 | 3 | // record 4 | typedef struct { 5 | char nome[31]; 6 | float calorie; // 100 grammi dell'alimento 7 | } Dato; 8 | 9 | typedef struct nodo { 10 | Dato dato; 11 | struct nodo* next; 12 | } Nodo; 13 | 14 | typedef Nodo* Lista; 15 | 16 | void caricaCalorie(char nomeFileBinario[], Lista* pl); 17 | float calorieAlimento(char nomeAlimento[], Lista l); -------------------------------------------------------------------------------- /codice/230_liste_collegate/elim1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tipi.h" 3 | #include "elimTesta.h" 4 | 5 | Lista* ricerca(Lista* pl, int d) { 6 | while (*pl) { 7 | if ((*pl)->dato == d) 8 | break; 9 | pl = &(*pl)->next; 10 | } 11 | return pl; 12 | } 13 | 14 | int elim1(Lista* pl, int d) { 15 | pl = ricerca(pl, d); 16 | if (*pl) { 17 | elimTesta(pl); 18 | return 1; 19 | } else 20 | return 0; 21 | } -------------------------------------------------------------------------------- /codice/070_funzioni/rettangolo-di-asterischi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // stampa un numero n di asterischi 4 | riga(int numero_colonne) { 5 | int j; 6 | for (j = 1; j <= numero_colonne; j++) 7 | printf("*"); 8 | printf("\n"); 9 | } 10 | 11 | main() { 12 | int m, n; 13 | int i; 14 | printf("Inserisci i numeri di righe e colonne\n"); 15 | scanf("%d%d", &m, &n); 16 | for (i = 1; i <= m; i++) 17 | riga(n); 18 | } 19 | -------------------------------------------------------------------------------- /esami/20200122-parziale/turno1/listaVeicoli.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | char targa[8]; 3 | float durata; 4 | } Accesso; 5 | 6 | typedef struct { 7 | char targa[8]; 8 | int accessi; 9 | } Veicolo; 10 | 11 | typedef struct nodo { 12 | Veicolo dato; 13 | struct nodo *next; 14 | } Nodo; 15 | 16 | typedef Nodo *Lista; 17 | 18 | void nuovaLista(Lista* pl); 19 | void aggiorna(Lista* pl, char targa[]); 20 | void stampaImporti(Lista l); -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/giorno-settimana-if.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int jd = 1234567; 5 | 6 | if (jd % 7 == 0) printf("Lunedi`\n"); 7 | else if (jd % 7 == 1) printf("Martedi`\n"); 8 | else if (jd % 7 == 2) printf("Mercoledi`\n"); 9 | else if (jd % 7 == 3) printf("Giovedi`\n"); 10 | else if (jd % 7 == 4) printf("Venerdi`\n"); 11 | else if (jd % 7 == 5) printf("Sabato\n"); 12 | else printf("Domenica\n"); 13 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/rubrica-pin-blocco.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin, scelta; 5 | scanf("%d", &pin); 6 | if (pin == 44122) { 7 | printf("Accesso consentito\n"); 8 | printf("1. Tizio 335-1234567\n"); 9 | printf("2. Caio 347-1234567\n"); 10 | printf("Scegliere un contatto\n"); 11 | scanf("%d", &scelta); 12 | printf("Chiamata al contatto %d\n", scelta); 13 | } 14 | printf("Fine\n"); 15 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/rubrica-pin-else.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin, scelta; 5 | scanf("%d", &pin); 6 | if (pin != 44122) 7 | printf("Fine\n"); 8 | else 9 | printf("Accesso consentito\n"); 10 | printf("1. Tizio 335-1234567\n"); 11 | printf("2. Caio 347-1234567\n"); 12 | printf("Scegliere un contatto\n"); 13 | scanf("%d", &scelta); 14 | printf("Chiamata al contatto %d in corso\n", scelta); 15 | } -------------------------------------------------------------------------------- /codice/090_array/cinque-a1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int numeri[5]; 5 | scanf("%d", &numeri[0]); 6 | scanf("%d", &numeri[1]); 7 | scanf("%d", &numeri[2]); 8 | scanf("%d", &numeri[3]); 9 | scanf("%d", &numeri[4]); 10 | 11 | printf("%d\n", numeri[4]); 12 | printf("%d\n", numeri[3]); 13 | printf("%d\n", numeri[2]); 14 | printf("%d\n", numeri[1]); 15 | printf("%d\n", numeri[0]); 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /codice/l11/20170130-pratica-totale/listaCalorie.h: -------------------------------------------------------------------------------- 1 | #define DIM 1000 2 | 3 | typedef struct{ 4 | char nome[31]; 5 | float calorie100grammi; 6 | } Record; 7 | 8 | // interfaccia lista sequenziale di Record 9 | typedef struct { 10 | Record dati[DIM]; 11 | int n_elementi; 12 | } Lista; 13 | 14 | void lista_vuota(Lista *pl); 15 | int piena(Lista l); 16 | void insCoda(Lista *pl, Record r); 17 | float calorie100grammi(Lista l, char nome[]); -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/bimbum.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n; // variabile di S1 = [1..100] 5 | for (n = 1; n <= 100; n++) { 6 | // n assume i valori fra 1 e 100 7 | if (n % 3 == 0 && n % 5 == 0) 8 | printf("bimbum "); 9 | else if (n % 3 == 0) 10 | printf("bim "); 11 | else if (n % 5 == 0) 12 | printf("bum "); 13 | else 14 | printf("%d ", n); 15 | } 16 | printf("\n"); 17 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/bimbum2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n; // variabile di S1 = [1..100] 5 | for (n = 1; n <= 100; n++) { 6 | // n assume i valori fra 1 e 100 7 | if (n % 3 != 0 && n % 5 != 0) 8 | printf("%d ", n); 9 | else { 10 | if (n % 3 == 0) 11 | printf("bim"); 12 | if (n % 5 == 0) 13 | printf("bum"); 14 | printf(" "); 15 | } 16 | } 17 | printf("\n"); 18 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/rubrica-pin-salto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin, scelta; 5 | scanf("%d", &pin); 6 | if (pin != 44122) 7 | goto fine; 8 | printf("Accesso consentito\n"); 9 | printf("1. Tizio 335-1234567"); 10 | printf("2. Caio 347-1234567"); 11 | printf("Scegliere un contatto\n"); 12 | scanf("%d", &scelta); 13 | printf("Chiamata al contatto %d\n", scelta); 14 | fine: 15 | printf("Fine\n"); 16 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/triangolo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int a, b, c; 5 | printf("Inserisci i tre lati\n"); 6 | scanf("%d%d%d", &a, &b, &c); 7 | if (a == b) 8 | if (a == c) 9 | printf("Equilatero\n"); 10 | else 11 | printf("Isoscele\n"); 12 | else if (a == c) 13 | printf("Isoscele\n"); 14 | else if (b == c) 15 | printf("Isoscele\n"); 16 | else 17 | printf("Scaleno\n"); 18 | } 19 | -------------------------------------------------------------------------------- /codice/200_adt/contatore-adt/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // main.c è client dell'ADT contatore 4 | // e ne include l'interfaccia 5 | #include "contatore.h" 6 | 7 | int main() { 8 | Contatore c; // istanza dell'ADT Contatore 9 | Contatore c2; 10 | Contatore contatori[100]; 11 | inizializza(&c); 12 | stampa(c); 13 | incrementa(&c); 14 | incrementa(&c); 15 | stampa(c); 16 | inizializza(&c2); 17 | stampa(c2); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/uscita-doppio-flag.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i, j; 5 | 6 | int finito = 0; // flag 7 | for (i = 1; !finito && i <= 10; i++) { 8 | for (j = 1; !finito && j <= 10; j++) { 9 | printf("%3d ", i * j); 10 | if (i * j > 50) 11 | finito = 1; // flag diventa vero quando abbiamo stampato un numero maggiore di 50 12 | } 13 | printf("\n"); 14 | } 15 | printf("Finito\n"); 16 | } -------------------------------------------------------------------------------- /codice/155_make/radice_quadrata/Makefile: -------------------------------------------------------------------------------- 1 | eseguibile: main.o funzioni-aritmetiche.o radice-quadrata.o 2 | gcc -o eseguibile main.o funzioni-aritmetiche.o radice-quadrata.o -lm 3 | 4 | # entry 5 | main.o: main.c funzioni-aritmetiche.h radice-quadrata.h 6 | gcc -c main.c 7 | 8 | funzioni-aritmetiche.o: funzioni-aritmetiche.c 9 | gcc -c funzioni-aritmetiche.c 10 | 11 | radice-quadrata.o: radice-quadrata.c funzioni-aritmetiche.h 12 | gcc -c radice-quadrata.c -------------------------------------------------------------------------------- /codice/230_liste_collegate/ricerca.c: -------------------------------------------------------------------------------- 1 | #include "tipi.h" 2 | 3 | Lista* ricerca(Lista* pl, Dato d) { 4 | // finche' la lista ha elementi 5 | while (*pl) { 6 | // se l'elemento corrente ha la proprieta` desiderata 7 | if ((*pl)->dato == d) 8 | // esco 9 | break; 10 | // altrimenti passo all'elemento successivo 11 | pl = &(*pl)->next; 12 | } 13 | // qui l e` l'indirizzo della lista desiderata, o di quella vuota 14 | return pl; 15 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/seq/20170622/listino.h: -------------------------------------------------------------------------------- 1 | #define DIM 100 2 | 3 | typedef struct { 4 | int codice; 5 | int contatore; 6 | } Dato; 7 | 8 | typedef struct { 9 | int n_elementi; 10 | Dato dati[DIM]; 11 | } Lista; 12 | 13 | typedef struct { 14 | char descrizione[30]; 15 | float prezzo; 16 | } VoceListino; 17 | 18 | void nuovaLista(Lista* pl); 19 | void registraConsumazione(Lista* pl, int codice); 20 | void scontrino(Lista l, VoceListino listino[]); -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/giorno-settimana-switch.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int jd = 123456; 5 | 6 | switch (jd % 7) { 7 | case 0: printf("Lunedi`\n"); break; 8 | case 1: printf("Martedi`\n"); break; 9 | case 2: printf("Mercoledi`\n"); break; 10 | case 3: printf("Giovedi`\n"); break; 11 | case 4: printf("Venerdi`\n"); break; 12 | case 5: printf("Sabato\n"); break; 13 | default: printf("Domenica\n"); break; 14 | } 15 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/pin-do.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin; 5 | int n_tentativi = 0; // numero tentativi effettuati 6 | do { 7 | scanf("%d", &pin); 8 | n_tentativi++; 9 | } while (pin != 44122 && 10 | n_tentativi < 11 | 3); // l'utente ha sbagliato e ha tentato meno di 3 volte 12 | if (pin == 44122) 13 | printf("Accesso consentito\n"); 14 | else 15 | printf("Accesso negato\n"); 16 | } 17 | -------------------------------------------------------------------------------- /tutorato/tutorato_01/divisibili.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int a, b; 5 | 6 | printf("Inserire due numeri:\n\ta: "); 7 | scanf("%d", &a); 8 | printf("\tb: "); 9 | scanf("%d", &b); 10 | 11 | if(b!=0 && a%b == 0) 12 | printf("%d è divisibile per %d\n",a,b); 13 | else if(a!= 0 && b%a == 0) 14 | printf("%d è divisibile per %d\n",b,a); 15 | else 16 | printf("I due numeri non sono divisibili\n"); 17 | } -------------------------------------------------------------------------------- /codice/095_stringhe/compare.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 20 3 | int main() { 4 | char s[DIM], c; 5 | char input[2]; 6 | int i; 7 | int trovato; 8 | scanf("%s", s); 9 | 10 | scanf("%s", input); 11 | c = input[0]; 12 | 13 | trovato = 0; 14 | i = 0; 15 | while (!trovato && s[i] != '\0') { 16 | if (s[i] == c) 17 | trovato = 1; 18 | i++; 19 | } 20 | 21 | if (trovato) 22 | printf("si\n"); 23 | else 24 | printf("no\n"); 25 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/reverse/main.c: -------------------------------------------------------------------------------- 1 | // Client ADT Lista 2 | 3 | #include 4 | 5 | #include "lista.h" 6 | 7 | int main(){ 8 | Lista l1,l2; 9 | nuovaLista(&l1); 10 | insTesta(&l1, 1.5); 11 | insTesta(&l1, 0.7); 12 | insTesta(&l1,-2.3); 13 | // l1 = [-2.3, 0.7, 1.5] 14 | reverse(l1,&l2); 15 | printf("Lista originale:\n"); 16 | stampa(l1); 17 | printf("Lista inversa:\n"); 18 | stampa(l2); 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /tutorato/tutorato_05/num_perfetti.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int sommaDivisori(int numero){ 4 | int somma=0; 5 | int i; 6 | 7 | for(i=1; i<=numero/2; i++){ 8 | if(numero%i==0){ 9 | somma=somma+i; 10 | } 11 | } 12 | 13 | return somma; 14 | } 15 | 16 | int main(){ 17 | int i; 18 | 19 | for(i=1;i<=100;i++){ 20 | if(i==sommaDivisori(i)) 21 | printf("%d\n",i); 22 | } 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /codice/200_adt/contatore-adt/contatore.c: -------------------------------------------------------------------------------- 1 | // ADT Contatore -Implementazione 2 | 3 | #include 4 | 5 | // Inclusione dell'interfaccia 6 | #include "contatore.h" 7 | 8 | 9 | // Implementazione delle operazioni 10 | void inizializza(Contatore *pc) { 11 | *pc = 0; 12 | } 13 | 14 | void incrementa(Contatore *pc) { 15 | (*pc)++; 16 | } 17 | 18 | void decrementa(Contatore *pc) { 19 | (*pc)--; 20 | } 21 | 22 | void stampa(Contatore c) { 23 | printf("%d\n", c); 24 | } -------------------------------------------------------------------------------- /codice/l05/potenza-v2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | float potenza(float base, int esp) { 4 | int cont; 5 | float prod; 6 | prod = 1.0; 7 | for (cont = 0; cont < (esp < 0 ? -esp : esp); cont++) 8 | prod *= base; 9 | return esp >= 0 ? prod : 1.0 / prod; 10 | } 11 | 12 | int main() { 13 | int e; 14 | float b; 15 | printf("Inserisci base (reale) ed esponente (intero con segno)\n"); 16 | scanf("%f%d", &b, &e); 17 | printf("%f\n", potenza(b, e)); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /tutorato/tutorato_03/numero_perfetto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int div_sum,i,j; 5 | 6 | div_sum=0; 7 | 8 | for(i=2;i<1000;i++){ 9 | 10 | for(j=1;j<=i/2;j++){ 11 | if(i%j==0) 12 | div_sum = div_sum+j; 13 | } 14 | 15 | if(div_sum == i) 16 | printf("%d è un numero perfetto\n",i); 17 | // else 18 | // printf("%d non è un numero perfetto\n",i); 19 | div_sum=0; 20 | } 21 | 22 | } -------------------------------------------------------------------------------- /codice/055_sequenze/prodotto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n; 5 | int i; 6 | int a; 7 | 8 | a = 1; // v0 9 | for (i = 1; i <= 5; i++) { 10 | // i assume i valori fra 1 e 5 11 | scanf("%d", &n); 12 | // S1: n assume i 5 valori di input 13 | a = a * n; // aggiornamento dell'accumulatore 14 | // a assume i valori dei prodotti dei numeri finora inseriti 15 | } 16 | // in a c'è il prodotto dei 5 numeri inseriti 17 | printf("Prodotto: %d\n", a); 18 | } -------------------------------------------------------------------------------- /codice/l11/20220131-pratica-totale/listaEsami.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int matricola; 3 | int voto_pratico; 4 | int voto_teorico; 5 | } Dato; 6 | 7 | typedef struct nodo { 8 | Dato dato; 9 | struct nodo* next; 10 | } Nodo; 11 | 12 | typedef Nodo* Lista; 13 | 14 | typedef struct { 15 | int matricola; 16 | int voto; 17 | char tipo; 18 | } Record; 19 | 20 | void nuova_lista(Lista* pl); 21 | void aggiorna(Lista* pl, Record r); 22 | void stampa(Lista l); 23 | Lista insertionSort(Lista l); -------------------------------------------------------------------------------- /tutorato/tutorato_05/area_perimetro.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int perimetro(int a, int b, int c){ 4 | return a+b+c; 5 | 6 | } 7 | 8 | float area(int a, int b, int c){ 9 | float p = perimetro(a,b,c)/2.0; 10 | 11 | return p*(p-a)*(p-b)*(p-c); 12 | } 13 | 14 | int main(){ 15 | int a,b,c; 16 | 17 | printf("Inserire 3 numeri\n"); 18 | scanf("%d %d %d", &a,&b,&c); 19 | 20 | printf("Perimetro: %d\n", perimetro(a,b,c)); 21 | printf("Area: %.2f\n", area(a,b,c)); 22 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/listaCollegata.h: -------------------------------------------------------------------------------- 1 | typedef int Dato; 2 | typedef struct nodo { 3 | Dato dato; 4 | struct nodo* next; 5 | } Nodo; 6 | typedef Nodo* Lista; 7 | 8 | void nuovaLista(Lista* pl); 9 | int vuota(Lista l); 10 | int piena(Lista l); 11 | void insTesta(Lista* pl, int numero); 12 | void insOrd(Lista* pl, int numero); 13 | int ricerca(Lista l, int numero); 14 | void elim1(Lista* pl, int numero); 15 | void elimTutti(Lista *pl, int numero); 16 | int lunghezza(Lista l); 17 | void stampa(Lista l); -------------------------------------------------------------------------------- /codice/l03/terne-pitagoriche.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int m; 5 | int a, b, c; 6 | int cont; 7 | printf("Inserisci l'ipotenusa massima\n"); 8 | scanf("%d", &m); 9 | cont = 0; 10 | for (a = 1; a <= m; a++) 11 | for (b = a + 1; b <= m; b++) 12 | for (c = b + 1; c <= m; c++) { 13 | cont++; 14 | if (a * a + b * b == c * c) // la terna è pitagorica 15 | printf("%d %d %d\n", a, b, c); 16 | } 17 | printf("%d terne testate\n", cont); 18 | } -------------------------------------------------------------------------------- /codice/l07/minimo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | int valore_assoluto(int n) { 5 | return n < 0 ? -n : n; 6 | } 7 | 8 | int main() { 9 | int a[DIM], i; 10 | int m; // accumulatore dell'indice dell'elemento di valore assoluto minimo 11 | 12 | // input 13 | for (i = 0; i < DIM; i++) 14 | scanf("%d", &a[i]); 15 | 16 | m = 0; 17 | for (i = 1; i < DIM; i++) 18 | m = valore_assoluto(a[i]) < valore_assoluto(a[m]) ? i : m; 19 | 20 | printf("%d\n", a[m]); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /esami/20200122-parziale/turno2/listaCani.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int chip; 3 | char vaccino; 4 | } Vaccino; 5 | 6 | typedef struct { 7 | int chip; 8 | int cimurro; 9 | int epatite; 10 | int parvovirosi; 11 | } Cane; 12 | 13 | typedef struct nodo { 14 | Cane dato; 15 | struct nodo *next; 16 | } Nodo; 17 | 18 | typedef Nodo *Lista; 19 | 20 | void nuovaLista(Lista* pl); 21 | void aggiorna(Lista* pl, Vaccino v); 22 | void stampaVacciniMancanti(Lista l); 23 | void stampaVaccinati(Lista l); -------------------------------------------------------------------------------- /tutorato/tutorato_04/pi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int i, numIterazioni; 5 | 6 | float piValue=0; 7 | 8 | printf("Indicare il numero di iterazioni:\n"); 9 | scanf("%d",&numIterazioni); 10 | 11 | for(i=0; i 2 | 3 | main() { 4 | int pin, scelta; 5 | scanf("%d", &pin); 6 | if (pin == 44122) printf("Accesso consentito\n"); 7 | if (pin == 44122) printf("1. Tizio 335-1234567\n"); 8 | if (pin == 44122) printf("2. Caio 347-1234567\n"); 9 | if (pin == 44122) printf("Scegliere un contatto"); 10 | if (pin == 44122) scanf("%d", &scelta); 11 | if (pin == 44122) 12 | printf("Chiamata al contatto %d\n", scelta); 13 | printf("Fine\n"); 14 | } -------------------------------------------------------------------------------- /tutorato/tutorato_04/pi_v2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int i, numIterazioni,denominatore=1,numeratore=1; 5 | 6 | float piValue=0; 7 | 8 | printf("Indicare il numero di iterazioni:\n"); 9 | scanf("%d",&numIterazioni); 10 | 11 | for(i=0;i 2 | #include 3 | 4 | typedef struct { 5 | char nome[10]; 6 | float stipendio; 7 | } Impiegato; 8 | 9 | int main() { 10 | FILE* pfb; 11 | Impiegato im; 12 | pfb = fopen("stipendi.dat", "rb"); 13 | if (pfb == NULL) { 14 | printf("Errore apertura\n"); 15 | exit(1); 16 | } 17 | while (fread(&im, sizeof(Impiegato), 1, pfb) == 1) { 18 | printf("%s %.2f\n", im.nome, im.stipendio); 19 | } 20 | fclose(pfb); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /codice/l05/potenza-v3.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | float potenza(float base, int esp) { 4 | int cont; 5 | float prod; 6 | prod = 1.0; 7 | if (esp < 0) { 8 | esp = -esp; 9 | base = 1.0 / base; 10 | } 11 | for (cont = 0; cont < esp; cont++) 12 | prod *= base; 13 | return prod; 14 | } 15 | 16 | int main() { 17 | int e; 18 | float b; 19 | printf("Inserisci base (reale) ed esponente (intero con segno)\n"); 20 | scanf("%f%d", &b, &e); 21 | printf("%f\n", potenza(b, e)); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /tutorato/tutorato_03/algoritmo_euclideo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int a, b, r, magg, min; 5 | 6 | printf("Inserire due numeri interi\n"); 7 | scanf("%d %d",&a,&b); 8 | 9 | if(a>b){ 10 | magg=a; 11 | min=b; 12 | } 13 | else{ 14 | magg=b; 15 | min=a; 16 | } 17 | 18 | while(min!=0){ 19 | r=magg%min; 20 | magg=min; 21 | min=r; 22 | } 23 | 24 | printf("mcd(%d,%d)=%d\n",a,b,magg); 25 | 26 | } -------------------------------------------------------------------------------- /tutorato/tutorato_03/palindromo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int n, num; 5 | int reversed, digit; 6 | 7 | printf("Inserire un numero\n"); 8 | scanf("%d", &n); 9 | 10 | num =n; 11 | reversed = 0; 12 | 13 | while(num>0){ 14 | digit = num %10; 15 | reversed = reversed * 10 +digit; 16 | num= num/10; 17 | } 18 | 19 | if(n==reversed) 20 | printf("%d è palindromo",n); 21 | else 22 | printf("%d non è palindromo",n); 23 | } 24 | 25 | -------------------------------------------------------------------------------- /codice/100_strutture_typedef_enum/paga.c: -------------------------------------------------------------------------------- 1 | typedef enum { Lun= 1, Mar, Mer, Gio, Ven, Sab, Dom } Giorni; 2 | 3 | int main() { 4 | Giorni giorno; 5 | float pagaOraria = 15.4; 6 | float paga[7], ore[7] = {8.0, 7.5, 0.0, 4.5, 6.0, 8.0, 8.0}; 7 | for (giorno = Lun; giorno <= Dom; giorno++) { 8 | int indice = giorno - Lun; 9 | if ((giorno == Sab) || (giorno == Dom)) 10 | paga[indice] = ore[indice] * pagaOraria * 1.5; 11 | else 12 | paga[indice] = ore[indice] * pagaOraria; 13 | } 14 | return 0; 15 | } -------------------------------------------------------------------------------- /codice/055_sequenze/quadrati-dei-numeri-pari.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int i; 5 | for (i = 1; // init 6 | i <= 20; // cond 7 | i++ // update 8 | ) { 9 | // S1: valori assunti da i, tutti quelli fra 1 e 20 10 | if (i % 2 == 0) { 11 | // S2: i assume i valori pari fra 1 e 20 12 | // S3: i * i assume i quadrati dei numeri pari fra 1 e 20 13 | printf("%d\n", i * i); 14 | // output: map(printf, S3) i quadrati valori pari fra 1 e 20 15 | } 16 | } 17 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/insTesta.c: -------------------------------------------------------------------------------- 1 | void insTesta(Lista* pl, int numero) { 2 | int i; 3 | if (piena(*pl)) { 4 | // se la lista e' piena non posso inserire elementi 5 | printf("Errore: lista piena\n"); 6 | exit(-1); 7 | } 8 | // faccio spazio per il nuovo numero spostando gli altri a destra 9 | for (i = pl->n_elementi; i > 0; i--) 10 | pl->dati[i] = pl->dati[i - 1]; 11 | // inserisco il nuovo numero 12 | pl->dati[0] = numero; 13 | // incremento la dimensione logica 14 | pl->n_elementi++; 15 | } -------------------------------------------------------------------------------- /codice/220_allocazione_dinamica/stringa-dinamica.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | char *alloca_stringa(int n){ 6 | char *indirizzo= (char*)malloc(n*sizeof(char)); 7 | return indirizzo; 8 | } 9 | 10 | 11 | // ERRATO 12 | // char *alloca_stringa_locale(){ 13 | // char s[80]; 14 | // return s; 15 | // } 16 | 17 | int main(){ 18 | char *s; 19 | s = alloca_stringa(80); 20 | scanf("%s", s); 21 | printf("%d\n", strlen(s)); 22 | free(s); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /esami/20191119-parziale/turno1/d1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int primo(int n) { 4 | int i, potenzialmente_primo; 5 | potenzialmente_primo = n % 2 || n == 2; 6 | i = 3; 7 | while (potenzialmente_primo && i * i <= n) { 8 | if (n % i == 0) 9 | potenzialmente_primo = 0; 10 | i += 2; 11 | } 12 | return potenzialmente_primo; 13 | } 14 | 15 | int main(void) { 16 | int i, cont = 0; 17 | for (i = 2; i < 1000000; i++) 18 | if (primo(i)) 19 | cont++; 20 | printf("%d\n", cont); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /codice/130_file_di_testo/stampa.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | FILE* pf; 6 | char nome[80]; 7 | char c; 8 | printf("Inserisci il nome del file\n"); 9 | scanf("%s", nome); 10 | pf = fopen(nome, "rt"); 11 | if (pf == NULL) { 12 | printf("Errore apertura file %s\n", nome); 13 | exit(1); 14 | } 15 | 16 | while (fscanf(pf, "%c", &c) == 1) 17 | printf("%c", c); 18 | 19 | if (fclose(pf) != 0) { 20 | printf("Errore chiusura file %s\n", nome); 21 | exit(2); 22 | } 23 | } -------------------------------------------------------------------------------- /codice/070_funzioni/subroutine-funzione.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void logo(void) { 4 | printf("###############\n"); 5 | printf("# Rubrica #\n"); 6 | printf("###############\n"); 7 | } 8 | 9 | int main(void) { 10 | int scelta; 11 | 12 | logo(); 13 | printf("1. Tizio 335-1234567\n"); 14 | printf("2. Caio 347-1234567\n"); 15 | printf("Scegliere un contatto\n"); 16 | scanf("%d", &scelta); 17 | 18 | logo(); 19 | printf("Chiamata del contatto %d in corso\n", scelta); 20 | 21 | printf("Fine\n"); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/elimTutti.c: -------------------------------------------------------------------------------- 1 | void elimTutti(Lista* pl, int numero) { 2 | int i = 0; 3 | while (i < pl->n_elementi) // scorro tutti gli elementi 4 | { 5 | // se ne trovo uno uguale al numero da eliminare... 6 | if (pl->dati[i] == numero) { 7 | int j; 8 | // sposto a sinistra tutti gli elementi che lo seguono 9 | for (j = i; j < pl->n_elementi - 1; j++) 10 | pl->dati[j] = pl->dati[j + 1]; 11 | pl->n_elementi--; // decremento la dimensione logica 12 | } else 13 | i++; 14 | } 15 | } -------------------------------------------------------------------------------- /codice/l05/potenza-v4.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | float potenza(float base, int esp) { 4 | int i; 5 | float prod = 1.0; 6 | if (esp > 0) { 7 | for (i = 0; i < esp; i++) { 8 | prod = prod * base; 9 | } 10 | } else { 11 | for (i = 0; i > esp; i--) { 12 | prod = prod / base; 13 | } 14 | } 15 | return prod; 16 | } 17 | 18 | int main() { 19 | int e; 20 | float b; 21 | printf("inserisci base reale ed esponente \n"); 22 | scanf("%f%d", &b, &e); 23 | printf("%f\n", potenza(b, e)); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /codice/110_puntatori/funzione: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int divisione(int dividendo, int divisore, int* pq, int* pr) { 4 | if (divisore != 0) { 5 | *pq = dividendo / divisore; 6 | *pr = dividendo % divisore; 7 | return 1; 8 | } else { 9 | return 0; 10 | } 11 | } 12 | 13 | int main(void) { 14 | int q, r; 15 | int dividendo, divisore; 16 | scanf("%d%d", ÷ndo, &divisore); 17 | if (divisione(dividendo, divisore, &q, &r)) 18 | printf("%d, %d\n", q, r); 19 | else 20 | printf("Errore\n"); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/lista-sequenziale.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define DIMENSIONE 100 4 | 5 | typedef struct { 6 | int n_elementi; 7 | int dati[DIMENSIONE]; 8 | } Lista; 9 | 10 | void nuova_lista(Lista* pl); 11 | int vuota(Lista l); 12 | int piena(Lista l); 13 | void insTesta(Lista* pl, int numero); 14 | void insOrd(Lista* pl, int numero); 15 | int ricerca(Lista l, int numero); 16 | void elim1(Lista* pl, int numero); 17 | void elimTutti(Lista* pl, int numero); 18 | int lunghezza(Lista l); 19 | void stampa(Lista l); -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/rubrica-pin-blocco-else.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int pin, scelta; 5 | scanf("%d", &pin); 6 | if (pin == 44122) { 7 | printf("Accesso consentito\n"); 8 | printf("1. Tizio 335-1234567\n"); 9 | printf("2. Caio 347-1234567\n"); 10 | printf("Scegliere un contatto"); 11 | scanf("%d", &scelta); 12 | printf("Chiamata al contatto %d\n", scelta); 13 | } else { 14 | printf("Accesso negato\n"); 15 | printf("Il programma sta per terminare\n"); 16 | } 17 | printf("Fine\n"); 18 | } -------------------------------------------------------------------------------- /codice/220_allocazione_dinamica/alloca.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | char* allocaStringa(int n) { 6 | char* s; 7 | s = (char*)malloc(n); 8 | if (s == NULL) { 9 | printf("Impossibile allocare la stringa\n"); 10 | exit(1); 11 | } 12 | return s; 13 | } 14 | 15 | void libera(char **ps){ 16 | free(*ps); 17 | *ps = NULL; 18 | } 19 | 20 | int main() { 21 | char* pc = allocaStringa(100); 22 | strcpy(pc, "Ferrara"); 23 | printf("%s\n", pc); 24 | libera(&pc); 25 | return 0; 26 | } -------------------------------------------------------------------------------- /codice/130_file_di_testo/copia.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | char s[80]; 7 | FILE* pf; 8 | pf = fopen("prova.txt", "wt"); 9 | if (pf == NULL) { 10 | printf("Errore apertura file\n"); 11 | exit(1); 12 | } 13 | 14 | do { 15 | fscanf(stdin,"%s", s); // uguale a scanf("%s", s); 16 | fprintf(pf, "%s\n", s); 17 | } while (strcmp(s, "FINE") != 0); 18 | 19 | if (fclose(pf) != 0) { 20 | printf("Errore chiusura file\n"); 21 | exit(2); 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/elim1.c: -------------------------------------------------------------------------------- 1 | void elim1(Lista* pl, int numero) { 2 | int i = 0; 3 | while (i < pl->n_elementi) // scorro tutti gli elementi 4 | { 5 | // se ne trovo uno uguale al numero da eliminare... 6 | if (pl->dati[i] == numero) { 7 | int j; 8 | // sposto a sinistra tutti gli elementi che lo seguono 9 | for (j = i; j < pl->n_elementi - 1; j++) 10 | pl->dati[j] = pl->dati[j + 1]; 11 | pl->n_elementi--; // decremento la dimensione logica 12 | return; 13 | } else 14 | i++; 15 | } 16 | } -------------------------------------------------------------------------------- /tutorato/tutorato_05/celsius.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | float celsiusToFahrenheit (int temperatura){ 4 | return ((temperatura/5.0)*9 + 32); 5 | } 6 | 7 | float fahrenheitToCelsius (int temperatura){ 8 | return ((temperatura-32)/9.0)*5; 9 | } 10 | 11 | int main(){ 12 | int i; 13 | 14 | for(i=-100;i<=100;i+=10){ 15 | printf("Celsius: %d \t Fahrenheit %.2f\n",i, celsiusToFahrenheit(i)); 16 | } 17 | 18 | for(i=-100;i<=300;i+=20){ 19 | printf("Fahrenheit: %d \t Celsius: %.2f\n", i, fahrenheitToCelsius(i)); 20 | } 21 | } -------------------------------------------------------------------------------- /codice/155_make/radice_quadrata/funzioni-aritmetiche.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "funzioni-aritmetiche.h" 4 | 5 | float media(float y, float z) { 6 | return (y + z) / 2; 7 | } 8 | 9 | float media_geometrica(float y, float z) { 10 | return sqrt(y * z); 11 | } 12 | 13 | float quadrato(float y) { 14 | return y * y; 15 | } 16 | 17 | float piu1(float x) { // non esposta 18 | return x + 1; 19 | } 20 | 21 | float cubo(float x) { 22 | return x * quadrato(x); 23 | } 24 | 25 | Frazione rf(Frazione f) { 26 | Frazione f1 = {1, 1}; 27 | return f1; 28 | } -------------------------------------------------------------------------------- /codice/070_funzioni/logo2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int scelta; 5 | printf("###############\n"); 6 | printf("# Rubrica #\n"); 7 | printf("###############\n"); 8 | printf("1. Tizio 335-1234567\n"); 9 | printf("2. Caio 347-1234567\n"); 10 | printf("Scegliere un contatto\n"); 11 | scanf("%d", &scelta); 12 | if (scelta > 0) { 13 | printf("###############\n"); 14 | printf("# Rubrica #\n"); 15 | printf("###############\n"); 16 | printf("Chiamata del contatto %d in corso\n", scelta); 17 | } 18 | printf("Fine\n"); 19 | } -------------------------------------------------------------------------------- /codice/110_puntatori/divisione-con-controllo-errore-funzione: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int divisione(int dividendo, int divisore, int* pq, int* pr) { 4 | if (divisore != 0) { 5 | *pq = dividendo / divisore; 6 | *pr = dividendo % divisore; 7 | return 1; 8 | } else { 9 | return 0; 10 | } 11 | } 12 | 13 | int main(void) { 14 | int q, r; 15 | int dividendo, divisore; 16 | scanf("%d%d", ÷ndo, &divisore); 17 | if (divisione(dividendo, divisore, &q, &r)) 18 | printf("%d, %d\n", q, r); 19 | else 20 | printf("Errore\n"); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /codice/130_file_di_testo/infinito.txt: -------------------------------------------------------------------------------- 1 | Sempre caro mi fu quest'ermo colle, E questa siepe, che da tanta parte De l'ultimo orizzonte il guardo esclude. Ma sedendo e mirando, interminati Spazi di la` da quella, e sovrumani Silenzi, e profondissima quiete Io nel pensier mi fingo, ove per poco Il cor non si spaura. E come il vento Odo stormir tra queste piante, io quello Infinito silenzio a questa voce Vo comparando: e mi sovvien l'eterno, E le morte stagioni, e la presente E viva, e 'l suon di lei. Così tra questa Immensita` s'annega il pensier mio: E 'l naufragar m'è dolce in questo mare. 2 | -------------------------------------------------------------------------------- /codice/155_make/radice_quadrata/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "funzioni-aritmetiche.h" 5 | #include "radice-quadrata.h" 6 | 7 | int main(void) { 8 | Frazione f; 9 | float a; 10 | printf("Digita un numero\n"); 11 | scanf("%f", &a); 12 | if (a <= 0) { 13 | printf("%f e` negativo o nullo\n", a); 14 | return -1; 15 | } 16 | printf("La radice quadrata di %.2f e` circa %f\n", a, radq(a)); 17 | printf("La media geometrica di %.2f e 5.0 e` circa %f\n", a, media_geometrica(a, 5.0)); 18 | a= cubo(a); 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /tutorato/tutorato_03/collatz.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int a,b,i,n, nCicli; 5 | 6 | printf("Inserire il valore iniziale:\n"); 7 | scanf("%d", &a); 8 | 9 | printf("Inserire il valore finale;\n"); 10 | scanf("%d",&b); 11 | 12 | for(i=a;i<=b;i++){ 13 | n=i; 14 | nCicli=0; 15 | 16 | while(n!=1){ 17 | if(n%2==0) 18 | n=n/2; 19 | else 20 | n=3*n+1; 21 | nCicli++; 22 | } 23 | printf("Numero %d\n Numero Cicli %d\n\n",i, nCicli); 24 | } 25 | } -------------------------------------------------------------------------------- /codice/160_argomenti_linea_comando/infinito.txt: -------------------------------------------------------------------------------- 1 | Sempre caro mi fu quest'ermo colle, E questa siepe, che da tanta parte De l'ultimo orizzonte il guardo esclude. Ma sedendo e mirando, interminati Spazi di la` da quella, e sovrumani Silenzi, e profondissima quiete Io nel pensier mi fingo, ove per poco Il cor non si spaura. E come il vento Odo stormir tra queste piante, io quello Infinito silenzio a questa voce Vo comparando: e mi sovvien l'eterno, E le morte stagioni, e la presente E viva, e 'l suon di lei. Così tra questa Immensita` s'annega il pensier mio: E 'l naufragar m'è dolce in questo mare. 2 | -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/indice-massimo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int indice_max(int v[], int dl) { 4 | int m = 0; // indice del massimo 5 | int i; 6 | if (dl < 1) { 7 | printf("Array senza elementi!\n"); 8 | return -1; 9 | } 10 | for (i = 1; i < dl; i++) 11 | if (v[i] > v[m]) 12 | m = i; 13 | return m; 14 | } 15 | 16 | int main() { 17 | int a[10], n, i; 18 | printf("Quanti elementi?\n"); 19 | scanf("%d", &n); 20 | for (i = 0; i < n; i++) 21 | scanf("%d", &a[i]); 22 | printf("Indice del massimo: %d\n", indice_max(a, n)); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /codice/115_array_e_funzioni/procedura-insertion-sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 5 3 | 4 | void insertionSort(int a[], int dl) { 5 | int dlo; 6 | for (dlo = 0; dlo < dl; dlo++) { 7 | int j = dlo, m = a[dlo]; 8 | while (j > 0 && m < a[j - 1]) { 9 | a[j] = a[j - 1]; 10 | j--; 11 | } 12 | a[j] = m; 13 | } 14 | } 15 | 16 | int main(void) { 17 | int a[] = {4, 1, 8, 0, 5}, i; 18 | // inizio insertion sort 19 | insertionSort(a, DIM); 20 | // fine insertion sort 21 | for (i = 0; i < DIM; i++) 22 | printf("%d ", a[i]); 23 | printf("\n"); 24 | } -------------------------------------------------------------------------------- /codice/230_liste_collegate/lunghezza-di-una-lista.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef int Dato; 4 | 5 | typedef struct nodo { 6 | Dato dato; 7 | struct nodo* next; 8 | } Nodo; 9 | 10 | typedef Nodo* Lista; 11 | 12 | #include "generatoreListe.h" 13 | 14 | int lunghezza(Lista l) { 15 | // Reduce(++, 0, l) 16 | int c = 0; // accumulatore 17 | while (l) { 18 | c++; // aggiornamento accumulatore 19 | l = l->next; 20 | } 21 | return c; 22 | } 23 | 24 | int main() { 25 | Lista l; 26 | listaNonOrdinata(&l, 5); 27 | printf("%d\n", lunghezza(l)); 28 | return 0; 29 | } -------------------------------------------------------------------------------- /tutorato/tutorato_01/esiti.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int esito; 5 | 6 | printf("Inserire l'esito dell'esame: "); 7 | scanf("%d", &esito); 8 | 9 | if(18> esito) 10 | printf("Insufficiente\n"); 11 | if(18<= esito && esito<=20) 12 | printf("Sufficiente\n"); 13 | if(21<= esito && esito<=23) 14 | printf("Discreto\n"); 15 | if(24<= esito && esito<=26) 16 | printf("Buono\n"); 17 | if(27<= esito && esito<=29) 18 | printf("Distinto\n"); 19 | if(30<= esito && esito<=32) 20 | printf("Ottimo\n"); 21 | } -------------------------------------------------------------------------------- /tutorato/tutorato_11/listaPazienti.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | char cf[17]; 3 | int ora; 4 | float temperatura; 5 | float saturazione; 6 | } Rilevazione; 7 | 8 | typedef struct { 9 | char cf[17]; 10 | int n_rilevazioni; 11 | float somma_temperatura; 12 | float somma_saturazione; 13 | int anomalia; 14 | } Dato; 15 | 16 | typedef struct nodo { 17 | Dato dato; 18 | struct nodo* next; 19 | } Nodo; 20 | 21 | typedef Nodo* Lista; 22 | 23 | void nuovaLista(Lista* pl); 24 | void aggiorna(Lista* pl, Rilevazione v); 25 | void stampa(Lista l); 26 | void eliminaSani(Lista* pl); 27 | 28 | -------------------------------------------------------------------------------- /codice/070_funzioni/rettangolo-di-asterischi-funzione.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // stampa un numero n di asterischi 4 | void riga(int numero_colonne) { 5 | int j; 6 | for (j = 1; j <= numero_colonne; j++) 7 | printf("*"); 8 | printf("\n"); 9 | } 10 | 11 | void rettangolo(int nr, int nc) { // stampa un rettangolo di nr x nc asterischi 12 | int i; 13 | for (i = 1; i <= nr; i++) 14 | riga(nc); 15 | } 16 | 17 | int main() { 18 | int m, n; 19 | printf("Inserisci i numeri di righe e colonne\n"); 20 | scanf("%d%d", &m, &n); 21 | rettangolo(m, n); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /codice/110_puntatori/divisione-con-controllo-errore-funzione-stile-unix: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int divisione(int dividendo, int divisore, int* pq, int* pr) { 4 | if (divisore != 0) { 5 | *pq = dividendo / divisore; 6 | *pr = dividendo % divisore; 7 | return 0; 8 | } else { 9 | return 1; 10 | } 11 | } 12 | 13 | int main(void) { 14 | int q, r; 15 | int dividendo, divisore; 16 | scanf("%d%d", ÷ndo, &divisore); 17 | if (divisione(dividendo, divisore, &q, &r) == 0) 18 | printf("%d, %d\n", q, r); 19 | else 20 | printf("Errore\n"); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/insOrd.c: -------------------------------------------------------------------------------- 1 | void insOrd(Lista* pl, int numero) { 2 | int i; 3 | if (piena(*pl)) { 4 | // se la lista e' piena non posso inserire elementi 5 | printf("Errore: lista piena\n"); 6 | exit(-1); 7 | } 8 | // sposto a destra tutti gli elementi della lista 9 | // maggiori del numero da inserire 10 | i = pl->n_elementi; 11 | while (i > 0 && pl->dati[i - 1] > numero) { 12 | pl->dati[i] = pl->dati[i - 1]; 13 | i--; 14 | } 15 | // inserisco il numero 16 | pl->dati[i] = numero; 17 | // incremento la dimensione logica 18 | pl->n_elementi++; 19 | } -------------------------------------------------------------------------------- /codice/160_argomenti_linea_comando/stampa.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) { 5 | FILE* pf; 6 | char c; 7 | if (argc != 2){ 8 | printf("Uso: %s nome_file_da_stampare\n", argv[0]); 9 | exit(3); 10 | } 11 | 12 | pf = fopen(argv[1], "rt"); 13 | if (pf == NULL) { 14 | printf("Errore apertura file %s\n", argv[1]); 15 | exit(1); 16 | } 17 | 18 | while (fscanf(pf, "%c", &c) == 1) 19 | printf("%c", c); 20 | 21 | if (fclose(pf) != 0) { 22 | printf("Errore chiusura file %s\n", argv[1]); 23 | exit(2); 24 | } 25 | } -------------------------------------------------------------------------------- /codice/120_vettori_multidimensionali/identita.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 3 3 | 4 | typedef int Riga[DIM]; 5 | typedef Riga Matrice[DIM]; 6 | 7 | int main() { 8 | Matrice m; 9 | int i, j; 10 | 11 | for (i = 0; i < DIM; i++) 12 | for (j = 0; j < DIM; j++) 13 | if (j == i) 14 | m[i][j] = 1; 15 | else 16 | m[i][j] = 0; 17 | // oppure m[i][j] = i == j ? 1 : 0; 18 | // oppure m[i][j] = i == j; 19 | 20 | for (i = 0; i < DIM; i++) { 21 | for (j = 0; j < DIM; j++) 22 | printf("%d ", m[i][j]); 23 | printf("\n"); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /codice/095_stringhe/confronto_alfabetico.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 30 3 | 4 | int main() { 5 | char s1[DIM], s2[DIM]; 6 | int dif, i; 7 | printf("Inserisci due parole\n"); 8 | scanf("%s%s", s1, s2); 9 | // s1 = "Bologna" s2 = "Ferrara" 10 | 11 | i = 0; 12 | 13 | dif = 0; 14 | while (dif == 0 && (s1[i] != '\0' || s2[i] != '\0' )) { 15 | dif = s1[i] - s2[i]; 16 | i++; 17 | } 18 | 19 | if (dif < 0) 20 | printf("%s precede %s\n", s1, s2); 21 | else if (dif > 0) 22 | printf("%s precede %s\n", s2, s1); 23 | else 24 | printf("%s e %s sono uguali\n", s1, s2); 25 | } -------------------------------------------------------------------------------- /codice/110_puntatori/divisione-con-controllo-errore.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void divisione(int dividendo, int divisore, int* pq, int* pr, int* pok) { 4 | if (divisore != 0) { 5 | *pq = dividendo / divisore; 6 | *pr = dividendo % divisore; 7 | *pok = 1; 8 | } else { 9 | *pok = 0; 10 | } 11 | } 12 | 13 | int main(void) { 14 | int q, r; 15 | int dividendo, divisore; 16 | int ok; 17 | scanf("%d%d", ÷ndo, &divisore); 18 | divisione(dividendo, divisore, &q, &r, &ok); 19 | if (ok) 20 | printf("%d, %d\n", q, r); 21 | else 22 | printf("Errore\n"); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /codice/l05/radice-quadrata.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | float media(float y, float z) { 5 | return (y + z) / 2; 6 | } 7 | 8 | float radq(float a) { 9 | float x; // accumulatore 10 | x = 1.0; 11 | while (fabsf(x * x - a) / a > 1e-5) 12 | x = media(x, a / x); // media 13 | return x; 14 | } 15 | 16 | int main(void) { 17 | float a; 18 | printf("Digita un numero\n"); 19 | scanf("%f", &a); 20 | if (a <= 0) { 21 | printf("%f e` negativo o nullo\n", a); 22 | return -1; 23 | } 24 | printf("La radice quadrata di %.2f e` circa %f\n", a, radq(a)); 25 | return 0; 26 | } -------------------------------------------------------------------------------- /codice/l11/20220131-pratica-totale/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "listaEsami.h" 5 | 6 | int main(int argc, char* argv[]) { 7 | FILE* pf; 8 | Record r; 9 | Lista l; 10 | 11 | if (argc != 2){ 12 | printf("Errore invocazione\n"); 13 | exit(1); 14 | } 15 | 16 | pf = fopen(argv[1], "rb"); 17 | if (pf == NULL){ 18 | printf("Errore apertura file\n"); 19 | exit(2); 20 | } 21 | 22 | nuova_lista(&l); 23 | 24 | while (fread(&r, sizeof(Record), 1, pf) == 1) 25 | aggiorna(&l, r); 26 | 27 | stampa(insertionSort(l)); 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /codice/200_adt/figure-adt/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "figura.h" 4 | 5 | int main() { 6 | Figura f1, f2, f3, f4; 7 | rettangolo(&f1, 2.5, 3.7); 8 | printf("Perimetro: %f\n", perimetro(&f1)); 9 | printf("Area: %f\n", area(&f1)); 10 | quadrato(&f2, 2.5); 11 | printf("Perimetro: %f\n", perimetro(&f2)); 12 | printf("Area: %f\n", area(&f2)); 13 | triangolo(&f3, 3, 4, 5); 14 | printf("Perimetro: %f\n", perimetro(&f3)); 15 | printf("Area: %f\n", area(&f3)); 16 | cerchio(&f4, 5.0); 17 | printf("Perimetro: %f\n", perimetro(&f4)); 18 | printf("Area: %f\n", area(&f4)); 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /codice/l05/potenza.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | float potenza(float base, int esp) { 4 | int cont; 5 | float prod; 6 | if (esp >= 0) { 7 | prod = 1.0; 8 | for (cont = 0; cont < esp; cont++) 9 | prod *= base; 10 | return prod; 11 | } else { 12 | esp = -esp; 13 | prod = 1.0; 14 | for (cont = 0; cont < esp; cont++) 15 | prod *= base; 16 | return 1.0/prod; 17 | } 18 | } 19 | 20 | int main() { 21 | int e; 22 | float b; 23 | printf("Inserisci base (reale) ed esponente (intero con segno)\n"); 24 | scanf("%f%d", &b, &e); 25 | printf("%f\n", potenza(b, e)); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /tutorato/tutorato_03/input.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int a, sum, max, min; 5 | min=101; 6 | max=0; 7 | sum=0; 8 | 9 | printf("Inserisci un numero da tastiera: \n"); 10 | scanf("%d", &a); 11 | 12 | while(a!=0){ 13 | sum = sum + a; 14 | if(a>=max) 15 | max=a; 16 | if(a<=min) 17 | min=a; 18 | printf("Inserisci un numero da tastiera: \n"); 19 | scanf("%d", &a); 20 | } 21 | 22 | printf("La somma è %d\n", sum); 23 | printf("Il numero maggiore è %d\n", max); 24 | printf("Il numero minore è %d\n", min); 25 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/somma-interi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n; // variabile di input 5 | int i; 6 | int s; // accumulatore 7 | scanf("%d", &n); 8 | 9 | s = 0; // v0 10 | for (i = 1; i <= n; i++) { 11 | // S1: i assume i valori fra 1 e n 12 | printf("%d", i); 13 | if (i < n) 14 | printf("+"); 15 | else 16 | printf("="); 17 | // output = map(printf, "+" se < n, "=" altrimenti, S1) 18 | s = s + i; // aggiornamento accumulatore 19 | // s è la somma dei valori fra 1 e i 20 | } 21 | // s è la somma dei naturali fra 1 e n 22 | printf("%d\n", s); 23 | } -------------------------------------------------------------------------------- /codice/095_stringhe/to_uppercase.c: -------------------------------------------------------------------------------- 1 | // legge da input una stringa e la stampa con le lettere minuscole sostituite 2 | // dalle corrispondenti maiuscole 3 | 4 | // input : Ferrara 5 | // output: FERRARA 6 | 7 | #include 8 | 9 | #define DIM 51 10 | 11 | char maiuscola(char c) { 12 | if (c >= 'a' && c <= 'z') 13 | return c - ('a' - 'A'); 14 | else 15 | return c; 16 | } 17 | 18 | int main() { 19 | char s[DIM]; 20 | char c; 21 | int i; 22 | scanf("%s", s); 23 | i = 0; 24 | do { 25 | printf("%c", maiuscola(s[i])); 26 | i++; 27 | } while (s[i] != '\0'); 28 | printf("\n"); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /codice/050_controllo_di_flusso/primo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int n, i, n_divisori; 5 | printf("Inserisci un numero naturale\n"); 6 | scanf("%d", &n); 7 | n_divisori = 0; // inizializzazione accumulatore 8 | for (i = 1; i <= n; i++) { 9 | // S1 i assume i valori fra 1 e n 10 | if (n % i == 0) { 11 | // S2: i assume i valori dei divisori di n 12 | n_divisori = n_divisori + 1; 13 | } 14 | } 15 | // n_divisori contiene il numero dei divisori di n compresi fra 1 e n 16 | if (n_divisori == 2) 17 | printf("%d è primo\n", n); 18 | else 19 | printf("%d non è primo\n", n); 20 | } -------------------------------------------------------------------------------- /codice/095_stringhe/to_uppercase_versione_2.c: -------------------------------------------------------------------------------- 1 | // legge da input una stringa e la stampa con le lettere minuscole sostituite 2 | // dalle corrispondenti maiuscole 3 | 4 | // input : Ferrara 5 | // output: FERRARA 6 | 7 | #include 8 | 9 | #define DIM 51 10 | 11 | char maiuscola(char c) { 12 | if (c >= 'a' && c <= 'z') 13 | return c - ('a' - 'A'); 14 | else 15 | return c; 16 | } 17 | 18 | int main() { 19 | char s[DIM]; 20 | char c; 21 | int i; 22 | scanf("%s", s); 23 | i = 0; 24 | do { 25 | s[i] = maiuscola(s[i]); 26 | i++; 27 | } while (s[i] != '\0'); 28 | printf("%s\n", s); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /codice/070_funzioni/subroutine-goto.c: -------------------------------------------------------------------------------- 1 | #include 2 | main() { 3 | int scelta, ritorno; 4 | ritorno = 1; goto logo; 5 | elenco: 6 | printf("1. Tizio 335-1234567\n"); 7 | printf("2. Caio 347-1234567\n"); 8 | printf("Scegliere un contatto\n"); 9 | scanf("%d", &scelta); 10 | ritorno = 2; goto logo; 11 | chiamata: 12 | printf("Chiamata del contatto %d in corso\n", scelta); 13 | goto fine; 14 | logo: 15 | printf("###############\n"); 16 | printf("# Rubrica #\n"); 17 | printf("###############\n"); 18 | if (ritorno == 1) goto elenco; 19 | else if (ritorno == 2) goto chiamata; 20 | fine: 21 | printf("Fine\n"); 22 | } -------------------------------------------------------------------------------- /codice/120_vettori_multidimensionali/simmetrica.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 3 3 | 4 | void lettura(int m[][DIM]) { 5 | int i, j; 6 | for (i = 0; i < DIM; i++) 7 | for (j = 0; j < DIM; j++) 8 | scanf("%d", &m[i][j]); 9 | } 10 | 11 | int simmetrica(int m[][DIM]) { 12 | int i, j; 13 | for (i = 0; i < DIM; i++) 14 | for (j = i + 1; j < DIM; j++) 15 | if (m[i][j] != m[j][i]) 16 | return 0; 17 | return 1; 18 | } 19 | 20 | int main() { 21 | int matrice[DIM][DIM]; 22 | lettura(matrice); 23 | if (simmetrica(matrice)) 24 | printf("Simmetrica\n"); 25 | else 26 | printf("Non simmetrica\n"); 27 | } -------------------------------------------------------------------------------- /tutorato/tutorato_02/frazioni.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int d1, d2, n1, n2; 5 | 6 | printf("Inserire il numeratore ed il denominatore della prima frazione:\n"); 7 | scanf("%d%d", &n1,&d1); 8 | 9 | printf("Inserire il numeratore ed il denominatore della seconda frazione:\n"); 10 | scanf("%d%d", &n2,&d2); 11 | 12 | if(d1!=0 && d2!=0){ 13 | if(n1*d2 == n2*d1) 14 | printf("Le due frazioni sono equivalenti\n"); 15 | else 16 | printf("Le due frazioni non sono equivalenti\n"); 17 | } 18 | else 19 | printf("I denominatori devono essere diversi da zero\n"); 20 | } -------------------------------------------------------------------------------- /tutorato/tutorato_06/istogrammi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 100 3 | 4 | void stampa_asterischi(int n){ 5 | int i; 6 | printf("%d",n); 7 | for(i=0;i 2 | 3 | void elimina_ripetuti(int v[], int* pdl) { 4 | int i, k; 5 | for (k = 0; k < *pdl; k++) { 6 | i = k + 1; 7 | while (i < *pdl) { 8 | if (v[k] == v[i]) { 9 | int j; 10 | for (j = i; j < *pdl - 1; j++) 11 | v[j] = v[j + 1]; 12 | (*pdl)--; 13 | } else 14 | i++; 15 | } 16 | } 17 | } 18 | 19 | int main() { 20 | int a[] = {4, 1, 5, 4, 6, 1,4,4,4,4,4,4}; 21 | int dl = 6, i; 22 | elimina_ripetuti(a, &dl); 23 | for (i = 0; i < dl; i++) 24 | printf("%d ", a[i]); 25 | printf("\n"); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /codice/040_variabili/somma-due-variabili.c: -------------------------------------------------------------------------------- 1 | // stampa la somma di tre numeri richiesti all'utente usando solo due variabili 2 | 3 | #include 4 | 5 | main() { 6 | int numero; 7 | int somma = 0; // accumulatore: contiene la somma dei numeri inseriti a ogni istante 8 | 9 | printf("Digita un numero intero\n"); 10 | scanf("%d", &numero); 11 | somma = somma + numero; 12 | 13 | printf("Digita un numero intero\n"); 14 | scanf("%d", &numero); 15 | somma = somma + numero; 16 | 17 | printf("Digita un numero intero\n"); 18 | scanf("%d", &numero); 19 | somma = somma + numero; 20 | 21 | printf("La somma è %d\n", somma); 22 | } -------------------------------------------------------------------------------- /codice/140_file_binari/aggiorna_stipendi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct { 5 | char nome[10]; 6 | float stipendio; 7 | } Impiegato; 8 | 9 | int main() { 10 | FILE* pfb; 11 | Impiegato im; 12 | pfb = fopen("stipendi.dat", "r+b"); 13 | if (pfb == NULL) { 14 | printf("Errore apertura\n"); 15 | exit(1); 16 | } 17 | while (fread(&im, sizeof(Impiegato), 1, pfb) == 1) 18 | if (im.stipendio < 1500) { 19 | im.stipendio = im.stipendio * 1.1; 20 | fseek(pfb, -sizeof(Impiegato), SEEK_CUR); 21 | fwrite(&im, sizeof(Impiegato), 1, pfb); 22 | fflush(pfb); 23 | } 24 | fclose(pfb); 25 | } -------------------------------------------------------------------------------- /codice/140_file_binari/lettura_binario_come_testo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct { 5 | char cognome[31]; 6 | char nome[31]; 7 | char sesso; // probabilmente qui c'è 1 byte di padding 8 | int anno_nascita; 9 | } Persona; 10 | 11 | int main() { 12 | Persona persone[100]; 13 | FILE* pf; 14 | pf = fopen("people.dat", "rt"); 15 | fscanf(pf, "%s%s%c%d", persone[0].cognome, persone[0].nome, &persone[0].sesso, 16 | &persone[0].anno_nascita); 17 | fscanf(pf, "%s%s%c%d", persone[0].cognome, persone[0].nome, &persone[0].sesso, 18 | &persone[0].anno_nascita); 19 | fclose(pf); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /codice/140_file_binari/crea_stipendi.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct { 5 | char nome[10]; 6 | float stipendio; 7 | } Impiegato; 8 | 9 | int main() { 10 | FILE* pfb; 11 | Impiegato impiegati[5] = {{"Rossi", 2450}, 12 | {"Bianchi", 1820}, 13 | {"Verdi", 800}, 14 | {"Esposito", 3000}, 15 | {"Greco", 1250}}; 16 | pfb = fopen("stipendi.dat", "wb"); 17 | if (pfb == NULL) { 18 | printf("Errore in apertura\n"); 19 | exit(1); 20 | } 21 | fwrite(impiegati, sizeof(Impiegato), 5, pfb); 22 | fclose(pfb); 23 | } -------------------------------------------------------------------------------- /codice/l10/20170130/listaCalorie.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "listaCalorie.h" 6 | 7 | void lista_vuota(Lista* pl) { 8 | pl->n_elementi = 0; 9 | } 10 | 11 | int piena(Lista l) { 12 | return l.n_elementi == DIM; 13 | } 14 | 15 | void insCoda(Lista* pl, Record r) { 16 | pl->dati[pl->n_elementi] = r; 17 | pl->n_elementi++; 18 | } 19 | 20 | float calorie100grammi(Lista l, char nome[]) { 21 | int i; 22 | for (i = 0; i < l.n_elementi; i++) 23 | if (strcmp(l.dati[i].nome, nome) == 0) 24 | return l.dati[i].calorie100grammi; 25 | printf("Errore: %s non trovato\n", nome); 26 | exit(4); 27 | } -------------------------------------------------------------------------------- /codice/100_strutture_typedef_enum/persone.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | struct persona { 6 | char nome[20]; 7 | char cognome[30]; 8 | float altezza; 9 | int eta; 10 | } p1; 11 | 12 | int i; 13 | struct persona p2; 14 | 15 | struct persona persone[100]; 16 | 17 | struct aula { 18 | char nome[20]; 19 | struct persona occupanti[100]; 20 | } f9; 21 | 22 | f9.occupanti[49].altezza = 1.80; 23 | strcpy(f9.nome, "Chiostro F9"); 24 | 25 | p1.eta = 25; 26 | scanf("%f", &p1.altezza); 27 | strcpy(p1.cognome, "Jacobs"); 28 | 29 | for (i = 0; i < 100; i++) 30 | persone[i].eta = 30; 31 | } -------------------------------------------------------------------------------- /tutorato/tutorato_11/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "listaPazienti.h" 5 | 6 | int main(int argc, char* argv[]) { 7 | Rilevazione v; 8 | FILE* fp; 9 | Lista l; 10 | if (argc != 2) { 11 | printf("Uso: %s fileVisite\n", argv[0]); 12 | exit(1); 13 | } 14 | if ((fp = fopen(argv[1], "rb")) == NULL) { 15 | printf("Errore apertura %s\n", argv[1]); 16 | exit(2); 17 | } 18 | nuovaLista(&l); 19 | // solita reduce(aggiorna,[],file) 20 | while (fread(&v, sizeof(Rilevazione), 1, fp) == 1) 21 | aggiorna(&l, v); 22 | fclose(fp); 23 | eliminaSani(&l); // per la parte 2 24 | stampa(l); 25 | return 0; 26 | } -------------------------------------------------------------------------------- /codice/070_funzioni/subroutine-funzione-param.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | logo(char carattere) { 4 | int i; 5 | for (i = 0; i < 15; i++) 6 | printf("%c", carattere); 7 | printf("\n"); 8 | printf("%c Rubrica %c\n", carattere, carattere); 9 | for (i = 0; i < 15; i++) 10 | printf("%c", carattere); 11 | printf("\n"); 12 | } 13 | 14 | main() { 15 | int scelta; 16 | 17 | logo('*'); 18 | printf("1. Tizio 335-1234567\n"); 19 | printf("2. Caio 347-1234567\n"); 20 | printf("Scegliere un contatto\n"); 21 | scanf("%d", &scelta); 22 | 23 | logo('#'); 24 | printf("Chiamata del contatto %d in corso\n", scelta); 25 | 26 | printf("Fine\n"); 27 | } -------------------------------------------------------------------------------- /tutorato/tutorato_01/scacchiera.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int r, c; 5 | 6 | printf("Inserire la riga:\n"); 7 | scanf("%d", &r); 8 | 9 | printf("Inserire la colonna:\n"); 10 | scanf("%d", &c); 11 | 12 | if(r>8 || r<0 || c>8 || c<0) 13 | printf("Le coordinate inserite non corrispondono a punti sulla scacchiera\n"); 14 | else{ 15 | //condizione affinchè la casella sia bianca: riga e colonna devono essere entrambi pari o entrambi dispari 16 | if((r%2==0 && c%2==0)||(r%2!=0 && c%2!=0)) 17 | printf("Casella bianca\n"); 18 | else 19 | printf("Casella nera\n"); 20 | } 21 | 22 | } -------------------------------------------------------------------------------- /codice/070_funzioni/subroutine-funzione-riga.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | riga(int n, char carattere) { 4 | int i; 5 | for (i = 0; i < n; i++) 6 | printf("%c", carattere); 7 | printf("\n"); 8 | } 9 | 10 | logo(char carattere) { 11 | riga(15, carattere); 12 | printf("%c Rubrica %c\n", carattere, carattere); 13 | riga(15, carattere); 14 | } 15 | 16 | main() { 17 | int scelta, ritorno; 18 | logo('*'); 19 | printf("1. Tizio 335-1234567\n"); 20 | printf("2. Caio 347-1234567\n"); 21 | printf("Scegliere un contatto\n"); 22 | scanf("%d", &scelta); 23 | logo('#'); 24 | printf("Chiamata del contatto %d in corso\n", scelta); 25 | printf("Fine\n"); 26 | } -------------------------------------------------------------------------------- /codice/140_file_binari/aggiorna_stipendi_ftell.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct { 5 | char nome[10]; 6 | float stipendio; 7 | } Impiegato; 8 | 9 | int main() { 10 | FILE* pfb; 11 | Impiegato im; 12 | pfb = fopen("stipendi.dat", "r+b"); 13 | if (pfb == NULL) { 14 | printf("Errore apertura\n"); 15 | exit(1); 16 | } 17 | while (fread(&im, sizeof(Impiegato), 1, pfb) == 1) 18 | if (im.stipendio < 1500) { 19 | im.stipendio = im.stipendio * 1.1; 20 | fseek(pfb, ftell(pfb) - sizeof(Impiegato), SEEK_SET); 21 | fwrite(&im, sizeof(Impiegato), 1, pfb); 22 | fflush(pfb); 23 | } 24 | fclose(pfb); 25 | } -------------------------------------------------------------------------------- /codice/l11/20170130-pratica-totale/listaCalorie.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "listaCalorie.h" 6 | 7 | void lista_vuota(Lista* pl) { 8 | pl->n_elementi = 0; 9 | } 10 | 11 | int piena(Lista l) { 12 | return l.n_elementi == DIM; 13 | } 14 | 15 | void insCoda(Lista* pl, Record r) { 16 | pl->dati[pl->n_elementi] = r; 17 | pl->n_elementi++; 18 | } 19 | 20 | float calorie100grammi(Lista l, char nome[]) { 21 | int i; 22 | for (i = 0; i < l.n_elementi; i++) 23 | if (strcmp(l.dati[i].nome, nome) == 0) 24 | return l.dati[i].calorie100grammi; 25 | printf("Errore: %s non trovato\n", nome); 26 | exit(4); 27 | } -------------------------------------------------------------------------------- /esami/20221108-parziale/Esercizio1-turno1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int perfetto(int n) { 4 | int d; 5 | int s; 6 | d = 1; 7 | s = 0; 8 | while (d < n) { 9 | if (n % d == 0) 10 | s = s + d; 11 | d = d + 1; 12 | } 13 | if (s == n) 14 | return 1; 15 | else 16 | return 0; 17 | } 18 | 19 | int main() { 20 | int a[10]; 21 | int dl = 0; 22 | int n; 23 | int i; 24 | printf("Inserisci un numero minore o uguale a 10\n"); 25 | scanf("%d", &n); 26 | for (i = 1; i < n; i++) 27 | if (!perfetto(i)) { 28 | a[dl] = i * i; 29 | dl++; 30 | } 31 | for (i = 0; i < dl; i++) 32 | printf("%d\n", a[i]); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /tutorato/tutorato_07/find_replace.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | char parola[21]; 5 | char carattere, nuovo_carattere; 6 | int i=0; 7 | 8 | printf("Inserire una stringa max 20 caratteri\n"); 9 | scanf("%s", parola); 10 | 11 | printf("Inserisci il carattere da cercare\n"); 12 | scanf(" %c", &carattere); 13 | 14 | printf("Inserisci il carattere con cui sostituire\n"); 15 | scanf(" %c", &nuovo_carattere); 16 | 17 | while(parola[i]!='\0'){ 18 | if(parola[i]==carattere){ 19 | parola[i]=nuovo_carattere; 20 | } 21 | i++; 22 | } 23 | 24 | printf("La nuova parola è %s\n",parola); 25 | 26 | } -------------------------------------------------------------------------------- /codice/070_funzioni/massimo-di-tre.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int massimo(int a, int b) { 4 | if (a > b) 5 | return a; 6 | else 7 | return b; 8 | // return a > b ? a : b; 9 | } 10 | 11 | int massimo3(int a, int b, int c) { 12 | return massimo(massimo(a, b), c); 13 | } 14 | 15 | int massimo4(int a, int b, int c, int d) { 16 | // return massimo(massimo(massimo(a,b), c), d); 17 | // return massimo(a, massimo3(b, c, d)); 18 | return massimo(massimo(a, b), massimo(c, d)); 19 | } 20 | 21 | int main() { 22 | int a, b, c; 23 | printf("inserisci tre interi\n"); 24 | scanf("%d%d%d", &a, &b, &c); 25 | printf("Il massimo è %d\n", massimo3(a, b, c)); 26 | } 27 | -------------------------------------------------------------------------------- /codice/095_stringhe/to_uppercase_versione_3.c: -------------------------------------------------------------------------------- 1 | // legge da input una stringa e la stampa con le lettere minuscole sostituite 2 | // dalle corrispondenti maiuscole 3 | 4 | // input : Ferrara 5 | // output: FERRARA 6 | 7 | #include 8 | 9 | #define DIM 51 10 | 11 | char maiuscola(char c) { 12 | if (c >= 'a' && c <= 'z') 13 | return c - ('a' - 'A'); 14 | else 15 | return c; 16 | } 17 | 18 | int main() { 19 | char s[DIM]; 20 | char s2[DIM]; 21 | char c; 22 | int i; 23 | scanf("%s", s); 24 | i = 0; 25 | do { 26 | s2[i] = maiuscola(s[i]); 27 | i++; 28 | } while (s[i] != '\0'); 29 | s2[i] = '\0'; 30 | printf("%s\n", s2); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /esami/20200219/listaUtenti.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | char numero[11]; 3 | char piano; 4 | float credito; 5 | } Record; 6 | 7 | // questa struttura serve per la parte 2 8 | typedef struct { 9 | float costoScattoRisposta; 10 | int durataScatto; 11 | float costoUnitario; 12 | } Piano; 13 | 14 | typedef struct { 15 | char numero[11]; 16 | Piano piano; 17 | float credito; 18 | } Utente; 19 | 20 | typedef struct nodo { 21 | Utente dato; 22 | struct nodo* next; 23 | } Nodo; 24 | 25 | typedef Nodo* Lista; 26 | 27 | float costo(int secondi, Piano p); 28 | void insTesta(Lista* pl, Utente d); 29 | void aggiorna(Lista l, char numero[11], int durata); 30 | void stampa(Lista l); -------------------------------------------------------------------------------- /codice/140_file_binari/lettura_binaria.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct { 5 | char cognome[31]; 6 | char nome[31]; 7 | char sesso; 8 | int anno_nascita; 9 | } Persona; 10 | 11 | int main() { 12 | Persona persone[100]; 13 | FILE* pfb; 14 | int dl, i; 15 | pfb = fopen("people.dat", "rb"); 16 | if (pfb == NULL) { 17 | printf("Errore apertura people.dat\n"); 18 | exit(1); 19 | } 20 | dl = fread(persone, sizeof(Persona), 100, pfb); 21 | fclose(pfb); 22 | for (i = 0; i < dl; i++) 23 | printf("%s %s %c %d\n", persone[i].cognome, persone[i].nome, 24 | persone[i].sesso, persone[i].anno_nascita); 25 | return 0; 26 | } -------------------------------------------------------------------------------- /esami/20221108-parziale/Esercizio1-turno2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int radice(int n) { 4 | int a, b; 5 | a = 1; 6 | b = n; 7 | while (a < b) 8 | if (a * a + b * b < 2 * n) 9 | a++; 10 | else 11 | b--; 12 | if (n == a * b) 13 | return a; 14 | else 15 | return -1; 16 | } 17 | 18 | int main() { 19 | int n; 20 | int a[5]; 21 | int dl = 0; 22 | int i; 23 | printf("Inserisci un intero\n"); 24 | scanf("%d", &n); 25 | do { 26 | n++; 27 | if (radice(n) != -1) { 28 | a[dl] = n; 29 | dl++; 30 | } 31 | } while (dl < 5); 32 | for (i = 0; i < 5; i++) 33 | printf("%d ", a[i]); 34 | printf("\n"); 35 | return 0; 36 | } -------------------------------------------------------------------------------- /codice/060_espressioni/tipo-carattere.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | char carattere; 5 | scanf("%c", &carattere); 6 | // se carattere è una lettera maiuscola... 7 | if (carattere >= 'A' && carattere <= 'Z') 8 | printf("%c e` una maiuscola\n", carattere); 9 | // altrimenti se è una lettera minuscola 10 | else if (carattere >= 'a' && carattere <= 'z') 11 | printf("%c e` una lettera minuscola\n", carattere); 12 | // altrimenti se è una cifra 13 | else if (carattere >= '0' && carattere <= '9') 14 | printf("%c e` una cifra\n", carattere); 15 | // altrimenti sarà un altro tipo di carattere 16 | else 17 | printf("Il carattere inserito e` di altro tipo\n"); 18 | } -------------------------------------------------------------------------------- /codice/070_funzioni/differenza-fra-date-funzione-sottrazione.c: -------------------------------------------------------------------------------- 1 | #include 2 | int giorno_giuliano(int g, int m, int a) { 3 | int N0, N1, N2, N3; 4 | N0 = (m - 14) / 12; 5 | N1 = 1461 * (a + 4800 + N0) / 4; 6 | N2 = 367 * (m - 2 - 12 * N0) / 12; 7 | N3 = 3 * (a + 4900 + N0) / 400; 8 | return N1 + N2 - N3 + g - 32075; 9 | } 10 | 11 | main() { 12 | int G1, M1, A1; 13 | int G2, M2, A2; 14 | int JD1, JD2; 15 | printf("Prima data?\n"); scanf("%d%d%d", &G1, &M1, &A1); 16 | printf("Seconda data?\n"); scanf("%d%d%d", &G2, &M2, &A2); 17 | printf("La differenza e` %d\n", giorno_giuliano(G1, M1, A1) - 18 | giorno_giuliano(G2, M2, A2)); 19 | } 20 | -------------------------------------------------------------------------------- /codice/070_funzioni/differenza-fra-date-funzione.c: -------------------------------------------------------------------------------- 1 | #include 2 | int giorno_giuliano(int g, int m, int a) { 3 | int N0, N1, N2, N3; 4 | N0 = (m - 14) / 12; 5 | N1 = 1461 * (a + 4800 + N0) / 4; 6 | N2 = 367 * (m - 2 - 12 * N0) / 12; 7 | N3 = 3 * (a + 4900 + N0) / 400; 8 | return N1 + N2 - N3 + g - 32075; 9 | } 10 | 11 | int main() { 12 | int G1, M1, A1; 13 | int G2, M2, A2; 14 | int JD1, JD2; 15 | printf("Prima data?\n"); scanf("%d%d%d", &G1, &M1, &A1); 16 | JD1 = giorno_giuliano(G1, M1, A1); 17 | printf("Seconda data?\n"); scanf("%d%d%d", &G2, &M2, &A2); 18 | JD2 = giorno_giuliano(G2, M2, A2); 19 | printf("La differenza e` %d\n", JD2 - JD1); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /codice/070_funzioni/domani.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | int G, M, A; 5 | int giorni_del_mese; 6 | 7 | scanf("%d%d%d", &G, &M, &A); 8 | 9 | if (M == 4 || M == 6 || M == 9 || M == 11) 10 | giorni_del_mese = 30; 11 | else if (M == 2) 12 | if (A % 400 == 0 || (A % 4 == 0 && A % 100 != 0)) 13 | giorni_del_mese = 29; 14 | else 15 | giorni_del_mese = 28; 16 | else 17 | giorni_del_mese = 31; 18 | 19 | if (G == 31 && M == 12) 20 | printf("%d %d %d\n", 1, 1, A + 1); 21 | else if (G == giorni_del_mese) // ultimo giorno del mese 22 | printf("%d %d %d\n", 1, M + 1, A); 23 | else 24 | printf("%d %d %d\n", G + 1, M, A); 25 | return 0; 26 | } -------------------------------------------------------------------------------- /codice/070_funzioni/differenza-fra-date.c: -------------------------------------------------------------------------------- 1 | #include 2 | main() { 3 | int G, M, A, G1, M1, A1, G2, M2, A2; 4 | int N0, N1, N2, N3; int JD1, JD2; 5 | printf("Prima data?\n"); scanf("%d%d%d", &G1, &M1, &A1); 6 | N0 = (M1 - 14) / 12; 7 | N1 = 1461 * (A1 + 4800 + N0) / 4; 8 | N2 = 367 * (M1 - 2 - 12 * N0) / 12; 9 | N3 = 3 * (A1 + 4900 + N0) / 400; 10 | JD1 = N1 + N2 - N3 + G1 - 32075; 11 | printf("Seconda data?\n"); scanf("%d%d%d", &G2, &M2, &A2); 12 | N0 = (M2 - 14) / 12; 13 | N1 = 1461 * (A2 + 4800 + N0) / 4; 14 | N2 = 367 * (M2 - 2 - 12 * N0) / 12; 15 | N3 = 3 * (A2 + 4900 + N0) / 400; 16 | JD2 = N1 + N2 - N3 + G2 - 32075; 17 | printf("La differenza e` %d\n", JD2 - JD1); 18 | } 19 | -------------------------------------------------------------------------------- /tutorato/tutorato_01/regine.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int r1, c1, r2, c2; 5 | 6 | printf("Inserire le coordinate della prima regina:\n"); 7 | scanf("%d %d",&r1,&c1); 8 | 9 | printf("Inserire le coordinate della seconda regina:\n"); 10 | scanf("%d %d",&r2,&c2); 11 | 12 | if(r2==r1){ 13 | printf("Le regine sono sulla stessa riga\n"); 14 | } 15 | 16 | if(c2==c1){ 17 | printf("Le regine sono sulla stessa colonna\n"); 18 | } 19 | 20 | if(((r1-r2)==(c1-c2)) || ((r1-r2)== -1*(c1-c2))){ 21 | printf("Le regine sono sulla stessa diagonale\n"); 22 | } 23 | else { 24 | printf("Le regine non si attaccano\n"); 25 | } 26 | 27 | } -------------------------------------------------------------------------------- /esami/20191119-parziale/turno3/Esercizio1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 50 3 | 4 | int main() { 5 | float a[DIM]; 6 | int DL, i, j; 7 | // punto 1 8 | printf("Inserisci numeri reali (negativo termina)\n"); 9 | DL = 0; 10 | do { 11 | scanf("%f", &a[DL]); 12 | if (a[DL] < 0) 13 | break; 14 | DL++; 15 | } while (DL < 50); 16 | 17 | // punto 2 18 | for (i = 0; i < DL; i++) 19 | for (j = DL - 1; j > i; j--) 20 | if (a[j] < a[j - 1]) { // swap di a[j] e a[j-1] 21 | float t; 22 | t = a[j]; 23 | a[j] = a[j - 1]; 24 | a[j - 1] = t; 25 | } 26 | 27 | // punto 3 28 | for (i = 0; i < DL; i++) 29 | printf("%f ", a[i]); 30 | printf("\n"); 31 | } -------------------------------------------------------------------------------- /tutorato/tutorato_01/coordinate.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int x, y; 5 | 6 | printf("Inserire le coordinate del piano x y: "); 7 | scanf("%d %d", &x, &y); 8 | 9 | if(x > 0 && y > 0){ 10 | printf("Primo quadrante\n"); 11 | } 12 | else if(x < 0 && y > 0){ 13 | printf("Secondo quadrante\n"); 14 | } 15 | else if(x < 0 && y < 0){ 16 | printf("Terzo quadrante\n"); 17 | } 18 | else if(x > 0 && y < 0){ 19 | printf("Quarto quadrante\n"); 20 | } 21 | else if(x==0 && (y>0 || y<0)){ 22 | printf("Punto sull'asse y\n"); 23 | } 24 | else if((x > 0 || x < 0) && y == 0){ 25 | printf("Punto sull'asse x\n"); 26 | } 27 | else if(x == 0 && y== 0){ 28 | printf("Origine\n"); 29 | } 30 | 31 | } -------------------------------------------------------------------------------- /codice/130_file_di_testo/input-persone.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define NPERSONE 100 4 | 5 | typedef struct { 6 | char cognome[31]; 7 | char nome[31]; 8 | char sesso; 9 | int anno; 10 | } Persona; 11 | 12 | int main() { 13 | int dl; 14 | Persona persone[NPERSONE]; 15 | FILE* pf; 16 | char s[2]; 17 | pf = fopen("people.txt", "rt"); 18 | if (pf == NULL) { 19 | printf("Errore apertura file\n"); 20 | exit(1); 21 | } 22 | dl = 0; 23 | while (dl < NPERSONE && fscanf(pf, "%s%s%s%d", persone[dl].cognome, 24 | persone[dl].nome, s, &persone[dl].anno) == 4) { 25 | persone[dl].sesso = s[0]; 26 | dl++; 27 | } 28 | fclose(pf); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /codice/140_file_binari/lettura_binaria_v2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct { 5 | char cognome[31]; 6 | char nome[31]; 7 | char sesso; 8 | int anno_nascita; 9 | } Persona; 10 | 11 | int main() { 12 | Persona persone[100]; 13 | FILE* pfb; 14 | int dl, i; 15 | pfb = fopen("people.dat", "rb"); 16 | if (pfb == NULL) { 17 | printf("Errore apertura people.dat\n"); 18 | exit(1); 19 | } 20 | dl = 0; 21 | while (fread(&persone[dl], sizeof(Persona), 1, pfb) == 1) 22 | dl++; 23 | fclose(pfb); 24 | for (i = 0; i < dl; i++) 25 | printf("%s %s %c %d\n", persone[i].cognome, persone[i].nome, 26 | persone[i].sesso, persone[i].anno_nascita); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /codice/l03/divisori-primi.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int numero, n, i, j, numero_divisori_di_n; 5 | printf("Inserisci un numero naturale\n"); 6 | scanf("%d", &numero); 7 | for (n = 2; n <= numero; n++) { 8 | // S1 : n assume valori compresi fra 1 e n 9 | if (numero % n == 0) { 10 | // S2: n assume i valori divisori di n compresi fra 1 e n 11 | numero_divisori_di_n = 0; 12 | for (i = 2; numero_divisori_di_n == 0 && i * i <= n; i++) 13 | if (n % i == 0) { 14 | numero_divisori_di_n++; 15 | } 16 | 17 | if (numero_divisori_di_n == 0) { 18 | // n assume i valori divisori primi di numero 19 | printf("%d\n", n); 20 | } 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /codice/l02/giorni-del-mese.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() { 4 | int anno, mese, n_giorni; 5 | printf("Inserisci mese e anno\n"); 6 | scanf("%d%d", &mese, &anno); 7 | 8 | // se è febbraio 9 | if (mese == 2) 10 | // se l'anno è bisestile 11 | if (anno % 4 == 0 && anno % 100 != 0 || anno % 400 == 0) 12 | // 29 13 | n_giorni = 29; 14 | // altrimenti 15 | else 16 | // 28 17 | n_giorni = 28; 18 | // altrimenti 19 | else 20 | // se è aprile, giugno, settembre o novembre 21 | if (mese == 4 || mese == 6 || mese == 9 || mese == 11) 22 | // 30 23 | n_giorni = 30; 24 | // altrimenti 25 | else 26 | // 31 27 | n_giorni = 31; 28 | 29 | printf("%d\n", n_giorni); 30 | } -------------------------------------------------------------------------------- /tutorato/tutorato_01/tris.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main(){ 4 | int x1, y1, x2, y2, x3, y3; 5 | 6 | printf("Inserire le coordinate dei tre punti: \n"); 7 | printf("\tPrimo punto:\n"); 8 | scanf("%d %d", &x1, &y1); 9 | printf("\tSecondo punto:\n"); 10 | scanf("%d %d", &x2, &y2); 11 | printf("\tTerzo punto:\n"); 12 | scanf("%d %d", & x3, &y3); 13 | 14 | // casi di vittoria 15 | // rispettivamente diagonale AltoSx-BassoDx || Fila Orizzontale || Fila Verticale || Digonale AltoDX - BassoSx 16 | if((x1==y1 && x2==y2 && x3==y3)||(x1==x2 && x2==x3)||(y1==y2 && y2==y3)||(x1+y1==4 && x2+y2==4 && x3+y3==4)) 17 | printf("VITTORIA!\n"); 18 | 19 | else 20 | printf("Nessuna vittoria"); 21 | 22 | } -------------------------------------------------------------------------------- /codice/090_array/parabola.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | float a, b, c; 4 | float ascisse[21], ordinate[21]; 5 | int i; 6 | // inizializzare ascisse 7 | // ascisse = [-1.0, -0.9, ... 0.9, 1.0 8 | 9 | for (i = 0; i < 21; i++) 10 | ascisse[i] = -1.0 + 0.1 * i; 11 | 12 | // richiedo all'utente i coefficienti 13 | printf("Inserisci i coefficienti\n"); 14 | scanf("%f%f%f", &a, &b, &c); 15 | 16 | // ordinate = map (a * elemento^2 + b * elemento + c, ascisse) 17 | for (i = 0; i < 21; i++) { 18 | ordinate[i] = a * ascisse[i] * ascisse[i] + b * ascisse[i] + c; 19 | } 20 | 21 | // stampa delle coppie ordinate 22 | for (i = 0; i < 21; i++) 23 | printf("<%.1f, %f>\n", ascisse[i], ordinate[i]); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /codice/l08/frazioni-1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef struct { 4 | int num; 5 | int den; 6 | } Frazione; 7 | 8 | Frazione frazione(int n, int d) { 9 | Frazione f; 10 | f.num = n; 11 | f.den = d; 12 | return f; 13 | } 14 | 15 | Frazione leggi() { 16 | int n, d; 17 | Frazione f; 18 | 19 | scanf("%d%d", &n, &d); 20 | f.num = n; 21 | f.den = d; 22 | return f; 23 | } 24 | 25 | void stampa_frazionaria(Frazione f) { 26 | printf("%d/%d", f.num, f.den); 27 | } 28 | 29 | void stampa_decimale(Frazione f) { 30 | printf("%f", (float)(f.num) / f.den); 31 | } 32 | 33 | int main() { 34 | Frazione a; 35 | a = leggi(); 36 | stampa_frazionaria(a); 37 | printf("\n"); 38 | stampa_decimale(a); 39 | printf("\n"); 40 | return 0; 41 | } -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/lista-ordinata/lista.c: -------------------------------------------------------------------------------- 1 | // implementazione ADT lista 2 | #include 3 | #include 4 | 5 | #include "lista.h" 6 | 7 | void nuova(Lista* pl) { 8 | pl->n_elementi = 0; 9 | } 10 | 11 | int piena(Lista* pl) { 12 | return pl->n_elementi == DIMENSIONE; 13 | } 14 | 15 | void ins_ord(Lista* pl, int n) { 16 | int i; 17 | if (piena(pl)) { 18 | printf("Errore: lista piena\n"); 19 | exit(1); 20 | } 21 | for (i = pl->n_elementi; pl->dati[i - 1] > n && i >= 1; i--) 22 | pl->dati[i] = pl->dati[i - 1]; 23 | pl->dati[i] = n; 24 | pl->n_elementi++; 25 | } 26 | 27 | void stampa(Lista l) { 28 | int i; 29 | for (i = 0; i < l.n_elementi; i++) 30 | printf("%d ", l.dati[i]); 31 | printf("\n"); 32 | } 33 | -------------------------------------------------------------------------------- /esami/20200203/listaUtenti.h: -------------------------------------------------------------------------------- 1 | typedef char CodiceFiscale[17]; 2 | 3 | typedef struct { 4 | CodiceFiscale cf; 5 | int ingressi[3]; // ogni elemento dell'array è il contatore degli ingressi 6 | // per una attività; 7 | // si potevano usare anche tre variabili, 8 | // così si semplifica leggermente il codice di aggiornamento 9 | int ingressiNegatiCons, tesseraValida; // campi usati nella parte 2 10 | } Utente; 11 | 12 | typedef struct nodo { 13 | Utente dato; 14 | struct nodo* next; 15 | } Nodo; 16 | 17 | typedef Nodo* Lista; 18 | 19 | void nuovaLista(Lista* pl); 20 | void insTesta(Lista* pl, Utente u); 21 | int aggiorna(Lista* pl, CodiceFiscale c, int attivita); 22 | int stampaResidui(Lista l); 23 | -------------------------------------------------------------------------------- /codice/210_liste_sequenziali/calorie/listaAlimento.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "listaAlimento.h" 6 | 7 | void caricaCalorie(char nomeFileBinario[], Lista* pl) { 8 | int numero; 9 | FILE* fb; 10 | fb = fopen(nomeFileBinario, "rb"); 11 | if (fb == NULL) { 12 | printf("Impossibile aprire %s\n", nomeFileBinario); 13 | exit(3); 14 | } 15 | pl->n_elementi = fread(pl->dati, sizeof(Alimento), DIMENSIONE, fb); 16 | fclose(fb); 17 | } 18 | 19 | float calorieAlimento(char nomeAlimento[], Lista l) { 20 | int i; 21 | for (i = 0; i < l.n_elementi; i++) 22 | if (strcmp(nomeAlimento, l.dati[i].nome) == 0) 23 | return l.dati[i].calorie; 24 | printf("Alimento non trovato\n"); 25 | exit(4); 26 | } -------------------------------------------------------------------------------- /codice/090_array/insertion-sort-per-quadrato.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define DIM 10 3 | 4 | int precede(int a, int b) { // sussiste la relazione di ordinamento fro a e b 5 | return a * a < b * b; 6 | } 7 | 8 | int main() { 9 | int a[DIM]; 10 | int DL, dlo; 11 | int n, i; 12 | 13 | // input 14 | DL = 0; 15 | while (DL < DIM) { 16 | scanf("%d", &n); 17 | if (n != 0) { 18 | a[DL] = n; 19 | DL++; 20 | } else 21 | break; 22 | } 23 | 24 | for (dlo = 0; dlo < DL; dlo++) { 25 | int j = dlo, m = a[dlo]; 26 | while (j > 0 && precede(m, a[j - 1])) { 27 | a[j] = a[j - 1]; 28 | j--; 29 | } 30 | a[j] = m; 31 | } 32 | 33 | for (i = 0; i < DL; i++) 34 | printf("%d ", a[i]); 35 | printf("\n"); 36 | return 0; 37 | } --------------------------------------------------------------------------------