Slides 79 113

Università di Sassari - A.A.
2020-2021
Strutture di controllo
• Strutture di controllo: selezione multipla
int choice = 3;
switch (choice)
{
case 1 : statement1 ; choice ==1 ….
break; /* optional */
case 2 : statement2 ;
break; /* optional */ choice ==2 ….
case 3 : statement3 ;
break; /* optional */
…
default : default statement;
} caso default
Fondamenti di Informatica
NB: significato del break 79
Università di Sassari - A.A. 2020-2021
• Strutture di controllo: while
int x=0; no
int y = 2; x<4
while(x<4) {
si
x ++;
x++
y = y*y;
}
y=y*y
printf(“%d”,y);
Stampa y
Fondamenti di Informatica 80
• Strutture di controllo: while
int x=0; no
int y = 2; x<4
while(x<4) {
si
x ++;
x++
y = y*y;
}
y=y*y
printf(“%d”,y);
Stampa y
• Strutture di controllo: do while
int x=0;
int y = 2;
do { x++
x ++;
y = y*y; y=y*y
} while(x<4);
printf(“%d”,y); x<4
si
no
Stampa y
• Strutture di controllo: cicli definiti

I=0
for(int I=0; I<10; I++) {

printf(“%d”,I);
no
}
I<10
si
NB: non è diverso da un while
Stampa I
I++
Classwork
si chiede all'utente di inserire numeri in sequenza e sommare i
numeri inseriti ma solo se sono numeri pari. Ad ogni ciclo il
programma deve restituire la somma parziale. Il programma
deve uscire quando l’utente inserisce il numero 0.
• Esempio:
➔
2 (inserimento utente)
➔
2 (risposta programma)
➔
➔
➔
➔
➔
➔
(fine programma)
Classwork
si chiede all'utente di calcolare la seguente serie numerica
Procedere prima sommando solo 100 elementi.
Verificare che aumentando il numero di elementi la serie tende al

valore 0.5
Mettere in atto una strategia di uscita che consenta di chiudere il

programma quando la differenza tra due elementi successivi della
serie scende sotto il valore 0,0001
Stampare il valore raggiunto da n in tale caso
#include <stdio.h> //header file section
/***************main function****************/
int main()
{
int n;
float sommatoria=0;
float eps;
n=0;
do{
n++;
eps = (1.0 / (4 * n * n - 1));
sommatoria = sommatoria + eps;
} while (eps > 0.000001);
printf ("\n Valore della sommatoria: %f n= %d",sommatoria, n);
return 0;
}
Classwork
Il programma deve chiedere all'utente una stringa di ingresso.
Deve essere restituita una nuova stringa di uscita che contiene la

stessa stringa di ingresso a cui sono state eliminate le vocali, siano
esse maiuscole o minuscole.
Si chiede di stampare il numero di vocali eliminate.
Per semplicita' non si considerano le vocali accentate.
int cont
char cx
START
Leggi cx
cont=0
si no
cx!= vocale?
Stampa messaggio Stampa cx cont ++

chiedendo all’utente
l’inserimento di una stringa
no
cx !=NL
si Stampa cont END
/***************main function****************/
int main()
{
char cx;
int delta='a'-'A';
int cont=0;
printf("Insert a string followed by ENTER\n");
do{
cx=getchar();
if(cx!=65 && cx!=69 && cx!=73 && cx!=79 && cx!=85 && cx!=(65+delta) &&
cx!=(69+delta) && cx!=(73+delta) && cx!=(79+delta) && cx!=(85+delta))
putchar(cx);
else cont++;
}while (cx != '\n');
printf("\n%d vowels deleted", cont);
return 0;
}
int main() {
char cx;
int cont=0;
while((cx=getchar()) != '\n'){
switch(cx){
case 65: cont++;break;
default: putchar(cx);
}
};
return 0;
}
int main() {
char cx;
int cont=0;
switch(cx){
case 79: cont++;
case 85: cont++;
}
};
return 0;
}
int main() {
char cx;
int cont=0;
switch(cx){
case 65:
case 69:
case 73:
case 79:
case 85:
case 97:
case 101:
case 105:
case 111:
}
};
return 0;
}
Homework
Si chiede all'utente di inserire una frase. Il programma calcola
automaticamente il numero di parole della frase e il numero di
occorrenze di ogni vocale (senza distinzione tra maiuscola e
minuscola).
• Esempio:
➔
Ho fame e ho sonno (inserimento utente)
➔
La frase contiene 5 parole
➔
A: 1
➔
E: 2
➔
I: 0
➔
O: 4
➔
U: 0
➔
(fine programma)
• Strutture di controllo: break/continue
L’istruzione break consente di uscire da un loop immediatamente

