Esercizi
© Piero Demichelis
1
Equazione di II grado
Legge i coefficienti a, b e c
a = 0?
si
si
si
c = 0?
Equazione
indeterminata
no
b = 0?
no
no
delta = b*b – 4*a*c
Equazione di I grado:
x= -(c / b)
Equazione
impossibile
no
delta = 0?
w = 2*a
w1= -(b / w)
w2= | delta | / w
delta < 0?
no
si
Radice reali:
x1= w1+ w2 x2= w1- w2
© Piero Demichelis
si
Radice doppia
x = -(b / (2 * a))
Radice complesse
coniugate: x = w1± j w2
2
Equazione di II grado
#include <stdio.h>
#include <math.h>
float a, b, c, delta;
float x1, x2, w, w1, w2, mdelta;
main()
{
printf ("Coeff. a = ");
scanf ("%f",&a);
printf ("\nCoeff. b = ");
scanf ("%f",&b);
printf ("\nCoeff. c = ");
scanf ("%f",&c);
/* legge i tre coefficienti a, b, c */
© Piero Demichelis
3
Equazione di II grado
if (a == 0)
/* a = 0?
{
/* si, non è di II grado!
if (b == 0)
/* b = 0?
if (c == 0)
/* si, non è neppure di I grado!
printf ("\nEquazione indeterminata\n");
else
printf ("\nEquazione impossibile\n");
else
{
/* b diverso da 0; è di I grado!
x1 = - (c / b);
printf (“\nEquazione di I grado: x = %f\n", x1);
}
}
else
/* a è diverso da 0; è di II grado!
© Piero Demichelis
*/
*/
*/
*/
*/
*/
4
Equazione di II grado
{
/* a è diverso da 0 è di II grado! */
delta = b * b - 4 * a * c;
w = 2 * a;
w1 = - (b / w);
mdelta = delta;
if (mdelta < 0 ) mdelta = - mdelta;
w2 = sqrt (mdelta) / w; / * radice quadrata del discriminante */
if (delta == 0)
/* discriminante nullo? */
printf (“\nRadice doppia: x=%f\n", w1);
/* si */
else
{
/* no, il discriminante è diverso da 0 */
if (delta < 0)
/* discriminante < 0? */
{
/* si */
printf ("\nRadici complesse e coniugate:\n");
printf ("parte reale= %f ", w1);
printf (" parte immag.= %f\n", w2);
}
© Piero Demichelis
5
Equazione di II grado
else
{
/* no, discriminante > 0 */
x1 = w1 + w2;
/* calcola le due soluzioni */
x2 = w1 - w2;
printf ("\n Radici reali: x1= %f\n x2= %f\n", x1, x2);
}
}
/* chiusura dell’else di “if (delta == 0) “ */
}
/* chiusura dell’else di “if (a == 0) “ */
}
/* fine del main */
© Piero Demichelis
6
Lire / Euro
Programma per la conversione Lire/Euro e viceversa.
L'input del programma sia la lettera L per Lire o E per
Euro, seguita da uno spazio e dalla cifra da convertire:
nel primo caso un'intero lungo, nel secondo caso un
reale.
Esempio di esecuzione:
> Introduci la richiesta:
>L
15000000
>15000000 lire corrispondono a 7746.85 euro
© Piero Demichelis
7
Lire / Euro
• Analisi.
A seconda che il primo parametro introdotto (che è un
carattere) sia ‘L’ oppure ‘E’ occorre eseguire in modo
differenziato la lettura successiva:
di un intero lungo se era ‘L’;
di un float se era ‘E’;
La lettura va pertanto suddivisa in due fasi: dapprima si
legge un carattere e poi, in base al valore di questo
carattere, si esegue la lettura di un intero o di un float.
© Piero Demichelis
8
Lire / Euro
#include <conio.h>
#include <stdio.h>
/*
solo per Turbo C
*/
solo per Turbo C
*/
legge un carattere
*/
#define rapp 1936.27
main()
{
long int lire;
double euro;
char carat;
clrscr();
/*
printf ("\nIntrodurre la richiesta: ");
scanf ("%c", &carat);
/*
© Piero Demichelis
9
Lire / Euro
if (carat == 'L')
{
/*
è L?
*/
scanf ("%ld", &lire);
/* si, legge le lire */
euro = (float)lire / rapp;
/* converte in euro
*/
printf ("\n%ld lire equivalgono a %lf euro\n", lire, euro);
}
else
if (carat == 'E') {
/* non è L, è E? */
scanf ("%lf ", &euro);
/* si, legge gli euro */
lire = (int)(euro * rapp);
/* converte in lire */
printf ("\n%lf euro equivalgono a %ld lire\n", euro, lire);
}
else
/* non è né L né E, errore! */
printf ("\nCarattere non lecito\n");
}
© Piero Demichelis
10
Anno bisestile
Scrivere un programma che legga da tastiera un valore
intero rappresentante un anno e stabilisca se è o meno
un anno bisestile.
Si ricordi che un anno per essere bisestile deve essere
divisibile per 4 ma non per 100 a meno che sia divisibile
per 400.
Ad esempio il 2004 è un anno bisestile così come il 2000
mentre non lo è il 1900.
© Piero Demichelis
11
Anno bisestile
• Uso una variabile logica che chiamo bisestile, posta al
valore vero se l’anno è bisestile, al valore falso altrimenti.
• Pseudocodice
- Ipotizzo che non sia bisestile (bisestile = falso);
- divisibile per 4 ?
• si, ipotizzo sia bisestile (bisestile = vero);
• divisibile anche per 100 ?
si,
divisibile per 400 ?
 se no non è bisestile (bisestile = falso);
