Introduzione al C. Proprietà degli elementi di un insieme. Claudio Ciccotelli

Transcript

1 Corso di Fondamenti di Informatica Ingegneria delle Comunicazioni BCOR Ingegneria Elettronica BELR Introduzione al C Proprietà degli elementi di un insieme Claudio Ciccotelli

2 Insiemi Un insieme è una collezione di oggetti detti elementi dell'insieme. In questo corso abbiamo visto alcune strutture dati C che possono rappresentare insiemi (o multi-insiemi quando gli elementi possono ripetersi): stringhe: insiemi (ordinati) di caratteri array: insiemi (ordinati) di elementi dello stesso tipo (es. array di int) matrici: possiamo vederle come insiemi di vettori (riga o colonna) argv: insieme di stringhe Pagina 2

3 Esempi Insieme di numeri interi A = {1, 4, 7, 10 int A[] = {1, 4, 7, 10; insieme: array di int elemento: int Insieme di reali B = {0, 1, 3.14, 2.72 double B[] = {0, 1, 3.14, 2.72; Pagina 3

4 Esempi (Multi-)insieme (ordinato) di caratteri "hello" char *s = "hello"; insieme: array di char (acceduto tramite un puntatore) elemento: char Pagina 4

5 Esempi Insieme di stringhe S = {"hello", "world", "C language" char *S[3]; S[0] = "hello"; S[1] = "world"; S[2] = "C language"; Es.: argv Pagina 5

6 Esempi Insieme di vettori M = {<1,2,3>, <4,5,6> Es. matrice allocata staticamente: int M[2][3] = {{1,2,3,{4,5,6; M insieme M[0] elemento 1: vettore <1,2,3> M[1] elemento 2: vettore <4,5,6> Pagina 6

7 Esempi Insieme di vettori M = {<1,2,3>, <4,5,6> Es. matrice allocata dinamicamente: M M insieme M[0] elemento 1: vettore <1,2,3> M[1] elemento 2: vettore <4,5,6> Pagina 7

8 Verifica di proprietà sugli elementi Un problema che si presenta spesso è verificare delle proprietà sugli elementi di un insieme. proprietà: si traduce in una condizione, es.: essere pari essere compreso tra 1 e 10 contenere il carattere 'A' oppure il carattere 'B' ecc. Pagina 8

9 Verifica di proprietà sugli elementi In particolare, spesso si è interessati a verificare se qualche/tutti/nessun elemento/i dell'insieme ha/hanno una certa proprietà. Possiamo identificare almeno 6 problemi Pagina 9

10 Problemi tipici Dati un insieme S e una certa proprietà P, verificare che: 1. almeno un elemento di S abbia la proprietà P. 2. tutti gli elementi di S abbiano la proprietà P. 3. nessun elemento di S abbia la proprietà P. 4. almeno N elementi di S abbiano la proprietà P. 5. esattamente N elementi di S abbiano la proprietà P. 6. non più di N elementi di S abbiano la proprietà P. Pagina 10

11 Problemi È evidente che tra i 6 problemi proposti, alcuni sono casi particolari di altri: Problema 1 = Problema 4 con N = 1 Problema 3 = Problema 6 con N = 0 Problema 2 = Problema 4 e 5 con N = numero di elementi dell'insieme Pagina 11

12 Problemi Inoltre alcuni dei problemi sono equivalenti. Per esempio, verificare che nessun elemento abbia una proprietà P, equivale a verificare che tutti gli elementi abbiano la proprietà P', dove P' è la proprietà di non avere la proprietà P Es.: verificare che nessun elemento sia pari equivale a verificare che tutti gli elementi NON siano pari. È facile dimostrare che I problemi 1,2 e 3 sono equivalenti; Il problema 4 e il problema 6 sono equivalenti; Problema 5 è equivalente a (Problema 4 && Problema 6); ecc Pagina 12

13 Problemi Ciò nonostante analizzeremo ciascuno dei 6 problemi separatamente e per ognuno vedremo una soluzione specifica. In generale la soluzione sarà un algoritmo che restituisce 1 se la verifica ha successo, 0 altrimenti. Pagina 13

14 NOTA L'intento di questa presentazione non è quello di fornire allo studente un ricettario per risolvere problemi di questo tipo, ma di farlo ragionare sulla metodologia generale che permette di risolverli. Imparare a memoria le soluzioni per ciascuno dei casi che vedremo richiederà certamente uno sforzo maggiore. Pagina 14

15 Problema 1 Verificare che almeno un elemento di un insieme S ha una proprietà P Equivale a trovare un elemento x di S che ha la proprietà P. Come risolvere il problema? Pagina 15

16 Non pensare a come risolverlo in C! Poiché noi non pensiamo in C (fortunatamente!) approcciare un problema pensando direttamente a come risolverlo in linguaggio C può risultare difficile (specie se abbiamo poca esperienza). L'ideale è descrivere la soluzione (anche solo mentalmente) con il formalismo che ci risulta più naturale/intuitivo (es.: sequenza di passi in linguaggio naturale, pseudo-codice, diagramma di flusso, ecc.) A questo punto "tradurre" la soluzione in linguaggio C sarà, il più delle volte, banale. Pagina 16

17 Problema 1 Soluzione (Flow Chart) Ho visto tutti gli elementi di S? Sì Restituisci 0 No No Considera un nuovo elemento x di S x ha la proprietà P? Sì Restituisci 1 Pagina 17

18 Problema 1 Soluzione Una volta individuata la soluzione (in questo caso come flow chart), procediamo a tradurla in codice C. Pagina 18

19 Problema 1 Soluzione Consideriamo la seguente istanza del Problema 1: "Verificare se un insieme di interi ha almeno un elemento pari" Pagina 19

20 Problema 1 Soluzione Insieme di interi: possiamo rappresentarlo in C come un array di int. Perciò la nostra funzione C prenderà in input un puntatore a int e un intero che rappresenta il numero di elementi: int almeno_un_pari(int *S, int n); La funzione restituirà 1 se la verifica ha successo, zero altrimenti. Pagina 20

21 Problema 1 Soluzione Proprietà: essere pari La proprietà si traduce in una condizione sul generico elemento x dell'insieme S: x % 2 == 0 (condizione vera se x è pari) Pagina 21

22 Problema 1 Soluzione Iniziamo a "tradurre" dobbiamo "visitare" gli elementi dell'insieme uno ad uno Ciclo int almeno_un_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { Pagina 22

23 Problema 1 Soluzione se l'elemento che sto considerando ha la proprietà P restituisci 1, altrimenti vai al prossimo elemento: int almeno_un_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { if (S[i] % 2 == 0) return 1; Pagina 23

24 Problema 1 Soluzione se ho visto tutti gli elementi ( non ho mai restituito 1 nessun elemento ha la proprietà P) restituisci 0: int almeno_un_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { return 0; if (S[i] % 2 == 0) return 1; Pagina 24

25 Problema 1 Errore Tipico int almeno_un_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { if (S[i] % 2 == 0) return 1; else return 0; Errore! Perché? Pagina 25

26 Problema 2 Verificare che tutti gli elementi di un insieme S hanno una proprietà P Equivale a non trovare un elemento di S che non ha la proprietà P. Come risolvere il problema? Pagina 26

27 Problema 2 - Soluzione Ho visto tutti gli elementi di S? Sì Restituisci 1 No Sì Considera un nuovo elemento x di S x ha la proprietà P? No Restituisci 0 Pagina 27

28 Problema 2 Soluzione Consideriamo la seguente istanza del Problema 2: "Verificare se un insieme di interi ha tutti gli elementi pari" Pagina 28

29 Problema 2 Soluzione "Traduciamo" in C insieme di interi: array di int condizione: essere pari int tutti_pari(int *S, int n); Pagina 29

30 Problema 2 Soluzione dobbiamo "visitare" gli elementi dell'insieme uno ad uno Ciclo int tutti_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { Pagina 30

31 Problema 2 Soluzione se l'elemento che sto considerando NON ha la proprietà P restituisci 0, altrimenti vai al prossimo elemento: int tutti_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { // se NON è pari restituisci 0 if (S[i] % 2!= 0) return 0; Pagina 31

32 Problema 2 Soluzione se ho visto tutti gli elementi ( non ho mai restituito 0 tutti gli elementi hanno la proprietà P) restituisci 1: int tutti_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { return 1; if (S[i] % 2!= 0) return 0; Pagina 32

33 Problema 2 Errore Tipico int tutti_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { if (S[i] % 2 == 0) return 1; else return 0; Errore! Perché? Pagina 33

34 Problema 2 Errore Tipico int tutti_pari(int *S, int n) { int i; for (i = 0; i < n; i++) { if (S[i] % 2 == 0) return 1; return 0; Errore! Perché? Pagina 34

35 Problema 3 Verificare che nessun elemento di un insieme S ha una proprietà P Equivale a non trovare un elemento x di S che ha la proprietà P. Come risolvere il problema? Pagina 35

36 Problema 3 - Soluzione Ho visto tutti gli elementi di S? Sì Restituisci 1 No No Considera un nuovo elemento x di S x ha la proprietà P? Sì Restituisci 0 Pagina 36

37 Problema 3 Soluzione Consideriamo la seguente istanza del Problema 3: "Verificare se un insieme di reali non ha elementi pari" Pagina 37

38 Problema 3 Soluzione "Traduciamo" in C insieme di reali: array di double condizione: essere pari int nessun_pari(double *S, int n); Pagina 38

39 Problema 3 Soluzione dobbiamo "visitare" gli elementi dell'insieme uno ad uno Ciclo int nessun_pari(double *S, int n) { int i; for (i = 0; i < n; i++) { Pagina 39

40 Problema 3 Soluzione se l'elemento che sto considerando ha la proprietà P restituisci 0, altrimenti vai al prossimo elemento: int nessun_pari(double *S, int n) { int i; for (i = 0; i < n; i++) { if (S[i] % 2 == 0) return 0; Pagina 40

41 Problema 3 Soluzione se ho visto tutti gli elementi ( non ho mai restituito 0 tutti gli elementi non hanno la proprietà P) restituisci 1: int nessun_pari(double *S, int n) { int i; for (i = 0; i < n; i++) { return 1; if (S[i] % 2 == 0) return 0; Pagina 41

42 Problemi 1/2/3 - Riassumendo Problema 1 (almeno uno) è sufficiente trovare un elemento che ha la proprietà P per restituire 1; NON è sufficiente trovare un elemento che NON ha la proprietà P per restituire 0; occorre aver controllato tutti gli elementi. Problema 2 (tutti) è sufficiente trovare un elemento che NON ha la proprietà P per restituire 0; NON è sufficiente trovare un elemento che ha la proprietà P per restituire 1; occorre aver controllato tutti gli elementi. Problema 3 (nessuno) è sufficiente trovare un elemento che ha la proprietà P per restituire 0; NON è sufficiente trovare un elemento che ha NON ha la proprietà P per restituire 1; occorre aver controllato tutti gli elementi. Pagina 42

43 Problemi 4/5/6 Soluzione Problema 4: 1. Conta il numero di elementi che soddisfano la proprietà P 2. Se il conteggio è >= N restituisci 1, altrimenti 0. Soluzione Problema 5: "conteggio == N" Soluzione Problema 6: "conteggio <= N" Pagina 43

44 Problema 4/5/6 - Soluzione Consideriamo la seguente istanza del Problema 4: "Verificare se un insieme di interi contiene almeno N multipli di 3" Pagina 44

45 Problemi 4/5/6 Soluzione "Traduciamo" in C insieme di interi: array di int condizione: essere multiplo di 3 (x % 3 == 0) In questo caso, poiché nella definizione del problema N è generico, introduciamo N come ulteriore parametro della funzione. int almeno_n_mult3(int *S, int n, int N); Pagina 45

46 Problemi 4/5/6 Soluzione per effettuare il conteggio dobbiamo "visitare" gli elementi dell'insieme uno ad uno Ciclo int almeno_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { Pagina 46

47 Problemi 4/5/6 Soluzione se l'elemento che sto considerando ha la proprietà P incrementa il puntatore: int almeno_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) count++; Pagina 47

48 Problemi 4/5/6 Soluzione se il conteggio è maggiore o uguale a N restituisci 1, altrimenti restituisci 0: int almeno_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) count++; return count >= N; Pagina 48

49 Problemi 4/5/6 Soluzione Perché? return count >= N; Non dovrebbe essere? if (count >= N) { else { return 1; return 0; Pagina 49

50 Problemi 4/5/6 Soluzione Perché? return count >= N; Sono corrette entrambe! Non dovrebbe essere? if (count >= N) { else { return 1; return 0; Pagina 50

51 Problemi 4/5/6 Soluzione Perché? return count >= N; Non dovrebbe essere? if (count >= N) { else { return 1; return 0; Sono equivalenti! Infatti, lo standard ANSI C prevede che le espressioni con operatori relazionali e di uguaglianza (>,<,>=,<=,==,!=) valgano 1 nel caso la relazione sia vera, 0 altrimenti. La prima forma è più sintetica. La seconda forma può risultare più leggibile ai meno esperti. Pagina 51

52 Problema 4 Soluzione int almeno_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) count++; return count >= N; Pagina 52

53 Problema 5 Soluzione int esattamente_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) count++; return count == N; Pagina 53

54 Problema 6 Soluzione int non_piu_di_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) count++; return count <= N; Pagina 54

55 Problema 4 Soluzione Alternativa int almeno_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) { count++; // appena ne ho trovati almeno N // restituisco 1 if (count >= N) return 1; // se non ne ho trovati almeno N restituisco 0 return 0; Pagina 55

56 Problema 6 Soluzione Alternativa int non_piu_di_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) { count++; // appena ne ho trovati più di N // restituisco 0 if (count > N) return 0; // se non ne ho trovati più di N restituisco 1 return 1; Pagina 56

57 Problema 5 Soluzione Alternativa int esattamente_n_mult3(int *S, int n, int N) { int i, count = 0; for (i = 0; i < n; i++) { if (S[i] % 3 == 0) { count++; // appena ne ho trovati più di N // restituisco 0 if (count > N) return 0; // devo verificare se ne ho contati N (non meno) return count == N; Pagina 57

58 Soluzioni alternative: quale scegliere? Per i problemi 4, 5 e 6 sono state proposte 2 soluzioni alternative. Quale scegliere? Una è meglio dell'altra? Nessuna delle 2 alternative è migliore dell'altra in tutti i casi usate quella che vi sembra più intuitiva. Pagina 58

59 Esempi

60 Esempio 1 Data una stringa s verificare che la stringa contenga almeno un'occorrenza del carattere 'A' insieme: array di caratteri elementi: caratteri proprietà: essere il carattere 'A' int contienea(const char *s); Pagina 60

61 Esempio 1 Soluzione (Flow Chart) Ho visto tutti i caratteri? Sì Restituisci 0 No No Considera il prossimo carattere c della stringa c == 'A'? Sì Restituisci 1 Pagina 61

62 Esempio 1 Soluzione dobbiamo "visitare" gli elementi dell'insieme (caratteri) uno ad uno Ciclo int contienea(const char *s) { while (*s!= '\0') { s++; Pagina 62

63 Esempio 1 Soluzione se l'elemento che stiamo considerando è il carattere 'A' restituisci 1: int contienea(const char *s) { while (*s!= '\0') { if (*s == 'A') return 1; s++; Pagina 63

64 Esempio 1 Soluzione se ho visto tutti gli elementi ( non ho mai restituito 1 nessun elemento ha la proprietà "essere 'A'") restituisci 0: int contienea(const char *s) { while (*s!= '\0') { if (*s == 'A') return 1; s++; return 0; Pagina 64

65 Esempio 2 Data una matrice di interi M con r righe e c colonne verificare che ogni riga di M ha somma nulla. insieme: matrice (insieme di vettori riga) elementi: righe proprietà: somma degli elementi == 0 int foo(int **M, int r, int c); Pagina 65

66 Esempio 2 Soluzione (Flow Chart) Ho visto tutte le righe? Sì Restituisci 1 No Sì Considera una nuova riga la riga ha somma == 0? No Restituisci 0 Pagina 66

67 Esempio 2 Soluzione dobbiamo "visitare" gli elementi dell'insieme (righe) uno ad uno Ciclo int foo(int **M, int r, int c) { int i; for (i = 0; i < r; i++) { Pagina 67

68 Esempio 2 Soluzione per verificare la proprietà sull'elemento (riga), dobbiamo sommare gli elementi della riga (Ciclo, Accumulatore) int foo(int **M, int r, int c) { int i, j, sum; for (i = 0; i < r; i++) { sum = 0; for (j = 0; j < c; j++) { sum += M[i][j]; Pagina 68

69 Esempio 2 Soluzione se la somma NON è nulla restituisci 0: int foo(int **M, int r, int c) { int i, j, sum; for (i = 0; i < r; i++) { sum = 0; for (j = 0; j < c; j++) { sum += M[i][j]; if (sum!= 0) return 0; Pagina 69

70 Esempio 2 Soluzione se ho visto tutte le righe ( non ho mai restituito 0 tutti gli elementi hanno la proprietà "somma == 0") restituisci 1: int foo(int **M, int r, int c) { int i, j, sum; for (i = 0; i < r; i++) { sum = 0; for (j = 0; j < c; j++) { return 1; sum += M[i][j]; if (sum!= 0) return 0; Pagina 70

71 Esempio 3 Data una matrice di interi M con r righe e c colonne verificare che tutte le colonne di M contengono al più 2 zeri. insieme: matrice (insieme di vettori colonna) elementi: colonne proprietà: avere al più due zeri int bar(int **M, int r, int c); Pagina 71

72 Esempio 3 Proprietà (P1): avere al più due zeri In questo esempio, la proprietà P1, che va verificata sugli elementi colonne, richiede a sua volta di verificare una proprietà P2 (essere zero) sugli elementi interi dell'insieme colonna. Cioè, l'esempio 3 è un'istanza del Problema 2. La verifica della proprietà P1 è un'istanza del Problema 6. Pagina 72

73 Esempio 3 Istanza Problema 2: insieme: matrice (insieme di vettori colonna) elementi: colonne proprietà (P1): avere al più due zeri Istanza Problema 6: insieme: colonna (insieme di interi) elementi: interi proprietà (P2): essere zero Pagina 73

74 Esempio 3 Soluzione (Flow Chart) Ho visto tutte le colonne? Sì Restituisci 1 No Sì Considera una nuova colonna la colonna ha al più due zeri? No Restituisci 0 Pagina 74

75 Esempio 3 Verifica proprietà P1 la colonna ha al più due zeri? La colonna ha al più due zeri? 1. Conta gli zeri della colonna 2. Se il conteggio è <= 2, la colonna ha la proprietà P1, altrimenti non ha la proprietà P1. Pagina 75

76 Esempio 3 - Soluzione Procediamo con la "traduzione" della soluzione in linguaggio C Pagina 76

77 Esempio 3 Soluzione dobbiamo "visitare" gli elementi dell'insieme (colonne) uno ad uno Ciclo int bar(int **M, int r, int c) { int j; for (j = 0; j < c; j++) { Pagina 77

78 Esempio 3 Soluzione verifica della proprietà P1 soluzione Problema 6 int bar(int **M, int r, int c) { int j; for (j = 0; j < c; j++) { Pagina 78

79 Esempio 3 Soluzione verifica della proprietà P1 soluzione Problema 6 conto gli zeri della colonna (Ciclo, Accumulatore) int bar(int **M, int r, int c) { int i, j, count; for (j = 0; j < c; j++) { count = 0; for (i = 0; i < r; i++) { if (M[i][j] == 0) count++; // dopo il ciclo interno count è uguale // al numero di zeri della colonna j-esima Pagina 79

80 Esempio 3 Soluzione se count > 2 la colonna j-esima non ha al più 2 zeri non è vero che tutte le colonne hanno al più 2 zeri restituisci 0 int bar(int **M, int r, int c) { int i, j, count; for (j = 0; j < c; j++) { count = 0; for (i = 0; i < r; i++) { if (M[i][j] == 0) count++; if (count > 2) return 0; Pagina 80

81 Esempio 3 Soluzione se ho visto tutte le colonne non ho mai restituito 0 tutte le colonne hanno al più 2 zeri restituisci 1 int bar(int **M, int r, int c) { int i, j, count; for (j = 0; j < c; j++) { count = 0; for (i = 0; i < r; i++) { if (M[i][j] == 0) count++; if (count > 2) return 0; return 1; Pagina 81

82 Esempio 4 Dato un insieme di stringhe (sottoforma di array di puntatori a char) verificare che tutte le stringhe abbiano un numero di 'a' pari alla somma del numero di 'b' e 'c'. insieme: insieme di stringhe (char *stringhe[]) elementi: stringhe proprietà: avere un numero di 'a' pari alla somma del numero di 'b' e 'c'. Pagina 82

83 Esempio 4 insieme: insieme di stringhe int baz(char *str[], int n); str array di puntatori a char, ogni elemento è una stringa n - lunghezza array (= numero stringhe) Pagina 83

84 Esempio 4 proprietà: avere un numero di 'a' pari alla somma del numero di 'b' e 'c'. Le proprietà viste finora, si traducevano in condizioni piuttosto semplici. Quando la condizione è sufficientemente complessa può essere conveniente creare un'apposita funzione che prende in ingresso un elemento e restituisce 1 se l'elemento ha la proprietà, 0 altrimenti. Pagina 84

85 Esempio 4 proprietà: avere un numero di 'a' pari alla somma del numero di 'b' e 'c' int ha_la_proprieta(const char *s) { int a = 0, b = 0, c = 0; while (*s!= '\0') { switch(*s) { case 'a': a++; break; case 'b': b++; break; case 'c': c++; break; s++; return a == b+c; Pagina 85

86 Esempio 4 - Soluzione int baz(char *str[], int n) { int i = 0; for (i = 0; i < n; i++) { if (!ha_la_proprieta(str[i])) return 0; return 1; Pagina 86

87 Pagina 87