(nb solo da un livello di loop)
L’istruzione continue consente di evitare le restanti istruzioni del

ciclo in corso e passare direttamente al prossimo ciclo
Notare bene la differenza con “return” (uscita da funzione) ed

“exit” (uscita da programma)
int val; //global
/***************call function****************/
void printIfBetween()
{ int i;
for(i = 0; i <=100; ++i) {
if(i == val){
printf("The value %d is between 0 and 100\n", val);
break; // leave the for loop asap
}
}}
/***************main function****************/
int main()
{ int i;
for(i = 0; i < 3; ++i){
printf("Insert an integer\n");
scanf("%d",&val);
printIfBetween();
}}
int val; //global
/***************call function****************/
void printIfBetween()
{ int i;
for(i = 0; i <=100; ++i) {
if(i != val){
continue; //just skip the print
}
printf("The value %d is between 0 and 100\n", val);
}}
/***************main function****************/
int main()
{ int i;
for(i = 0; i < 3; ++i){
printf("Insert an integer\n");
scanf("%d",&val);
printIfBetween();
}}
• Cicli nidificati
#include <stdio.h>
#include <stdlib.h>
int main()
{ int a,b;
int f;
for(a=0;a<=1;a++){
for(b=0;b<=1;b++){
f=!((!a)||b) && a;
printf("A=%d B=%d : %d\n",a,b,f);
}
}
exit(0);
}
Classwork
Il programma deve calcolare in modo automatico tutti i numeri
primi tra 1 e 1000.
NB: usare cicli nidificati e considerare che un numero primo è

divisibile solo per 1 e se stesso.
#include <stdio.h>
int main () {
int i, j; /* local variable definition */

for(i = 2; i<1000; i++) {
for(j = 2; j <= (i/j); j++)
if(!(i%j)) break; // if factor found, not prime
if(j > (i/j)) printf("%d is prime\n", i);
}
}
Notare la struttura del diagramma di flusso
#include <stdio.h>
int main () {
int i, j; /* local variable definition */

for(i = 2; i<1000; i++) {
j=2;
while (j<=(i/j) && (i%j)) j++;
if(j > (i/j)) printf("%d is prime\n", i);
}
}
Notare la struttura del diagramma di flusso

Tipi strutturati
Break-Continue (come evitarli)
i=0 i=0
i<10 i<10
SI SI
ISTR x ISTR x
BREAK CONT
TEST TEST
È un
ISTR y ISTR y
if-else!
i=i+1 i=i+1

Tipi strutturati
Break-Continue (come evitarli)
i=0
i=0 V=0
i<10
i<10
&& !V
SI SI
ISTR x ISTR x
BREAK BREAK
TEST TEST
V=1
ISTR y ISTR y
i=i-1
i=i+1
i=i+1

Tipi strutturati
• Array
La dichiarazione ha una forma semplice:
int my_list[50];
char my_string[100];
Anche con più dimensioni:
int my_matrix[50][50][50];

Tipi strutturati
Notare bene:
– le celle sono indicizzate a partire dal valore 0 fino a 99
– per inizializzare un array occorre utilizzare un ciclo iterativo:
#include <stdio.h>
int main ()
{
int index, my_array[10];
for (index = 0; index < ARRAY_SIZE; index++) {
my_array[index] = 0;
}
}

Tipi strutturati
Notare bene:
– Esiste un modo alternativo per inizializzare un array:
int my_array[3][3] =
{
{10, 23, 42},
{1, 654, 0},
{40652, 22, 0}
};

Tipi strutturati
Classwork:
Si chiede all'utente di inserire una frase. Il programma calcola
automaticamente il numero di parole della frase e il numero di
occorrenze di ogni lettera (con distinzione tra maiuscola e
minuscola).
Svolgere l’esercizio utilizzando:

- un array (globale) per contare le lettere
- un array (globale) per leggere la frase
- la funzione di libreria isspace(ch) per verificare se il carattere
ch è un carattere di spaziatura
' ' (0x20) space (SPC)
'\t' (0x09) horizontal tab (TAB)
'\n' (0x0a) newline (LF)
'\v' (0x0b) vertical tab (VT)
'\f' (0x0c) feed (FF)
'\r' (0x0d) carriage return (CR)
Tipi strutturati
#include <stdio.h>
#include <ctype.h> //classificazione char
int main() {
char fr[101];
int cont[256];
int contaParole=0;
int i;
for(i=0;i<256; i++) cont[i]=0;
printf("Inserire una frase max 100 caratteri:\n");
// lettura frase
i=0;
while( (fr[i++]=getchar()) != '\n' && i<100);
fr[i]= '\0';

Tipi strutturati
i=0;
while( isspace(fr[i])) i++;
while( fr[i] != '\0')
{
while( !isspace(fr[i])) {
cont[0xff&fr[i]]++;
i++;
}
contaParole++ ;
while( isspace(fr[i])) i++;
}
printf("Il numero di parole e' %d a:%d b:%d c:%d\n",
contaParole , cont['a'], cont['b'] , cont['c'] );

Tipi strutturati
Classwork:
Inizializzare un array di float di dimensione 10, chiedendo i

numeri all'utente.
• Individuare e stampare il massimo tra i dieci numeri inseriti.
• Individuare e stampare la posizione del massimo nell’array

Tipi strutturati
Soluzione
int i
float N [10] max=N[0]
float max imax=0
Stampa max
int imax START
Stampa imax
i=1
Stampa messaggio
END
i=0 max<N[i]
no si
max=N[i]
imax=i
i<10
SI
i=i+1
Leggi N[i]
i=i+1
i<10

Tipi strutturati
#include <stdio.h>
int main () {
int i, imax;
float N[10], max;
for (i=0;i<10;i++) {
printf(" inserire float\n");
scanf("%f",&N[i]);
}
max = N[0];
imax=0;
i = 1;
do {
if(max<N[i]) {
max = N[i];
imax=i;
}
i=i+1;
} while(i<10);
printf("Massimo: %f Posizione: %d ", max, imax);
return 0;
}
Tipi strutturati
Homework:
• Inizializzare un array di float di dimensione 10, chiedendo i

numeri all'utente.
• Riprendere gli esempi di ordinamento trasparenze (slide 19 e
20) ed implementarli in C per il vettore suddetto
• Verificare che i due algoritmi diano risultato identico
• Calcolare, per ognuno dei due algoritmi, il numero di

operazioni elementari svolte e verificare la congruenza di tale
risultato con l’ordine di complessità teorico degli stessi

Tipi strutturati
Homework:
•Implementare l’algoritmo del crivello di Eratostene per la
ricerca dei numeri primi.
• Verificare che il numero di operazioni elementari è inferiore a
quello dell’algoritmo semplice della trasparenza n. 100
ALGORITMO SU VETTORE DI DIMENSIONE n
Tentativamente, marca tutti i numeri 2,3,4,...,n come primi
i=2
Finché i <= ⌊sqrt(n)⌋
trova il primo numero j >= i marcato come primo
smarca i numeri 2*j, 3*j, ....,⌊n/j⌋ * j
i=i+1
Stampa i numeri ancora marcati

Slides 79 113

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Slides 79 113

Caricato da

Copyright:

Formati disponibili

Università di Sassari - A.A.

• Strutture di controllo: selezione multipla

• Strutture di controllo: while

• Strutture di controllo: while

• Strutture di controllo: do while

• Strutture di controllo: cicli definiti

for(int I=0; I<10; I++) {

Procedere prima sommando solo 100 elementi.

Verificare che aumentando il numero di elementi la serie tende al

Mettere in atto una strategia di uscita che consenta di chiudere il

Stampare il valore raggiunto da n in tale caso

Deve essere restituita una nuova stringa di uscita che contiene la

Si chiede di stampare il numero di vocali eliminate.

Per semplicita' non si considerano le vocali accentate.

Stampa messaggio Stampa cx cont ++

si Stampa cont END

• Strutture di controllo: break/continue

L’istruzione break consente di uscire da un loop immediatamente

L’istruzione continue consente di evitare le restanti istruzioni del

Notare bene la differenza con “return” (uscita da funzione) ed

NB: usare cicli nidificati e considerare che un numero primo è

int i, j; /* local variable definition */

Notare la struttura del diagramma di flusso

int i, j; /* local variable definition */

Notare la struttura del diagramma di flusso

Fondamenti di Informatica 100

Break-Continue (come evitarli)

Fondamenti di Informatica 101

Break-Continue (come evitarli)

Fondamenti di Informatica 102

Anche con più dimensioni:

Fondamenti di Informatica 103

Fondamenti di Informatica 104

Fondamenti di Informatica 105

Svolgere l’esercizio utilizzando:

printf("Inserire una frase max 100 caratteri:\n");

Fondamenti di Informatica 107

Fondamenti di Informatica 108

Inizializzare un array di float di dimensione 10, chiedendo i

Fondamenti di Informatica 109

Fondamenti di Informatica 110

• Inizializzare un array di float di dimensione 10, chiedendo i

• Calcolare, per ognuno dei due algoritmi, il numero di

Fondamenti di Informatica 112

Fondamenti di Informatica 113

Potrebbero piacerti anche