- Visualizzo il risultato
© Piero Demichelis
12
Anno bisestile
#include <conio.h>
#include <stdio.h>
#define falso 0
#define vero 1
/*
solo per Turbo C
*/
main()
{
int anno;
int bisestile;
clrscr();
/*
solo per Turbo C
printf ("\nIntrodurre l’anno: ");
scanf ("%d", &anno);
bisestile = falso;
/* ipotizza che non sia bisestile
© Piero Demichelis
*/
*/
13
Anno bisestile
if ((anno % 4) == 0)
{
bisestile = vero; /* divisibile per 4: potrebbe essere bisestile */
if ((anno % 100) == 0)
/* divisibile per 100? */
{
if ((anno % 400) != 0)
/* si, divisibile per 400? */
bisestile = falso;
/* no, non bisestile */
}
}
if (bisestile)
printf ("\n Bisestile!");
else
printf ("\n Non Bisestile!");
}
© Piero Demichelis
14
Fattoriale
Realizzare un programma per il calcolo del fattoriale.
Si ricorda che il fattoriale è definito come:
n! = n · (n-1) · (n-2)….. · 2 · 1
• con 0! = 1
- legge da tastiera il valore di n (compreso tra 0 e val_max);
- Inizializza fattoriale (cioè il risultato) a 1;
- finché n è maggiore di zero:
• moltiplica fattoriale per n ed attribuisci il risultato a fattoriale;
• decrementa n di un unità;
- visualizza fattoriale.
© Piero Demichelis
15
Fattoriale
#include <stdio.h>
#define val_max 12
main ()
{
long int n, totale;
printf (“\nFattoriale di: ");
scanf ("%ld", &n);
totale = 1;
© Piero Demichelis
16
Fattoriale
if ((n >= 0) && (n <= val_max))
{
while (n > 0)
{
totale *= n;
n--;
}
printf ("\nFattoriale di %ld = %ld\n", n, totale);
else
{
printf ("\nFattoriale non calcolabile, ");
printf ("introdurre valori compresi tra 0 e %d", val_max);
}
}
© Piero Demichelis
17
MCD
Scrivere un programma in linguaggio C che prenda in input da
tastiera tre numeri interi e ne calcoli il massimo comune divisore.
Il massimo comune divisore è il più grande tra i divisori comuni ai
tre numeri.
Le soluzioni possibili sono numerose, più o meno eleganti, ne
proponiamo due:
1. con un indice che cresce da 1 a uno qualsiasi dei tre numeri si
cerca i divisori comuni: l’ultimo trovato è il mcd;
2. si cerca il minimo tra i tre numeri e poi, a partire da quel
minimo e decrementando a ogni ciclo si cerca il primo divisore
comune che è proprio il mcd.
© Piero Demichelis
18
MCD (1a soluzione)
#include <stdio.h>
main()
{
int x1, x2, x3, ind, mcd, min;
printf ("\nIntroduci il primo numero: ");
scanf ("%d", &x1);
printf ("\nIntroduci il secondo numero: ");
scanf ("%d", &x2);
printf ("\nIntroduci il terzo numero: ");
scanf ("%d", &x3);
for (ind = 1; ind <= x1; ind++)
if ((x1 % ind) == 0 && (x2 % ind) == 0 && (x3 % ind) == 0)
mcd = ind;
printf("\nMCD = %d", mcd);
}
© Piero Demichelis
19
MCD (2a soluzione)
#include <stdio.h>
#define falso 0
#define vero 1
main()
{
int x1, x2, x3, trovato, mcd, min;
printf ("\nIntroduci il primo numero: ");
scanf ("%d", &x1);
min = x1;
printf ("\nIntroduci il secondo numero: ");
scanf ("%d", &x2);
if (x2 < min) min = x2;
© Piero Demichelis
20
MCD (2a soluzione)
printf ("\nIntroduci il terzo numero: ");
scanf ("%d", &x3);
if (x3 < min) min = x3;
trovato = falso;
while (!trovato)
if ((x1%min == 0) && (x2%min == 0) && (x3%min == 0))
{
mcd = min;
trovato = vero;
}
else
min--;
printf ("\nMCD = %d", mcd);
© Piero Demichelis
21
Matrice
• Realizzare un programma in C che richieda da tastiera
due interi M e N e generi una matrice M x N. Gli elementi
della matrice (ai,j), con i che varia da 1 a M e j che varia
da 1 a N, devono essere calcolati mediante la relazione:
• ai,j = i * j
• Infine occorre visualizzare la matrice sottoforma di
tabellina.
• Esempio: se N = 2 e M = 3 si deve visualizzare:
1
2
2
4
3
6
© Piero Demichelis
22
Matrice
#include <stdio.h>
#include <stdlib.h>
#define NMAX 30
int main ()
{
int matrice[NMAX][NMAX];
int righe, col, i, j;
printf ("\nNumero di righe: ");
scanf ("%d",&righe);
printf ("\nNumero di colonne: ");
scanf ("%d",&col);
© Piero Demichelis
23
Matrice
for (i=1; i <= righe; i++)
for (j=1; j <= col; j++)
{
matrice[i][j] = i*j;
printf (" %4d ", matrice[i][j]);
}
printf ("\n");
}
/* fine programma */
Oppure (senza usare la struttura dati matrice):
for (i=1; i <= righe; i++)
for (j=1; j <= col; j++)
printf (" %4d ", i * j);
printf ("\n");
}
/* fine programma */
© Piero Demichelis
24
Matrice (2)
• Leggere da tastiera la dimensione di una matrice
quadrata di numeri interi.
• Successivamente leggere ancora da tastiera i valori di
tutti gli elementi della matrice.
• Infine calcolare e visualizzare la somma degli elementi
della diagonale principale e il valor medio degli elementi
della diagonale secondaria
© Piero Demichelis
25
Matrice (2)
#include <stdio.h>
#include <conio.h>
#define MAX 10
/* dimensione massima */
void main()
{
int num_r, riga, col;
int matrix[MAX][MAX];
long sommaprinc=0;
long sommasec=0;
clrscr();
printf (“\nDimensione della matrice: ");
scanf ("%d", &num_r);
© Piero Demichelis
26
Matrice (2)
/* Riempimento della matrice
*/
for (riga=1; riga<=num_r; riga++)
for (col=1; col<=num_r; col++)
{
printf ("\nelemento %d %d : ", riga, col);
scanf ("%d", &matrix[riga][col]);
}
/* Somma gli elementi sulle due diagonali */
for (riga=1; riga<=num_r; riga++)
{
sommaprinc += matrix[riga][riga];
sommasec += matrix[riga][num_r+1-riga];
}
© Piero Demichelis
27
Matrice (2)
/* Visualizza risultati
*/
printf ("\nLa somma è %ld", sommaprinc);
printf ("\nLa media è %lf", (double)sommasec/(double)num_r);
}
© Piero Demichelis
28
Coseno
• Realizzare una funzione per il calcolo del coseno di un
angolo espresso in radianti. Utilizzare allo scopo lo
sviluppo in serie:
2
4
6
x
x
x
cos  x   1 



2! 4! 6!
• Realizzare inoltre il programma di prova che confronti il
valore dalla funzione di libreria cos(x) col valore calcolato
con lo sviluppo in serie.
© Piero Demichelis
29
Coseno
• Osservando la formula dello sviluppo in serie si vede
come ogni termine può essere ricavato dal precedente
come per il seno, con la relazione ricorrente:
x  x
fatt  fatt. prec. 
 N  1   N  2 
• La differenza sta nelle inizializzazioni:
- il primo termine ora vale 1
- il denominatore n parte da 0
© Piero Demichelis
30
Coseno
#include <stdio.h>
#include <math.h>
/* prototipo della funzione */
double cosenox(double x);
main()
{
double angolo;
printf (“\nAngolo in radianti: ");
scanf ("%lf", &angolo);
printf ("\nCoseno di %lf = %lf", angolo, cosenox(angolo));
printf("\nLa funzione di libreria fornisce %lf ", cos(angolo));
}
© Piero Demichelis
31
Coseno
/* funzione per il coseno x */
double cosenox(double x)
{
const double soglia = 0.00005;
double accosenx, termine, termass, n;
/* Inizializzazione variabili */
termine = 1;
/* primo termine */
n = 0;
/* denominatore */
accosenx = 1;
/* accumulatore di risultato */
termass = 1;
/* valore assoluto del primo termine */
© Piero Demichelis
32
Coseno
while (termass > soglia)
{
/* contributo del nuovo termine */
termine *= -x * x /((n+1) * (n + 2));
/* accumula in accosenx
*/
accosenx += termine;
/* aggiorna il denominatore */
n += 2;
/* ricava valore assoluto del termine appena calcolato */
termass = fabs(termine);
}
return (accosenx);
}
© Piero Demichelis
33
MCD di un insieme di numeri
• Leggere da tastiera la quantità di numeri sui quali ricercare
successivamente il MCD.
• Leggere poi quei numeri salvandoli in un vettore (di interi) e
successivamente calcolare e visualizzare il MCD.
• Analisi:
Il problema è simile al precedente basta estendere la ricerca del
divisore comune. Anziché tre numeri siamo ora in presenza di una
serie di numeri la cui consistenza non è nota al momento della
scrittura del programma. Risulta pertanto indispensabile memorizzare
la sequenza in un vettore di dimensioni opportune
il controllo sul resto ottenuto dalla divisione tra ogni numero e il
divisore (presunto MCD) dovrà necessariamente essere gestito
tramite un ciclo (for è il più adatto).
© Piero Demichelis
34
MCD di un insieme di numeri
#include <conio.h>
#include <stdio.h>
#define falso 0
#define vero 1
main()
{
int num, vett[100], mcd, min, i;
int trovato, noresto;
clrscr();
printf ("\nSu quanti numeri calcolo il MCD?: ");
scanf ("%d", &num);
© Piero Demichelis
35
MCD di un insieme di numeri
/* Legge i num numeri previsti mediante un ciclo for */
/* contemporaneamente trova il minimo controllando */
/* il loro valore man mano che vengono introdotti
*/
min = 32767;
/* massimo valore per un intero */
for (i = 0; i < num; i++)
{
printf ("\nIntroduci il numero di indice %d: ", i);
scanf ("%d", &vett[i]);
if (vett[i] < min) min = vett[i];
}
© Piero Demichelis
36
MCD di un insieme di numeri
trovato = falso;
while (!trovato)
{
noresto = vero;
for (i = 0; i < num; i++)
if (vett[i] % min != 0) noresto = falso;
if (noresto)
{
mcd = min;
trovato = vero;
}
else
min--;
}
printf ("\nMCD = %d", mcd);
}
© Piero Demichelis
37
Esempio: giorni nell’anno
• Realizzare un programma che legga da tastiera l’anno
di riferimento e la sigla del primo giorno di quell’anno
(1 gennaio) composta dai primi tre caratteri del nome
(ad esempio: 2003 mer) e visualizzi sul video una tabella
in cui sono indicati, per ogni mese dell’anno, quante
volte occorre ciacun giorno della settimana.
Si rammenta che sono bisestili gli anni divisibili per 4 ma,
tra quelli multipli di 100, solo quelli che sono divisibili per
400.
© Piero Demichelis
38
Esempio: giorni nell’anno
Esempio di tabella in uscita:
2003
lun
mar
mer
gio
ven
sab
dom
gen feb mar apr mag giu lug ago set ott nov dic
4 4
4 4
5 ecc.
5
5
4
4
© Piero Demichelis
39
Esempio: codice 2 su 5
Generare tutti i codici 2 su 5 (5 bit, di cui due bit devono essere a 1 e
tre bit a zero), li si memorizzi in un'opportuna base dati e li si
visualizzi sul videoterminale.
(Si rammenti che i codici binari possono essere visti come numeri
interi (senza segno), per cui è sufficiente generare tutti i codici di 5
bit e poi scartare quelli che non soddisfano la condizione di avere 2
bit ad uno e 3 a zero.)
Successivamente confrontare i codici a due a due e, per ciascuna
coppia, confrontare i bit a parità di posizione, conteggiando il
numero di bit diversi tra di loro (il numero di bit diversi viene detto
distanza tra i codici). Il programma calcoli e stampi il massimo e il
minimo della distanza tra i codici.
© Piero Demichelis
40