Hardware e Software - unisannio.it · 2014-12-28 · minimo e della posizione in cui esso si trova...

1

Elementi di Informatica a.a. 2014/15 - Prof. G.A. Di Lucca

Dipartimento di Ingegneria – Università del Sannio - CdL Ingegneria Energetica

Elementi di Informatica

Prof. G. A. Di Lucca - Univ. del Sannio 1

Esempio

Analisi e Specifica

Definizione del problema: Inserire i valori di tutti gli elementi di un array

monodimensionale di interi, composto da 50 elementi, visualizzare il

contenuto dello array così ottenuto, calcolare la sommatoria degli elementi

di indice dispari (l’indice 0 è considerato pari)

Definizione dei dati del problema:

I: il valore di ciascun elemento dello array di numeri interi

Pi: il numero degli elementi da inserire non può essere maggiore

della cardinalità dell’array

U: lo array ‘riempito’ con i valori di tutti gli elementi, la sommatoria

degli elementi di indice dispari

Pu: lo array non può essere ‘vuoto’



Esempio

Nome variabile Descrizione Tipo

VET(I) elemento dell’array INT


VET array di interi con i valori immessi INT

Sommadispari sommatoria elementi indice dispari INT

Tabella delle variabili di ingresso

Tabella delle variabili di uscita


I Indice array INT

Tabella delle variabili di algoritmo

2





Esempio Progettazione

Descrizione del metodo di elaborazione:

Con un ciclo ripetitivo, si effettua la lettura del valore di ciascun

elemento dell’array.

Si visualizza, sempre usando un ciclo ripetitivo, il contenuto dello

array, stampando ad ogni passo del ciclo il valore di ciascun

elemento dello array

Con un ciclo ripetitivo che parte dalla posizione di indice 1 e con

step di incremento pari a due si calcola la sommatoria dei valori

nelle posizioni di indice dispari. Si stampa il risultato ottenuto.



#include< stdio. h>

main()

{

int Vett[50], i, Sommadispari;

// Legge in input i valori di tutti gli elementi dello array

for (i= 0; i< 50; i++)

{

printf(“Valore di Vett(%d)\ n", i);

scanf("% d", &Vett[ i]);

}

// Stampa tutti gli elementi dello array

for (i= 0; i< 50; i++)

printf(“Vett(%d)=% d\ n", i, Vett[ i]);

Esempio - il programma C

3





// calcola la sommatoria degli elementi di indice dispari

// un primo modo

Sommadispari=0;

for (i= 0; i< 50; i++)

{if ((i%2)!=0)

Sommadispari= Sommadispari+Vett[i];

}

printf(“Sommatoria valori elementi in posti di indice dispari=% d\ n",

Sommadispari);

}




// calcola la sommatoria degli elementi di indice dispari

// un modo più efficiente

Sommadispari=0;

for (i= 1; i< 50; i=i+2)

Sommadispari= Sommadispari+Vett[i];

printf(“Sommatoria valori elementi in posti di indice dispari=% d\ n",

Sommadispari);

}


4





Esempio

Definizione del problema: Trovare il valore minimo tra gli elementi di un

array di interi, con cardinalità 50, ed indicarne la posizione (se vi sono più

elementi con lo stesso valore minimo va indicata la posizione del primo

elemento ‘minimo’). Lo array può essere ‘riempito’ parzialmente.


I: il riempimento; il valore di ciascun elemento

Pi: il riempimento non può essere maggiore della cardinalità dell’array

U: il valore minimo nello array; la posizione dell’elemento con valore

minimo

Pu: la posizione del minimo non maggiore del riempimento



Esempio


riemp riempimento INT



MIN Elemento con il valore del minimo INT

POS Posizione dove è contenuto MIN INT




I Indice array INT


5





Esempio


è immesso il numero di quanti elementi si vogliono inserire (riempimento):

tale numero deve essere minore della cardinalità dello array.

Usando un ciclo si ‘riempe’ lo array leggendo il valore di ciascun elemento

da immettere.

Si pone il minimo pari al primo elemento dell’array e la sua posizione pari

all’indice zero.

Usando un ciclo, si ‘visita’ lo array verificando se ciascun altro elemento

dell’array è inferiore al minimo fissato, in tal caso si aggiorna il valore del

minimo e della posizione in cui esso si trova nell’array

Alla fine del ciclo si stampa il valore minimo e la posizione in cui esso si

trova



Esempio - il programma C #include<stdio.h>

main()

{ const int cardinalita=50;

int VET[cardinalita], I, riemp,MIN, POS;

do

{ printf (“quanti elementi vuoi inserire?\n”);

scanf (“%d”, &riemp);

}

while ( riemp>cardinalita);

// Legge in input gli elementi del vettore

for (I= 0; I< riemp; I++)

{ printf(" dammi elemento di posto %d\n", I);

scanf("% d", &VET[I]);

}

6





// Cerca il valore minimo nello array

MIN = VET[0]; POS=0;

for (I=1; I< riemp; I++)

{

if (VET[I]<MIN)

{

MIN=VET[I];

POS=I;

}

}

printf(“il valore minimo = %d si trova nella posizione numero%d\n” ,

MIN, POS);

}




Esempio

Definizione del problema: Verificare se in un array monodimensionale di

interi, composto da 50 elementi, esiste un determinato valore dato in input. Se

questo valore esiste indicare la posizione del primo elemento che lo contiene, e

terminare la ricerca. Lo array può essere ‘riempito’ parzialmente.

Definizione dei dati :

I: il valore di ciascun elemento; il valore da cercare; (eventuale)

riempimento

Pi: se usato un riempimento questo non può essere maggiore della

cardinalità dello array

U: la posizione del primo elemento dello array con valore uguale a

quello cercato

Pu: la posizione del primo elemento dello array con valore uguale a

quello cercato non maggiore del riempimento

7





Esempio




VAL valore da cercare nell’array INT


TROVATO Indica se esiste un elemento pari a VAL LOGICAL

POS Posizione dove è contenuto VAL INT




I indice array INT




Esempio


è indicato il numero di quanti elementi si vogliono inserire: tale

numero deve essere non maggiore della cardinalità dell’array.

Con un ciclo ripetitivo, si legge il valore di ciascun elemento da

immettere.

Si immette il valore da cercare nell’array.

Con un ciclo iterativo, si verifica se tale valore esiste nell’array:

se esiste viene visualizzata la posizione del primo elemento che

lo contiene;

se non esiste viene visualizzata la scritta ‘il valore indicato non

esiste nello array’.

8





#include<stdio.h>

main()


int VET[cardinalita], I, riemp,VAL, POS;

int trovato;

do


scanf (“%d”, & riemp); }






}

// Immissione valore da cercare

printf (“immetti valore da cercare\n”);

scanf (“%d”, &VAL);




// Cerca se il valore immesso esiste nello array (ricerca lineare)

trovato=0; POS=0;

I=0;

do

{ if (VET[I] == VAL)

{ trovato = 1;

POS=I;}

I++; }

while ((trovato ! = 1) && ( I < riemp));

if (trovato == 1)

printf (“valore immesso %d in posizione %d\n’, VAL, POS);

else

printf(“il valore indicato %d non esiste nello array\n”, VAL);

}

9






trovato=0; POS=0;

I=0;

while ((VET[I] != VAL) && ( I<riemp))

I++;

if (I < riemp)

{ trovato = 1;

POS=I; }

if (trovato == 1)

printf (“valore immesso %d in posizione %d\n”, VAL, POS);

else


}

… un’altra soluzione …




trovato=0;

I=0;

while ((trovato==0) && (I<riemp))

{ trovato=(VET[I]==VAL);

I++;

}

if (trovato==1)

printf(‘il valore immesso %d in posizione %d\n”, VAL, (I-1));

else


}

… ancora un’altra soluzione …

10





Esempio

Definizione del problema: In un array monodimensionale di interi, composto

da 50 elementi e riempito con valori in input da tastiera, contare il numero

delle occorrenze di un determinato valore dato in input. Indicare anche le

posizioni degli elementi dello array uguali al valore cercato. Lo array può

essere ‘riempito’ parzialmente.

Definizione dei dati :

I: il valore di ciascun elemento; il valore da cercare; (eventuale)

riempimento

Pi: se usato un riempimento questo non può essere maggiore della

cardinalità dello array

U: Numero di occorrenze del valore cercato, gli indici degli elementi

dello array con valore uguale a quello cercato

Pu: Numero di occorrenze non negativo, gli indici degli elementi dello

array con valore uguale a quello cercato non maggiori del riempimento



Esempio






NumOccorrenze Numero occorrenze pari a VAL INT

I Indice posizione elemento uguale a VAL INT




I indice array INT


11





Esempio


è indicato il numero di quanti elementi si vogliono inserire: tale numero

deve essere non maggiore della cardinalità dell’array;

Con un ciclo ripetitivo, si legge il valore di ciascun elemento da immettere;

Si immette il valore di VAL da cercare nell’array;

Si inizializza a zero il valore di NumOccorrenze;

Con un ciclo ripetitivo:

si verifica se ciascun elemento dello array ha il valore uguale a VAL ed

in tal caso si incrementa di 1 il valore di NomOccorrenze e si stampa

l’indice dell’elemento verificante la condizione di uguaglianza;

Alla fine del ciclo si stampa il valore di NumOccorrenze.



#include<stdio.h>

main()


int VET[cardinalita], I, riemp,VAL, NumOccorrenze = 0;

do








}


printf (“immetti valore da cercare\n”);

scanf (“%d”, &VAL);


12





// Conta le occorrenze di VAL (ricerca lineare)



{ NumOccorrenze++;

printf(“Valore %d trovato in posizione %d\n”, VAL, I);

}

}

printf (“valore %d trovato %d volte\n”, VAL, NumOccorrenze);

}



// Conta le occorrenze di VAL (ricerca lineare)

int posizione[cardinalita];

…..



{posizione[NumOccorrenze]=I;

NumOccorrenze++;

}

}

printf (“valore %d trovato %d volte\n nelle posizioni:\n”, VAL,

NumOccorrenze);

for (I= 0; I< NumOccorrenze; I++)

printf(“posizione = %d\n”, posizione[I]);

}

13





Visita totale: vengono analizzati tutti gli elementi

Si usa un ciclo a conteggio

E’ il caso degli esempi della ricerca del minimo e dell’ordinamento

Visita finalizzata: la visita termina quando un elemento dell’array verifica

una certa condizione

Si usa un ciclo iterativo

due condizioni di uscita:

una sull’indice di scansione (visitati tutti gli elementi si esce comunque

dal ciclo) e

l’altra che dipende dal problema specifico ...

… in ogni caso si termina se si sono visitati tutti gli elementi

dell’array senza trovare l’elemento dato

E’ il caso della ricerca di un elemento (termina se l’elemento è stato trovato ...)

Visita degli elementi di un array



Generazione casuale (random) di un numero:

… si usa la funzione rand() della libreria <stdlib.h>

#include <stdio.h>

#include <stdlib.h>

main ()

{int a;

printf ("Generazione random di un numero intero \n");

a = rand() %70; //la funzione rand() genera in modo random un numero

// intero; l’applicazione di %70 fa in modo che il numero

// generato sia modulo 70, ossia compreso tra 0 e 69.

printf ("Numero = %d \n", a);

}

Esempio

14





/* Programma per simulare il risultato del lancio di un dado */

#include <stdio.h>

#include <stdlib.h>

main ()

{ int faccia_dado;

faccia_dado = rand() % 6; //genera un numero casuale fra 0 e 5

faccia_dado++; // per ottenere un valore tra 1 e 6

printf(“Faccia_dado = %d\n",faccia_dado);

system("Pause");

}

Esempio



… Se eseguiamo il programma più volte si ottiene sempre lo stesso

risultato!!!

… ciò è dovuto al fatto che rand() genera numeri pseudo-casuali, cioè

numeri che "sembrano" casuali …

Affinchè ogni esecuzione del programma generi un diverso valore deve

essere effettuata la ‘randomizzazione’ della funzione, ovvero inizializzare il

generatore di numeri pseudo-casuali usando un valore che viene detto ‘seme’

La randomizzazione può essere fatta usando la funzione srand(), che

richiede un parametro di input di tipo unsigned (intero senza segno), che

funge da seme.

La funzione time() della libreria time.h è solitamente usata, con parametro

NULL (o zero) , per generare il seme; essa fornisce un valore unsigned

calcolato in base all'ora corrente del giorno, espressa in secondi.

Esempio

15





// Programma per simulare il risultato del lancio di un dado - randomizzato

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

main ()

{ int faccia_dado, i;

srand(time(NULL)); //inizializza il generatore di numeri random

for (i=0;i<5;i++) // lancia il dado 5 volte e ogni volta mostra il risultato

{ faccia_dado= rand() % 6; //genera un numero casuale fra 0 e 5

faccia_dado++; // per ottenere un valore tra 1 e 6

printf(“Faccia dado = %d\n",faccia_dado);

}

system("Pause");

}

Esempio



Esempio

Riempimento di un array con generazione random di numeri :

#include <stdio.h>

#include <stdlib.h>

#include<time.h>

main ()

{ int i, vet[10];

srand(time(NULL));

for(i=0;i<10;i++)

v[i] = rand(); //il valore random generato da rand() è assegnato

// all’elemento i-esimo dello array v

for(i=0;i<10;i++)

printf ("v[%d] = %d \n", i, v[i]);

}

16





Ordinamento di array: per selezione

Definizione del problema: Ordinare in senso crescente gli

elementi di un array monodimensionale di interi e visualizzare

l’array risultante.

Definizione dei dati:

I: riempimento; il valore di ciascun elemento dello array

Pi: il numero degli elementi da inserire (riempimento) non

può essere maggiore della cardinalità dell’array

U: l’array monodimensionale con gli elementi ordinati in

senso crescente

Pu: T[i] T[i+1] " i=1..n dove T è lo array da ordinare





VET Array da ordinato INT






Nome variabile Descrizione Tipo I indice array INT

???


17





Ordinamento di array: per selezione Descrizione del metodo di elaborazione:

Ordinamento per selezione (detto anche per minimi successivi).

Detto T lo array mono-dimensionale di cardinalità n, per ottenere

l’ordinamento desiderato deve verificarsi che sia

T[i] T[i+1] " i=1..n.

• Si trova, allora, il valore minimo T[p] dell’intero array e si scambia il valore

di T[p] con quello in prima posizione (T[0]);

• poi, si trova il nuovo minimo T[p] tra tutti gli elementi tra la seconda e

l’ultima posizione (T[1] e T[n]) e si scambia il valore di T[p] con quello in

seconda posizione (T[1]);

• ... si ha una parte ordinata e una NON ancora ordinata

• si continua in tal modo con tutti gli altri elementi dell’array nella parte NON

ancora ordinata, scambiando di posto il primo elemento della parte NON

ancora ordinata con il minimo della parte NON ordinata con.

• Alla fine sono visualizzati gli elementi dell’array risultante.



9

5

8

2

4

22

5

8

9

4

222

444

8

9

5

222

444

8

9

5

222

444

555

9

8

222

444

555

9

8

222

444

555

888

999


9

5

8

2

4

222

5

8

9

4

In blu parte già ordinata

In rosso minimo parte

NON ancora ordinata

18







VET Array da ordinato INT






Nome variabile Descrizione Tipo I,J indice array INT

temp variabile appoggio per swap INT

POS Posizione minimo INT

MIN Minimo in parte non ordinata dell’array INT




Il programma in C

Ordinamento di array:

per selezione

#include<stdio.h>

main()


int VET[cardinalita], I, riemp, J, POS, temp, MIN;

do








}

19





// trova minimo parte non ordinata e scambia

for (I=0;I<(riemp-1);I++)

{MIN= VET[I];

POS=I;

for (J=(I+1);J<riemp;J++)

{ if (VET[J]<MIN)

{ MIN=VET[J];

POS=J;

}

}

temp= VET[I];

VET[I]= VET[POS]; // ovvero VET[I]=MIN

VET[POS]=temp;

}

// Stampa array ordinato

for (I= 0; I< riemp; I++) printf("% d\ n", VET[ I]);

}

Il programma in C


per selezione



... swapping ...

temp= VET[I];

VET[I]= VET[POS];

VET[POS]=temp;

Il programma in C


per selezione

Lo swapping

9

5

8

2

4

9 temp

2

5

8

9

4

9 temp

2

5

8

9

4

... I=0 ; POS=3; ...

temp= VET[0];

VET[0]= VET[3];

VET[3]=temp;

temp

2

5

8

2

4

9

9

5

8

2

4

20





... swapping ...

ATTENZIONE A NON FARE:

VET[I]= VET[POS];

VET[POS]=VET[I];

E’ ERRATO !!!

Il programma in C


per selezione

Lo swapping

2

5

8

2

4

... I=0 ; POS=3; ...

VET[0]= VET[3];

VET[3]=VET[0];

9

5

8

2

4



// trova minimo parte non ordinata e scambia

for (I=0; I<(riemp-1); I++)

{ for (J=(I+1); J<riemp; J++)

{ if (VET[J]< VET[I])

{ temp = VET[I];

VET[I] = VET[J];

VET[J] = temp;

}

}

}

// Stampa array ordinato

for (I= 0; I< riemp; I++) printf("% d\ n", VET[ I]);

}

Il programma in C


per selezione

… un’altra soluzione …

21






9

5

8

2

4

I = 0

5

9

8

2

4

J = 1

5

9

8

2

4

J = 2

2

9

8

5

4

J = 3

2

9

8

5

4

J = 4 I = 1

2

9

8

5

4

J = 2

2

8

9

5

4

2

5

9

8

4

J = 3

2

4

9

8

5

J = 4

2

4

9

8

5

I=2

2

4

8

9

5

J = 3

2

4

5

9

8

J = 4

2

4

5

9

8

I = 3

2

4

5

8

9

J = 4

2

4

5

8

9



Aggiunta di elementi in un array non ordinato

Card = 12

28 10 3 31 40 33 57 93

Riemp = 8

Si vogliono aggiungere, in coda, i

valori:

Riemp = 9

Card = 12 14 525252

28 10 3 31 40 33 57 93 52

14 52

Definizione del problema: Si vogliono aggiungere uno o più elementi in

un array monodimensionale di interi già parzialmente riempito e

visualizzare lo array risultante.

22






Riemp = 10

Card = 12 141414 525252

28 10 3 31 40 33 57 93 52 14

• prima di effettuare la ‘aggiunta’, controllare che il numero di elementi da

aggiungere non faccia superare la cardinalità

• ovvero si possono aggiungere al più (Card - Riemp) nuovi valori

• il riempimento finale sarà quello iniziale più la quantità di elementi

aggiunti




Card = 12

28 10 3 31 40 33 57 93

Riemp = 8

Si vogliono aggiungere, in coda, i

valori:

Riemp = 9

Card = 12 14 525252

28 10 3 31 40 33 57 93 52

14 52

Definizione del problema: Si vogliono aggiungere uno o più elementi in

un array monodimensionale di interi già parzialmente riempito e

visualizzare lo array risultante.

23







I: lo array monodimensionale parzialmente riempito; il

valore degli elementi che si vogliono aggiungere allo

array

Pi: il numero degli elementi da aggiungere non deve

superare la differenza tra la cardinalità ed il riempimento

già esistente

U: lo array monodimensionale con gli elementi aggiunti

Pu: il riempimento finale è non minore di quello iniziale








.... ..... ...... ..... .....




... LO STUDENTE COMPLETI LE TABELLE ....

24






Allo array, di cardinalità n già parzialmente riempito con

riempimento R , si vogliono aggiungere i valori di K elementi;

si verifica che sia R + K <= n ed in tal caso si aggiungono i K

valori a partire dalla posizione R+1 .

Si visualizza lo array risultante.




Aggiunta di elementi in un array non ordinato: il programma C

#include<stdio.h>

main()


int i, J, conta1, riemp;

int VET[cardinalita] ;

// codice C per il riempimento array

.... .... ....

// richiesta di quanti altri valori si vogliono inserire

do

{ printf("Lo array ha cardinalità %d\n”, cardinalita);

printf("Lo array contiene %d elementi \n”, riemp);

printf(“Quanti elementi vuoi aggiungere? (Max %d )\n”, (cardinalita - riemp));

scanf(“%d”, &conta1);

} while (conta1>(cardinalita - riemp));

25





for (i=riemp; i<(riemp+conta1); i++)

{ printf ("immetti valore da aggiungere \n”);

scanf(“%d”, &VET[i]);

}

riemp=riemp+conta1;

// Stampa array

for (I= 0; I< riemp; I++) printf("% d n", VET[ I]);

}

Aggiunta di elementi in un array non ordinato: il programma C



Definizione del problema: Si vogliono aggiungere uno o più

elementi in un array monodimensionale di interi già parzialmente

riempito mantenendo l’ordinamento esistente (crescente) dello

array (senza doverlo riordinare) e visualizzare lo array risultante.

Aggiunta di elementi in un array ordinato


I: lo array monodimensionale parzialmente riempito ed

ordinato (crescente); il valore degli elementi che si vogliono

aggiungere allo array

Pi: il numero degli elementi da aggiungere non deve superare

la cardinalità; l’array è ordinato in senso crescente

U: lo array monodimensionale con gli elementi aggiunti

Pu: lo array risultante deve essere ordinato (crescente)

26





14

Riemp = 9 Card = 12

3 10 14 28 31 33 40 57 93

141414 52

3 10 14 28 31 33 40 52 57 93

Riemp = 10 Card = 12 525252


Card = 12

3 10 28 31 33 40 57 93

Riemp = 8

VET




3 10 28 31 33 40 57 93

• bisogna ‘creare lo spazio’ per inserire il nuovo valore …

• Pos, posizione dell’array con il primo elemento con valore maggiore di quello da

aggiungere

• si verifica che la quantità degli elementi da aggiungere non superi la cardinalità

• si trasla (si ‘copia’) l’ultimo elemento nella prima successiva posizione libera ...

14

… si continuano a traslare gli altri elementi fino a

giungere all’elemento in Pos

Card = 12

3 10 28 31 33 40 57 93

Riemp = 8

3 10 28 31 33 40 57 93 93

Riemp = 9

… in C ...

Riemp++;

I=Riemp - 1;

VET[I]=VET[I-1];

Pos

27






3 10 28 31 33 40 57 93 93

Riemp = 9

3 10 28 31 33 40 57 57 93

3 10 28 31 31 33 40 57 93

3 10 28 28 31 33 40 57 93

Riemp = 9

…...

Riemp++;

for (I=(Riemp-1);I>Pos;I--) VET[I]=VET[I-1];




3 10 28 28 31 33 40 57 93

Riemp = 9

14

VET[Pos]= el_da_inserire;

3 10 14 28 31 33 40 57 93

Riemp = 9

28





Un errore tipico consiste nell’eseguire il ciclo a conteggio scandendo le posizioni in senso

crescente

Il risultato è il ricopiamento a destra dell’elemento che si trova in posizione inferiore:

for (i=pos; i<riemp;i++) vet[i+1]=vet[i]; // ERRORE !!!

Errore tipico

3 10 28 28 33 40 57 93

3 10 28 31 33 40 57 93

pos

3 10 28 28 28 40 57 93








.... ..... ...... ..... .....




... LO STUDENTE COMPLETI LE TABELLE ....

29






• Allo array T[n], di cardinalità n già ordinatamente riempito con Riemp elementi, si vogliono

aggiungere i valori di K elementi;

• si verifica che sia Riemp + K <= n ; se la condizione è verificata:

• con un ciclo ripetitivo si immettono i nuovi K valori • al fine di mantenere l’ordinamento esistente nello array, i K valori vanno aggiunti

ciascuno nella giusta posizione in modo che sia verificato:

T[I-1] < Valore_da_Inserire < T[I]

• Si legge il nuovo valore da aggiungere

• Per trovare la posizione Pos in cui inserire il nuovo valore si usa un ciclo iterativo in

cui, partendo dalla prima posizione dello array, si verifica se

Valore_da_Inserire > T[I]

e si termina il ciclo quando questa condizione è vera (o quando sono stati esaminati

tutti i Riemp elementi dello array): il valore di I per cui la condizione è vera è la

posizione Pos dove andrà inserito il nuovo valore

• Bisogna traslare di una posizione tutti gli elementi T[J] per J = Riemp .. I usando un

ciclo ripetitivo, dopo aver incrementato di 1 Riemp:

Riemp++; for (I=(Riemp-1);I>Pos;I--) VET[I]=VET[I-1];

• Si visualizza lo array risultante.




Aggiunta di elementi in un array ordinato: il programma C

#include<stdio.h>

main()

{// codice per dichiarazioni variabili

………….

// codice per immissione di riemp elementi nell’array

// codice per ordinare in modo crescente gli elementi nell’array

………


do





} while (conta1>(cardinalita - riemp));

30





for (i=1; i<=conta1; i++) // immissione nuovi valori

{ printf("immetti un valore da aggiungere \n”);

scanf(“%d”, &el_da_inserire);

// trova posizione dove inserire

k=0;

while ((el_da_inserire>vet[k]) && (k<riemp)) k++;

pos=k;

riemp++;

// sposta elementi di una posizione

if (pos<riemp-1)

for (j=(riemp-1);j>pos;j--)

vet[j]=vet[j-1];

// inserisce il nuovo elemento

VET[pos]= el_da_inserire;

}

for (i= 0; i< riemp; i++) printf("% d\ n", vet[i]); // Stampa array

}




#include<stdio.h>

void leggivet(int Vet1[],int card1, int *riemp1);

void stampavet(int Vet1[ ],int card1);

void ordinavet (int Vet1[], int riemp);

main()


int i, j, conta1, riemp, k, pos, el_da_inserire , VET[cardinalita] ;

leggivet(Vet, cardinalita, &riemp); stampavet(Vet, riemp);

ordinavet (Vet, riemp); stampavet(Vet, riemp);


do





} while (conta1>=(cardinalita - riemp));

il programma C con

sottoprogrammi

31





for (i=1; i<=conta1; i++) // immissione nuovi valori

{ printf("immetti un valore da aggiungere \n”);

scanf(“%d”, &el_da_inserire);

// trova posizione dove inserire

k=0;

while ((el_da_inserire>vet[k]) && (k<riemp)) k++;

pos=k;

riemp++;

// sposta elementi di una posizione

if (pos<riemp-1)

for (j=(riemp-1);j>pos;j--) vet[j]=vet[j-1];

VET[pos]= el_da_inserire; // inserisce nuovo elemento

}

stampavet(Vet, riemp);

}



void leggivet(int Vet1[],int card1, int *riemp1)

{ int I;

do

{printf("immetti riemp\n");

scanf("%d",&(*riemp1));

}

while(*riemp1>card1);

for (I=0;(I<*riemp1); I++)

{printf("immetti Vet[ %d ]= \n",I) ;

scanf("%d", &Vet1[I]);

}

}

void stampavet(int Vet1[ ],int card1)

{ int I;

for (I=0;I<card1; I++)

printf("Vet1[ %d ]= %d \n”, I, Vet1[I] );

}

void ordinavet(int Vet1[ ],.............)

LO STUDENTE DEFINISCA IL

SOTTOPROGRAMMA PER ORDINARE

IN MODO CRESCENTE UN ARRAY

MONODIMENSIONALE

32





Definizione del problema: Si vuole verificare se in un array

ordinato in senso crescente esiste un elemento con un dato valore

e se esso esiste si vuole conoscere la sua posizione.

Ricerca di un elemento in un array ordinato


I: lo array monodimensionale ordinato; il valore dell’elemento

che si vuole cercare

Pi: lo array è ordinato in senso crescente

U: la posizione dell’elemento con valore pari a quello cercato se

esso esiste nello array

Pu: il contenuto dello array resta immutato




Viene letto il valore da cercare;

viene considerato l’elemento dello array (ordinato in senso crescente) in

posizione centrale (rispetto al riempimento);

se il dato da cercare è ugale a quello centrale la ricerca è terminata

altrimenti:

• se il dato da cercare è minore di quello centrale viene applicato lo stesso

algoritmo alla prima parte dello array, se questa ha almeno un elemento,

altrimenti

• se il dato da cercare è maggiore di quello centrale viene applicato lo

stesso algoritmo alla seconda parte dello array, se questa ha almeno un

elemento

Si continua fin quando un elemento centrale è pari a quello cercato o

nessuna parte contiene più elementi

Ricerca di un elemento in un array ordinato

33





93

Posizione elemento centrale:

P=(Sup+Inf)/2=5

3 10 28 31 33 40 57 93 98

Riemp = 9 Card = 12

Inf = 1 Sup = 9

3 10 28 31 333 10 28 31 333 10 28 31 33 40 57 93 98

Inf = 6 Sup = 9


P=(Sup+Inf)/2=8

93

3 10 28 31 333 10 28 31 333 10 28 31 33 40 5740 5740 57 93 98

Inf = 8 Sup = 9

93


P=(Sup+Inf)/2=7

=?

=?

=?

Deve sempre essere Inf <= Sup

Se Inf >=Sup l’elemento non esiste nello array



#include<stdio.h>

#include <..… /leggivet.h>

#include <….. /stampavet.h>

#include <….. /ordinavet.h>

main ()

{ const card=50;

int Vet[card], I, riemp, elem, trovato, centro, inf, sup;

leggivet(Vet, card, &riemp);

stampavet (Vet, riemp);

ordinavet(Vet, riemp);

// immissione valore da ricercare

printf("immetti valore da cercare \n”);

scanf(“%d”, &elem);

trovato=0;

inf=0; sup=riemp - 1;

Ricerca di un elemento in un array ordinato Il programma C strutturato in sottoprogrammi

34





// ricerca binaria

while ((inf <= sup) && (trovato = = 0))

{

centro = (inf + sup) / 2; // posizione centrale

if (Vet[centro] == elem)

trovato = 1; // permette di uscire dal ciclo

else if(Vet[centro] > elem)

sup = centro -1; // la ricerca continua nella prima metà

else inf = centro+1; // la ricerca continua nella seconda metà

}

if(trovato)

printf(“elemento trovato in posizione: %d \n”, centro);

else printf(“elemento non trovato \n”);

}



#include <stdio.h>

void leggivet(int Vet1[],int card1, int *riemp1)

{ int I;

do

{printf("immetti riemp\n");

scanf("%d",&(*riemp1));

}

while(*riemp1>card1);

for (I=0;(I<*riemp1); I++)

{printf("immetti Vet[ %d ]= \n",I) ;

scanf("%d", &Vet1[I]);

}

}

#include <stdio.h>

void stampavet(int Vet1[ ],int card1)

{ int I;

for (I=0;I<card1; I++)

printf("Vet1[ %d ]= %d \n”, I, Vet1[I] );

}

void ordinavet(int Vet1[ ], int riemp1)

{

...............

}

35





Esempio

Definizione del problema:

Scrivere, producendo la necessaria documentazione, un programma in

linguaggio C che dato una stringa di 30 caratteri:

• consente di riempire completamente la stringa con valori che sono le sole

vocali dell’alfabeto (‘a’, ‘e’, ‘i’, ‘o’,’u’);

• conta quante volte ciascuna vocale compare nella stringa e stampa il

risultato.

• cancella tutte le vocali ‘o’ compattando, ad ogni cancellazione, la stringa

(lo array che la contiene) e stampa la stringa risultante.



Esempio


I: il valore di ciascun carattere dello array.

Pi: elementi dello array devono essere una delle vocali ‘a’, ‘e’, ‘i’,

‘o’,’u’.

U: Numero dei caratteri ‘a’, ‘e’, ‘i’, ‘o’,’u’ presenti nello array; lo

array compattata

Pu: Nello array non ci sono vocali ‘o’.

36





Esempio

Nome Variabile Descrizione Tipo

VET[i] Elemento Array

monodimensionale

char


contaA, contaE,

contaI, contaO,

contaU

Contatori del numero di

occorrenze di ciascuna

vocale ‘a’, ‘e’, ‘i’, ‘o’,’u’

in VET

INT

VET Array compattato dopo la

eliminazione della vocale

‘o’

char

Tabella delle variabili di Ingresso:

Tabella delle variabili di Uscita:



Esempio


riemp riempimento dello

array VET

INT

i, j Indice di controllo di

ciclo

INT

Tabella delle variabili di algoritmo:

37





Esempio


Si riempe lo array VET controllando che si immettano le sole vocali ‘a’, ‘e’,

‘i’, ‘o’,’u’.

Si azzerano i contatori delle occorrenze totali di ciascuna vocale.

Con un ciclo ripetitivo si effettua una visita completa di VET e, usando una

struttura ‘switch’, si contano le occorrenze di ciascuna vocale

incrementando di 1 il corrispondente contatore.

Con un ciclo iterativo di indice i si visita lo array VET: se l’elemento

visitato è pari alla vocale ‘o’, con un ciclo ripetitivo, di indice j iniziante

dalla posizione dove si trova la ‘o’ e terminante al penultimo elemento di

VET, si cancella la ‘o’ e si compatta VET con l’istruzione VET[j]=VET[j+1]

e si decrementa di 1 il suo riempimento; dopo la compattazione si riprende

la visita di VET dalla stessa posizione in cui si è trovata la ‘o’.

Si stampa lo array VET compattato



Esempio #include<stdio.h>

main ( )

{int const card=31;

char VET[card];

int i, j, contaA, contaE, contaI, contaO, contaU, riemp;

// Si inizializzano a 0 i contatori e la variabile i

i=0;

contaA=0;

contaE=0;

contaI=0;

contaO=0;

contaU=0;

/* Si riempie VET verificando che siano immesse le sole vocali ‘a’,

‘e’, ‘i’, ‘o’,’u’ e contano le loro occorrenze */

while (i<card-1)

{ printf(" Immetti una vocale in VET al posto %d\n", i);

scanf("\n%c", &VET[i]);

38





Esempio

switch (VET[i])

{

case 'a': i++; contaA++; break;

case 'e': i++; contaE++; break;

case 'i': i++; contaI++; break;

case 'o': i++; contaO++; break;

case 'u': i++; contaU++; break;

default: printf("NON Immessa una vocale!\n"); break;

}

}

VET[card-1]=‘\0’;

// si stampano le occorrenze delle vocali in VET

printf("Vocale A presente %d volte in VET \n", contaA);

printf("Vocale E presente %d volte in VET \n", contaE);

printf("Vocale I presente %d volte in VET \n", contaI);

printf("Vocale O presente %d volte in VET \n", contaO);

printf("Vocale U presente %d volte in VET \n", contaU);



Esempio

// Si cercano le ‘o’ in VET, le si cancellano compattando lo array

riemp=card;

i=0;

while (i<riemp-1)

{ if (VET[i]=='o')

{for (j=i; j<riemp-2; j++)

VET[j]=VET[j+1];

riemp--;

}

else i++;

}

for (j=0; j<riemp-1; j++)

printf("VET[%d] = %c \n", j, VET[j]);

}

39





Esempio - Array Bidimensionale

Definizione del problema: Inserire i valori degli elementi di un

array bidimensionale di interi, composto da 6 righe e 5 colonne, e

visualizzare il contenuto dell’array così ottenuto, ordinato per

righe


I: il valore di ciascun elemento dello array bidimensionale

Pi: il numero degli elementi da inserire non può essere

maggiore della cardinalità dell’array

U: l’array bidimensionale ‘riempito’ con i valori degli elementi

Pu: array bidimensionale non ‘vuoto’



Esempio


MAT array bidimensionale di interi INT

MAT(I,J) elemento dell’array INT


MAT array di interi con i valori immessi INT



40





Esempio - Array Bidimensionale


Con due cicli ripetitivi innestati, si legge il valore di ciascun

elemento da immettere, immettendo i valori per riga. Quindi, il

ciclo più esterno controlla l’indice di riga, quello più interno

l’indice di colonna.

Con due cicli ripetitivi innestati, si visualizza il contenuto

dell’array, visualizzando i valori immessi per righe. Anche in

qiesto caso il ciclo più esterno controlla l’indice di riga, quello

più interno l’indice di colonna.




#include<stdio.h>

main()

{ const cardR=6, cardC=5;

int MAT[cardR] [cardC], i,j;

// Legge in input tutti gli elementi della matrice

for (i= 0; i< cardR; i++) //scandisce le righe

for (j= 0; j< cardC; j++) //scandisce le colonne

{ printf(" dammi el. (%d , %d) di MAT\n", i,j);

scanf("% d", &MAT[i][j]);

}

// Visualizza tutti gli elementi della matrice

for (i= 0; i< cardR; i++) //scandisce le righe

for (j= 0; j< cardC; j++) //scandisce le colonne

printf(”(%d, %d) = % d\n",i,j, MAT[i][j]);

}

41





0

1

2

3

4

5

0 1 2 3 4

23 47 63 96 8

27 66 23 44 567

42 28 34 125 47

for (i= 0; i< cardR; i++)

for (j= 0; j< cardC; j++)

{

printf(" dammi el. (%d , %d) di MAT\n", i,j);

scanf("% d", &MAT[i][j]);

}

i = 0

j = 0 => MAT[0,0]= 23

...

...

84

... ...

... ...

...

j = 1 => MAT[0,1]= 47 j = 2 => MAT[0,2]= 63

j = 3 => MAT[0,3]= 96 j = 4 => MAT[0,4]= 8

i = 1

j = 0 => MAT[1,0]= 27

j = 1 => MAT[1,1]= 66

j = 2 => MAT[1,2]= 23

j = 3 => MAT[1,3]= 44

j = 4 => MAT[1,4]= 567

i = 2

j = 0 => MAT[2,0]= 84

… …

i = 5

j = 0 => MAT[5,0]= 42

j = 4 => MAT[5,4]= 47

j = 1 => MAT[5,1]= 28

j = 2 => MAT[5,2]= 34 j = 3 => MAT[5,3]= 125



42





#include <stdio.h>

main ()

{const cardriga=3, cardcol=4;

int Vett[]={3,6,12,45}; // lo array ha cardinalità 4, pari al numero di valori che lo inizializzano

int MAT[cardriga] [cardcol] ={{1,7, 22, 33}, {2,1, 44, 55}, {66, 77, 88,5}}

int I, J;

// Stampa valori elementi dell’array Vett

for(I=0;I<4;I++) printf(“Vett[%d]=%d \n”, I, Vett[i]);

// Stampa valori elementi dell’array MAT

for (I=0; I<cardriga, I++)

{ for J=0; J<cardcol, J++)

printf(“ %d – “, MAT[i][j]);

printf(“\n”);

}

}

Esempio ... inizializzare un array quando lo si dichiara .....



Esempio


Trovare il valore massimo tra gli elementi di un array bidimensionale, di 5 righe e 7

colonne, ed indicarne la posizione (riga e colonna)

Definizione della specifica del programma:

I: l’array bidimensionale di numeri interi; il valore di ciascun elemento

Pi: nessuna

U: la posizione dell’elemento con valore massimo

Pu: nessuna


Si genera in modo random il valore di ciascun elemento della matrice. Si pone il massimo

pari al primo elemento dell’array (elemento posto nella prima riga e prima colonna), si

effettua una visita completa (scandendolo per riga e colonne) della matrice e si verifica se

ciascun altro elemento dell’array è superiore al massimo fissato, in tal caso si aggiorna il

valore del massimo e della posizione in cui esso si trova nell’array

43





Esempio






MAX Elemento con il valore del massimo INT

RIGA Riga dove è contenuto MAX INT

COL Colonna dove è contenuto MAX INT




#include <stdio.h>

#include <stdlib.h>

#include<time.h>

main ()

{ // Max_in_array_bidimensionale;

const cardriga=5, cardcol=7;

int MAT[cardriga] [cardcol], I, J, MAX;

int RIGA, COL;

// Riempimento array in modo random

srand(time(0));

for (I=0; I<cardriga; I++)

for (J=0; J<cardcol; J++)

MAT [I][J]=rand();

//Stampa array



printf("MAT[%d, %d] = %d \n", I, J, MAT[I][J]);

// Cerca il valore massimo nello array

RIGA=0; COL=0; MAX = MAT[0][0];



{ if (MAT[I][J]>MAX)

{ MAX=MAT[I][J];

RIGA=I; COL=J;

}

}

printf (“il massimo = %d si trova nella posizione

riga %d e colonna %d \n", MAX, RIGA, COL);

}

Esempio - il programma

44





Esempio Definizione del problema: Verificare se in un array bidimensionale di

interi, composto da 5 righe e 7 colonne, esiste un determinato valore dato in

input da tastiera. Se questo valore esiste indicare la posizione, riga e

colonna, dell’elemento che lo contiene. L’elaborazione termina appena

l’elemento è trovato.


I: il valore di ciascun elemento; il valore da cercare

Pi: il numero degli elementi da inserire non può essere maggiore

della cardinalità dell’array

U: la posizione, indici di riga e colonna, dell’elemento con valore

pari a quello cercato

Pu: se il valore è stato trovato gli indici della sua posizione inserire

non possono essere maggiore delle rispettive cardinalità di

riga/colonna



Esempio







TROVATO Indica se esiste un elemento pari a VAL LOGICAL

I, J Posizione dove è contenuto VAL INT


45





Esempio


Con due cicli ripetitivi innestati, si legge, in ordine di riga, il

valore da assegnare a ciascun elemento dello array.

Si immette il valore da cercare nell’array bidimensionale.

Si verifica se tale valore esiste nello array:

se esiste viene visualizzata la posizione dell’elemento che

lo contiene;

se non esiste viene visualizzata la scritta ‘il valore indicato

non esiste nello array’.



#include <stdio.h>

#define col 7

void leggimat(int Mat1[][col],int cardr, int cardc);

void stampamat(int Mat1[][col],int cardr, int cardc);

main ()

{int const cardr=5;

int const cardc=col;

int MAT[cardR] [cardC], i,j, VAL, trovato;

leggimat(Mat,cardr,cardc);

stampamat(Mat,cardr,cardc);


printf(“Immetti il valore da cercare\n”);

scanf("%d", &VAL);


46







trovato=0; i=0;

while ((trovato==0) && ( i<cardR))

{ j=0;

while ((trovato==0) && ( j<cardC))

{trovato=(MAT[i][j]==VAL);

j++;}

i++;

}

if (trovato != 0)

printf(“valore immesso %d in posizione %d, %d\n”, VAL, i-1, j-1);

else


}



Esempio - il programma C void leggimat(int Mat1[][col],int cardr, int cardc)

{int I, J;

for (I=0;(I< cardr); I++)

for (J=0;J<cardc;J++)

{printf("immetti Mat[ %d ] [%d]= \n",I,J) ;

scanf("%d", &Mat1[I][J]);

}

}

void stampamat(int Mat1[][col],int cardr, int cardc)

{ int I,J;

for (I=0;I<cardr; I++)

for (J=0;J<cardc;J++)

printf("Mat1[%d][%d]= %d \n", I,J, Mat1[I][J]);

}

47





Esempio

Definizione del problema: Calcolare la trasposta di una matrice

quadrata di interi


I: lo array bidimensionale; il valore di ciascun elemento dello

array

Pi: il numero delle righe deve essere uguale a quello delle

colonne

U: l’array bidimensionale pari al trasposto di quello in ingresso

Pu: nessuna

Descrizione del metodo di elaborazione: Si legge, in ordine di riga,

il valore di ciascun elemento dello array. Si verifica che il numero di

colonne sia uguale al numero di righe. Si calcola il valore di ciascun

elemento della matrice trasposta MATTR(I,J)=MAT(J,I). Stampare la

matrice trasposta risultante.



0

1

2

3

4

0 1 2 3 4

23 47 63 96 8

27 66 23 44 567

...

...

84

... 15

32 ...

... MAT

0

1

2

3

4

0 1 2 3 4

23 27 84 15 32

47 66

23

44

63

... 96

8 567

... MATTR

48





Esempio


MAT prima matrice di interi INT

MAT(I,J) elemento della prima matrice INT


MATTR Matricetrasposta di MAT INT





Esempio - il programma #include<stdio.h>

main()

{// Trasposta di una matrice quadrata

const card=5;

int MAT[card] [card], i,j,MATTR [card] [card];

// Legge in input tutti gli elementi della matrice MAT

for (i= 0; i< card; i++)

for (j= 0; j< card; j++)

{


scanf("%d", &MAT[i][j]);

}

// Visualizzazione valori elementi matrice MAT

for(i=0;i<card;i++)

{ printf(“\n”);

for(j=0; j<card; j++)

printf(“MAT(%d, %d) = %d - ”, i,j,MAT[i] [j]);

}

49






// Calcola matrice trasposta

for (i= 0; i< card; i++)

for (j= 0; j< card; j++)

MATTR [i][j]=MAT[j][i];

// Visualizzazione valori elementi matrice trasposta

printf(“\n\n MATRICE TRASPOSTA \n\n”);

for(i=0;i<card;i++)

{ printf(“\n”);

for(j=0; j<card; j++)

printf(“MATTR(%d, %d) = %d - ”, i,j,MATTR[i] [j]);

}

}



Esempio

Definizione del problema: Calcolare la trasposta di una matrice di interi

(anche se non quadrata)


I: lo array bidimensionale; il valore di ciascun elemento dello array

Pi: nessuna

U: l’array bidimensionale pari al trasposto di quello in ingresso

Pu: Il numero di righe della matrice trasposta è pari al numero di

colonne della matrice in input ed il numero di colonne della matrice

trasposta è pari al numero di righe della matrice in input

Descrizione del metodo di elaborazione: Si legge, in ordine di riga, il

valore di ciascun elemento dello array in input.

Si calcola il valore di ciascun elemento della matrice trasposta

...... LO STUDENTE DEFINISCA L’ALGORITMO ...

Si stampa la matrice trasposta risultante.

50





23 27 44 55 32

66 88 54 23 11

98 78 46 32 66

23 66 98

27 88 78

44 54 46

55 23 32

32 11 66

MAT

MATTR

Esempio




main()

{// Calcola la trasposta di una matrice

const cardR=4, cardC=3;

int MAT[cardR][cardC], i,j;

int MATTR[cardC][cardR]; // la trasposta ha le cardinalità invertite

// Legge in input tutti gli elementi della matrice

for (i=0; i< cardR; i++)




}

// Visualizzazione valori elementi matrice MAT

for(i=0;i<cardR;i++)

{printf("\n");

for(j=0;j<cardC;j++)

printf("MAT(%d, %d) = %d - ", i,j,MAT[i] [j]);

}

51






// Calcola matrice trasposta

for (i= 0; i< cardC; i++) // gli indici dei due cicli sono ‘invertiti’ rispetto a

for (j= 0; j< cardR; j++) // prima per essere consistenti con le cardinalità

// della trasposta

MATTR [i][j]=MAT[j][i];

// Visualizzazione valori elementi matrice trasposta

printf("\n\n MATRICE TRASPOSTA:\n");

for(i=0;i<cardC;i++)

{printf("\n");

for(j=0;j<cardR;j++)

printf("MATTR(%d, %d) = %d - ", i,j,MATTR[i][j]);

}

}




Dato un array monodimensionale A di interi, di 40 elementi scrivere,

producendo la necessaria documentazione, un programma che permette di:

• Effettuare il riempimento, tramite input da tastiera, dello intero array

con valori tutti pari;

• Calcolare la media dei valori inseriti nello array e contare il numero

degli elementi con valore non superiore a quello della media calcolata e

quello degli elementi con valore superiore a quello di tale media.

Esercizio

52






I: il valore di ciascun elemento dello array A.

Pi: elementi di A devono essere numeri pari.

U:

media dei valori in A;

numero di elementi di A con valore non superiore alla media;

numero di elementi di A con valore superiore alla media;

Pu: numero di elementi di A con valore non superiore alla media maggiore

di zero; somma del numero di elementi di A con valore non superiore alla

media con il numero di elementi di A con valore superiore alla media pari

alla cardinalità dello array




A[i] Elemento Array monodimensionale INT

Tabella delle variabili di Ingresso


containf numero di elementi di A con valore inferiore o uguale alla

media

INT

contasup numero di elementi di A con valore superiore alla media INT

media media dei valori degli elementi in A FLOAT



somma sommatoria di elementi di A INT

i Indice di controllo di ciclo INT


53






Si azzerano i valori delle variabili somma, containf, contasup.

Si riempie, con un ciclo ‘for’, completamente lo array A verificando che si immettano solo

numeri pari, ripetendo l’immissione, con un ciclo ‘do ... while’, finché non è immesso non è

immesso un valore pari.

Man mano che si immettono i valori validi di A[i] si incrementa il valore di somma del

valore valido immesso.

Alla uscita dal ciclo ‘for’ per il riempimento di A, si calcola la media dei valori immessi

dividendo il valore di somma per la cardinalità di A, facendo la conversione di tipo da

intero a reale.

Con un nuovo ciclo ‘for’ si calcolano i valori di containf, contasup , confrontando

ciascun elemento di A con il valore di media: se A[i] è inferiore o uguale alla media si

incrementa di 1 il valore di containf, altrimenti quello di contasup .

Si stampano i valori di containf e contasup ottenuti.



#include<stdio.h>

main()

{const int card=40;

int i, somma, containf, contasup;

int A[card];

float media;

somma=0; containf=0; contasup=0;

for(i=0;i<card;i++)

{do

{printf(" dammi elemento A[%d] \n", i);

scanf("\n%d", &A[i]);

}

while((A[i]%2!=0));

somma=somma+A[i];

}

54





for(i=0;i<card;i++)

printf(" A[%d]= %d \n", i, A[i]);

media=(float)somma/(float)card;

for(i=0;i<card;i++)

{ if (A[i]<=media) containf++;

else contasup++;

}

printf ("Media dei valori di A = %f\n", media);

printf ("Numero elementi di A con valore non superiore alla

media = %d\n", containf);

printf ("Numero elementi di A con valore superiore alla

media= %d\n", contasup);

}



Esempio


Data una matrice quadrata MAT di interi di 20 righe e 20 colonne si vuole

determinare se essa è simmetrica (rispetto alla diagonale principale).


I: il valore di ciascun elemento dello array bidimensionale MAT; il

riempimento di riga dello array, il riempimento di colonna dello array.

Pi: il riempimento di riga e di colonna non può essere maggiore delle

rispettive cardinalità di riga e di colonna. I riempimenti di righe e colonne

devono essere uguali

U: L'indicazione che la matrice MAT è simmetrica o meno.

Pu: nessuna

55





Esempio


Nome Variabile Descrizione Tipo MAT Array bidimensionale INT

riemp Riempimento di riga e di colonna INT


Nome Variabile Descrizione Tipo simmetrica Se pari a 1 indica che la MAT INT

è una matrice simmetrica



Esempio




j Indice di controllo di ciclo INT

k Indice di controllo di ciclo INT

56





Esempio Descrizione del metodo di elaborazione:

E' immesso il riempimento di riga e di colonna dello array MAT, verificando che esso sia

non maggiore della cardinalità di riga e di colonna.

Si legge, tramite due cicli innestati, il valore di ciascun elemento di MAT.

Si pone il valore della variabile simmetrica pari a 'vero' (in C pari ad 1); tramite due

cicli innestati si verifica la simmetria della matrice confrontando gli elementi al di sopra

della diagonale principale con quelli al di sotto di essa in modo che per essi sia verificata la

condizione MAT[i][j]==MAT[j][i] e si aggiorna di conseguenza il valore della

variabile simmetrica, facendo un'operazione di AND logico con il valore che essa

aveva in precedenza.

Alla fine del ciclo si analizza il valore della variabile simmetrica: se esso è pari ad 1, la

matrice MAT è simmetrica altrimenti non lo è.

E’ stampato il risultato.



Esempio

0,0 0,1 0,2 0,3

1,0 1,1 1,2 1,3

2,0 2,1 2,2 2,3

3,0 3,1 3,2 3,3

57






main()

{

const card=20;

int MAT[card][card], i,j, k, riemp, simmetrica;

do

{ printf("Quante Righe e Colonne vuoi inserire?\n");

scanf("%d", &riemp);

}

while (riemp>card);

// Legge in input gli elementi della matrice

for(i=0; i<riemp; i++)

for (j=0; j<riemp; j++)

{



}



// Verifica se la Matrice è simmetrica

// esce dal ciclo appena la condizione MAT[i][j]==MAT[j][i] non è verificata

simmetrica=1;

i=0;

while ((simmetrica==1)&&(i<riemp))

{ j=i+1; // esamina solo gli elementi al di sopra della diagonale principale

// e li confronta con quelli al di sotto di essa in posizione simmetrica

while ((simmetrica==1)&&(j<riemp))

{

simmetrica=(simmetrica && (MAT[i][j]==MAT[j][i]));

j++;

}

i++;

}

if (simmetrica==1) printf("La Matrice MAT è simmetrica\n");

else

printf("La Matrice MAT NON è simmetrica\n");

}


58





Esempio Definizione del problema:

Data una matrice quadrata MAT di interi di 20 righe e 20 colonne si vuole

determinare se in essa esistono elementi il cui valore è pari alla somma dei

fattoriali degli indici di riga e di colonna ed in tal caso indicare quanti sono

tali elementi, la loro posizione ed il loro valore.


I: il valore di ciascun elemento dello array bidimensionale MAT; il

riempimento di riga dello array, il riempimento di colonna dello array.

Pi: il riempimento di riga e di colonna non può essere maggiore delle

rispettive cardinalità di riga e di colonna.

U: il numero di elementi di MAT il cui valore è pari alla somma dei

fattoriali degli indici di riga e di colonna, il valore di tali elementi, la

posizione di tali elementi.

Pu: nessuna



Esempio Tabella delle variabili di Ingresso:

Nome Variabile Descrizione Tipo MAT Array bidimensionale INT

riemp Riempimento di riga e di colonna INT


Nome Variabile Descrizione Tipo contafatt Numero di elementi di MAT il INT

cui valore è pari alla somma dei fattoriali

degli indici di riga e di colonna

MAT(i,j) Elementi di MAT il cui valore è pari INT

alla somma dei fattoriali degli indici

di riga e di colonna

i, j Indici indicanti la posizione degli INT

elementi di MAT il cui valore è pari alla somma

dei fattoriali degli indici di riga e di colonna

59





Esempio Tabella delle variabili di algoritmo:





ifatt Fattoriale dell'indice di riga i INT

jfatt Fattoriale dell'indice di colonna j INT




E' immesso il riempimento di riga e di colonna dello array MAT, verificando che esso sia

non maggiore della cardinalità di riga e di colonna.

Si legge, tramite due cicli innestati, il valore di ciascun elemento di MAT.

Si pone pari a zero il valore della variabile contafatt; tramite due cicli innestati si

effettua una visita totale della matrice MAT e per ogni elemento si verifica se è vera la

condizione MAT[i][j]= i! + j!, dove i! e j! sono i valori del fattoriale dell'indice

di riga e di colonna a quel passo del ciclo, ed in tal caso si incrementa di 1 il valore di

contafatt e si stampa il valore di MAT[i][j] verificante la condizione e quelli degli

indici i e j

Alla fine della visita totale di MAT è stampato il valore di contafatt.

60






main()

{

const card=20;

int MAT[card][card], i,j, k, riemp, ifatt, jfatt, contafatt;

do

{ printf("Quante Righe e Colonne vuoi inserire?\n");

scanf("% d", &riemp);

}

while (riemp>card);

// Legge in input gli elementi della matrice



{



}



// Verifica se MAT(i,j) = i!+j!.

contafatt=0;



{

// Calcola fattoriale di i

ifatt=1;

for(k=2;k<=i;k++) ifatt=ifatt*k;

// Calcola fattoriale di j

jfatt=1;

for(k=2;k<=j;k++) jfatt=jfatt*k;

if (MAT[i][j] == (ifatt + jfatt))

{ contafatt++;

printf("L'elemento in posizione %d, %d uguale alla somma dei fattoriali

degli indici %d\n", i, j, MAT[i][j]);

}

}

printf("Sono stati trovati %d elementi di MAT con valore pari alla somma dei fattoriali

degli indici\n", contafatt);

}


… una prima versione, poco efficiente …

61






contafatt=0;


{// Calcola fattoriale di i

ifatt=1;



{// Calcola fattoriale di j

jfatt=1;

for(k=2;k<=j;k++) jfatt=jfatt*k;

if (MAT[i][j] == (ifatt + jfatt))

{ contafatt++;

printf("L'elemento in posizione %d, %d uguale alla somma dei fattoriali

degli indici %d\n", i, j, MAT[i][j]);

}

}

}



}

Esempio - il programma … una versione più efficiente …

… il fattoriale dell’indice di riga è calcolato

solo ad ogni cambio di riga …



int MAT[card] [card], …., ifat, ….;

longint fatt(int i)

{ int k, ifatt=1;


return ifatt; }

…………..


contafatt=0;


{ ifat=fatt(i);


{ if (MAT[i][j] == (ifat + fatt(j)))

{ contafatt++;

printf(“Elemento in posizione %d, %d uguale alla somma dei fattoriali

degli indici %d\n", i, j, MAT[i][j]); }

}

}



}

Esempio - il programma … una versione più elegante …

… con i sottoprogrammi …

62





Esempio


Scrivere, producendo la necessaria documentazione, un programma che,

dato un array bidimensionale MAT di caratteri, con 10 righe e 10 colonne:

(1) Consente il riempimento dello array con i soli caratteri ‘*’, ‘+’, ‘-‘;

(2) conta, e stampa, quante volte ciascuno dei suddetti caratteri è

presente in ogni riga dello array, e calcola, e stampa, la percentuale totale

della presenza di ciascun carattere nell’intero array;

(3) Ricopia in un array monodimensionale VET di dimensioni

opportune tutti i caratteri di MAT inserendo prima tutti i caratteri ‘+’, poi

tutti gli ‘*’ e poi tutti i ‘-‘



Esempio


I: il valore di ciascun elemento dello array MAT.

Pi: elementi di MAT devono essere uno dei caratteri ‘*’, ‘+’, ‘-‘.

U: Numero dei caratteri ‘*’, ‘+’, ‘-‘ in ciascuna riga, percentuale di

presenza dei caratteri ‘*’, ‘+’, ‘-‘ in MAT, lo array VET.

Pu: Nello array VET ci sono prima tutti i caratteri ‘+’, poi gli ‘*’ e poi i ‘-‘.

63





Esempio


MAT[i][j] Elemento Array bidimensionale CHAR



sommaAst, sommaPiu,

sommaMeno

Numero di caratteri ‘*’, ‘+’,

‘-‘ in ciascuna riga di MAT INT

percAst, percPiu,

percMeno

Percentuale di caratteri

‘*’, ‘+’, ‘-‘ in MAT

FLOAT

VET Array con carrteri

ordinati come richiesto

INT

Tabella delle variabili di Uscita



Esempio



totAst, totPiu,

totMeno

Occorrenze totali di

*, +, - in MAT

INT

i, j Indice di controllo di

ciclo

INT

kAst, kPiu, kMeno Indice di posizione INT

64





Esempio


Si riempie la matrice MAT verificando che si immettano solo i caratteri

richiesti.

Si azzerano i contatori delle occorrenze totali.

Con due cicli for innestati si contano quanti caratteri *,+,- ci sono in ogni

riga, azzerando i contatori ogni qualvolta si cambia riga e stampando il

risultato per ogni riga, ed il numero totale di occorrenze di tali caratteri in

MAT.

Alla fine dell’esecuzione dei due cicli for si calcolano le percentuali di

presenza delle occorrenze.

Infine si riempie lo array VET: con due cicli for si leggono gli elementi di

MAT ed in base al loro valore essi sono inseriti nello array VET,

conoscendo le occorrenze totali di ciascun carattere.



Esempio

#include<stdio.h>

main()

{

const int cardR=10;

const int cardC=10;

int i, j, sommaAst, sommaPiu, sommaMeno, totAst, totPiu, totMeno,

kAst, kPiu, kMeno;

char mat[cardR][cardC], VET[(cardR*cardC)];

float percMeno, percAst, percPiu;



{do

{printf(" dammi elemento mat[%d][ %d] \n", i,j);

scanf("\n%c", &mat[i][j]);

}

while((mat[i][j]!='*') && (mat[i][j]!='+') && (mat[i][j]!='-'));

}

65





Esempio totAst=0; totPiu=0; totMeno=0;


{sommaAst=0; sommaPiu=0; SommaMeno=0;


{ switch (mat[i][j])

{case '*': totAst++; sommaAst++; break;

case '+': totPiu++; sommaPiu++; break;

case '-': totMeno++; sommaMeno++; break;

}

}

printf(“riga %d contiene %d *, %d +, e %d -\n", sommaAst,

sommaPiu, sommaMeno);

}

printf("\n \n Mat contiene %d *, %d +, e %d -\n\n", totAst, totPiu,

totMeno);

percAst= ((float)totAst/(float)(cardR*cardC))*100;

percPiu = ((float)totPiu/(float)(cardR*cardC))*100);

percMeno = ((float)totMeno/(float)(cardR*cardC))*100;

printf("Percentuale di * = %f\n", percAst);

printf("Percentuale di + = %f\n", percPiu);

printf("Percentuale di - = %f\n", percMeno);



Esempio kAst=0; kPiu=0; kMeno=0;



{ switch (mat[i][j])

{case '+': VET[kPiu]=mat[i][j];kPiu++; break;

case '*': VET[totPiu+kAst]=mat[i][j];kAst++; break;

case '-': VET[(totPiu+totAst)+kMeno]=mat[i][j];kMeno++; break;

}

}

printf("\n\n");

for(i=0;i<(cardR*cardC);i++)

printf(" VET[%d]= %c \n", i, VET[i]);

}

… … UNA SOLUZIONE PIU’ ‘FURBA’ … … …

kAst=0; kPiu=0; kMeno=0;

for(i=0;i<totPiu;i++) VET[i]='+' ;

for(i=totPiu;i<totAst;i++) VET[i]='*' ;

for(i=totAst;i<card;i++) VET[i]='-' ;

… … …

66





Esempio

Definizione del problema: Scrivere un programma che consente

di inserire in un array i dati di una agenda telefonica, ovvero

nome, cognome, e n.ro di telefono di una persona e di salvare poi

il contenuto dello array in un file sequenziale di testo. L’agenda

contiene al massimo 200 nomi


I: nome, cognome, e n.ro di telefono


maggiore di 200

U: il file di testo con l’agenda telefonica salvata

Pu: nessuna



Esempio


Cognome stringa

nome stringa

telefono stringa


agenda file di testo memorizzante l’agenda File




????


67





Esempio


…. lo studente riporti la descrizione dell’algoritmo da utilizzare

per il programma …



#include <stdio.h>

#include <string.h>

void legge(char campo[], int max) // legge una stringa

// da tastiera

{ int i = 0; char c;

while ( (c=getchar())!='\n' && (i < max))

{campo[i] = c;

i++;

}

campo[i] = '\0';

}


68





main ()

{

const card=200;

int i, riemp;

struct persona

{char nome[20];

char cogno[20];

char tel[15];

};

struct persona pers[card];

FILE*Fmio;

char risp='S';

i=0;




while (((risp=='S')||(risp=='s'))&&(i<card))

{ fflush(stdin);

printf("Nome: \n"); legge(pers[i].nome, 20);

printf("Cognome: \n"); legge(pers[i].cogno, 20);

printf(" Tel. : \n"); legge(pers[i].tel, 20);

i++;

printf(" Vuoi inserire altre persone? (S/N) ");

risp=getchar();

}

riemp=i;

// stampa contenuto array

for(i=0;i<riemp;i++)

{

printf(" Cognome = %s - ",pers[i].cogno);

printf(" Nome = %s - ", pers[i].nome);

printf(" Tel = %d \n", pers[i].tel);

}


69





printf(" Vuoi salvare i dati su un file? (S/N) ");

scanf("\n%c", &risp);

if ((risp=='S')||(risp=='s'))

{ Fmio=fopen("agenda.txt","w");

if (Fmio == NULL)

printf ("Il file non puo essere aperto \n");

else


fprintf(Fmio,"%s %s %s\n",pers[i].cogno,

pers[i].nome, pers[i].tel);

printf("Agenda Salvata \n");

Fclose(Fmio);

}

else

printf("Agenda non Salvata \n");

}





70





…………………

// Carica lo array dell’agenda leggendo dal file

{Fmio=fopen("agenda.txt","r");

if (!feof(Fmio))

{ i=0;

fscanf(Fmio,"%20s %20s %15s",

&pers2[i].cogno,pers2[i].nome, &pers2[i].tel);

while (!feof(Fmio))

{ printf(" Cognome = %20s - ",pers2[i].cogno);

printf(" Nome = %20s - ", pers2[i].nome);

printf(" Tel = %15s \n", pers2[i].tel);

i++;

fscanf(Fmio,"%20s %20s %15s",&pers2[i].cogno,

&pers2[i].nome, &pers2[i].tel);

}

printf("FINE CARICAMENTO\n");

}

else printf("RAGGIUNTA FINE FILE");

fclose(Fmio);

}

Esempio

140

Definizione del problema: In un file sequenziale in cui è registrata una agenda

telefonica (cognome, nome, n.ro di telefono), si vogliono cercare i dati di una persona in

base al cognome dato in input.


I: il file di testo registrante l’agenda telefonica, il cognome della persona da

cercare

Pi: nessuna

U: il cognome, il nome ed il numero di telefono della persona trovata

Pu: nessuna

File sequenziale

71



141


…. apre in lettura il file …

… legge il cognome da trovare, ….

... Cerca sul file il cognome ...

... Se trova il cognome immesso visualizza cognome nome e n.ro di telefono, altrimenti il

messaggio ‘Cognome non trovato in archivio’.

Chiude il file

Esercizio con File sequenziale

142

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// Cerca un cognome in una agenda telefonica

// registrata in un file sequenziale

main ()

{

struct persona

{ char cogn[20];

char nome[20];

char tel[15];

};

struct persona pers;

char cognome[20];

int nontrovato=1;

FILE*Fmio;


72



143

Fmio=fopen("agenda.txt","r"); //apre file in lettura

printf("Inserisci cognome da cercare: \n");

scanf("%s", &cognome);

if (Fmio != NULL)

{fscanf(Fmio,"%s%s%s\n", &pers.cogn, &pers.nome, &pers.tel);

if (feof(Fmio))

printf("File Vuoto\n");

else

{ while (!feof(Fmio)) // verifica che non si è a fine file

{ if (strcmp(cognome, pers.cogn)==0)

{printf(“TROVATO!!\n Cogn.= %s, Nome=%s, Tel.=%s \n\n", pers.cogn, pers.nome, pers.tel);

nontrovato=0;}

fscanf(Fmio,"%s%s%s\n", &pers.cogn, &pers.nome, &pers.tel);

} // fine while

printf("RAGGIUNTA FINE FILE \n");

if (nontrovato==1) printf ("Cognome non trovato in achivio \n");

} // fine else feof(Fmio)

}

else


fclose(Fmio); //chiude fileint.txt

}

144

Definizione del problema: Si vogliono memorizzare su un file sequenziale il

cognome, il nome ed il numero di telefono di persone; si vogliono poi visualizzare tutte le

informazioni registrate ed eventualmente aggiungerne altre o ricercare o cancellare un

elemento in base al cognome.


I: il cognome, il nome ed il numero di telefono delle persone

Pi: nessuna

U: il cognome, il nome ed il numero di telefono di persone registrati sul file

Pu: nessuna


73



145


… visualizzazione di un menù delle possibili operazioni (crea, aggiungi, trova, cancella) …

…. Selezione dell’operazione

…. Crea, apre in scrittura il file …

… aggiungi, … in append …

… legge il cognome da trovare, apre il file in lettura ….

… legge il cognome da cancellare, apre il file in lettura, ne ricopia il contenuto su un altro

di appoggio tranne le informazioni legate al cognome da cancellare … riscrive l’agenda

ricopiando su essa il file di appoggio …

…

File sequenziale

146

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// gestisce una agenda telefonica con un file

// sequenziale

main ()

{

struct persona

{ char cogn[40];

char nome[40];

char tel[15];

};


char risp;

char cognome[40];

int scelta, nontrovato=1;

FILE*Fmio;

FILE*F2;

do

{ do

{

printf("\n\n PROGRAMMA GESTIONE

Agenda \n");

printf("1. Crea agenda \n");

printf("2. Stampa agenda \n");

printf("3. Aggiungi \n");

printf("4. Cerca \n");

printf("5. Cancella \n");

printf("0. FINE\n");

printf("Immetti n.ro operazione \n");

scanf("%d", &scelta);

} while ((scelta<0) || (scelta>5));

Gestione Agenda telefonica con un file sequenziale

74



147

Lo studente continui a sviluppare il programma

148

if (scelta!=0)

switch (scelta)

{ case 1 : // Crea Agenda

{Fmio=fopen("age.txt","w");

if (Fmio == NULL)


else

{

do

{printf("Vuoi inserire persone? (S/N)\n");


}

while ((risp!='S' && risp!='s') &&

(risp!='N' && risp!='n'));

// legge dati e li scrive nel file

while (risp=='S' || risp=='s')

{ printf("Cognome ");

scanf("%s", &pers.cogn);

printf("Nome ");

scanf("%s", &pers.nome);

printf("Tel. ");

scanf("%s", &pers.tel);

// scrive il record sul file

fprintf(Fmio,"%s %s %s\n",pers.cogn,

pers.nome, pers.tel);

printf("Vuoi inserire altre persone? (S/N)\n");


}

} // fine else

// chiusura del file

fclose(Fmio);

break;

// fine case 1


75



149

case 2 : //Stampa agenda

{Fmio=fopen("age.txt","r"); //apre file in lettura

if (Fmio != NULL)

{ fscanf(Fmio,"%s%s%s\n", &pers.cogn, &pers.nome, &pers.tel);

if (feof(Fmio))


else


{ printf("%s, %s, %s \n", pers.cogn, pers.nome, pers.tel);

fscanf(Fmio,"%s %s %s", pers.cogn, pers.nome, &pers.tel);

} // fine while

printf("RAGGIUNTA FINE FILE");

}// fine else

} // fine if

else



break;

} // fine case 2


150

case 3: //Aggiungi

{

// apertura del file in append

Fmio=fopen("age.txt","a");

if (Fmio == NULL)


else

{

do

{printf("Vuoi aggiungere persone? (S/N)\n");


}

while ((risp!='S' && risp!='s') && (risp!='N' && risp!='n'));


76



151

// legge dati e li scrive nel file

while (risp=='S' || risp=='s')

{ printf("Cognome ");

scanf("%s", &pers.cogn);

printf("Nome ");

scanf("%s", &pers.nome);

printf("Tel. ");

scanf("%s", &pers.tel);

// scrive il record sul file

fprintf(Fmio,"%s %s %s\n", pers.cogn, pers.nome, pers.tel);

printf("Vuoi aggiungere altre persone? (S/N)\n");


} // fine while

} // fine else ’ if (Fmio == NULL)’

// chiusura del file

fclose(Fmio);

break;

}

} // fine case 3


152

case 4 : //Cerca

{Fmio=fopen("age.txt","r"); //apre file in lettura

nontrovato=1;



if (Fmio != NULL)


if (feof(Fmio))


else



{ printf("%s, %s, %s \n\n", pers.cogn, pers.nome, pers.tel);

nontrovato=0;}


}



77



153


}// fine else

}

else



break;

} // fine case 4


154

case 5 : // Cancella

{Fmio=fopen("age.txt","r"); //apre file age.txt in lettura

F2=fopen("appoggio.txt", "w"); // apre file appoggio in scrittura

printf("Inserisci cognome da cancellare: \n");


nontrovato=1;

if (Fmio != NULL)

{ fscanf(Fmio,"%s%s%s\n", &pers.cogn, &pers.nome, &pers.tel);

if (feof(Fmio))


else


{ if (strcmp(cognome, pers.cogn)!=0)

fprintf(F2,"%s %s %d\n", pers.nome, pers.cogn, pers.tel);

else nontrovato=(nontrovato && strcmp(cognome, pers.cogn));

fscanf(Fmio,"%s %s %d", &pers.cogn, &pers.nome, &pers.tel);

}

printf("RAGGIUNTA FINE FILE\n");

if (nontrovato==1) printf("Cognome non presente in Archivio \n");

else printf(“Cognome Cancellato \n”);

}// fine else feof

}


78



155

else



fclose(F2);

// ricopia appoggio.txt su age.txt

Fmio=fopen("age.txt","w"); //apre file age.txt in scrittura

F2=fopen("appoggio.txt", "r"); // apre file appoggio in lettura

fscanf(F2,"%s %s %s", pers.cogn, pers.nome, &pers.tel);

while(!feof(F2))

{fprintf(Fmio,"%s %s %s\n", pers.nome, pers.cogn, pers.tel);

fscanf(F2,"%s %s %s", pers.cogn, pers.nome, &pers.tel);

}

fclose(Fmio); fclose(F2);

break;

} // fine case 5

} // fine switch

} while(scelta!=0);

system(“Pause”);

} // fine programma


156

Lo studente ristrutturi il programma con adeguati sottoprogrammi

79







Esempio


Scrivere, producendo la necessaria documentazione, un programma in

linguaggio C che dati due array monodimensionali di interi A e B

rispettivamente di cardinalità 15 e 25 consente:

- di riempire completamente i due array con valori compresi tra -10 e +30

(estremi inclusi)

- contare, e stampare, quante volte ciascun elemento di A compare anche in

B;

- verificare se lo array A è interamente contenuto nello array B (cioè se B

contiene tutti gli elementi di A nella stessa sequenza con cui essi

compaiono in A).

80





Esempio


I: il valore di ciascun elemento degli array A e B.

Pi: il valore di ciascun elemento degli array A e B deve essere

compreso tra -10 e +30 (estremi inclusi).

U: Numero di volte che un elemento di A è presente anche in B;

informazione che indica se l'array A è completamento contenuto

in B.

Pu: nessuna



Esempio



A Array monodimensionale INT

B Array monodimensionale INT



conta Numero di volte che un

elemento di A è presente

anche in B

INT

contenuto indica se l'array A è

completamento contenuto

in B

LOGICAL

81





Esempio







Esempio


Si legge, tramite un ciclo ripetitivo, il valore di ciascun elemento di A in modo da rispettare

la precondizione;

Si legge, tramite un ciclo ripetitivo, il valore di ciascun elemento di B in modo da rispettare

la precondizione;

- Si considera, tramite un ciclo ripetitivo, ciascun elemento di A e utilizzando un altro ciclo

ripetitivo innestato nel primo si confronta ciascun elemento di A con tutti gli elementi di B

e si incrementa di 1 la variabile conta ogni volta che si trova un elemento di B con un

valore uguale all'elemento di A considerato; al termine del ciclo più interno si stampa il

numero di volte che l'elemento di A è contenuto in B;

- Si scandisce B fino all'elemento in posizione pari a cardB-cardA (dove cardB è la

cardinalità di B e cardA è la cardinalità di A); se si verifica che l'elemento considerato

sia uguale al primo elemento di A si continua a verificare se anche gli elementi successivi

di B sono uguali a quelli successivi di A ed in tal caso si pone pari a 1 la variabile

contenuto ; alla fine della scansione se la variabile contenuto è pari ad 1 allora A è

contenuto in B altrimenti non lo è.

82





Esempio - il programma C #include<stdio.h>

main()

{

const int cardA=15, cardB=25;

int i, j, contenuto, conta;

int A[cardA], B[cardB];

// Legge in input gli elementi del vettore A

for (i= 0; i< cardA; i++)

{do

{printf(" dammi elemento di A di posto %d\n", i);

scanf("% d", &A[i]);}

while ((A[i]<-10)|| (A[i]>30));

}

// Legge in input gli elementi del vettore B

for (i= 0; i< cardB; i++)

{ do

{printf(" dammi elemento di B di posto %d\n", i);

scanf("% d", &B[i]);}

while ((B[i]<-10)|| (B[i]>30));

}



// Conta quante volte un elemento di A è presente in B

for (i= 0; i< cardA; i++)

{

conta=0;

for (j= 0; j< cardB; j++)

if(A[i]== B[j]) conta++;

printf("Elemento A[%d]=%d presente %d volte in B\n",i, A[i],

conta);

}


83





// Verifica se A è completamente contenuto in B

conta=0;

contenuto=0;

i=0;

do

{ if (B[i]==A[conta])

{j=i;

do

{conta++;

j++;

}

while ((B[j]==A[conta])&&(conta<cardA));

if (conta==cardA)

contenuto=1;

}

i++;

conta=0;

}

while(i<=(cardB-cardA));

if (contenuto == 1) printf ("Array A completamente contenuto in B\n");

else printf("Array A NON contenuto in B\n");

}




84





Esempio

Definizione del problema: Scrivere un programma che consente

di inserire in un array i dati di una agenda telefonica, ovvero

nome, cognome, e n.ro di telefono di una persona e di salvare poi

il contenuto dello array in un file sequenziale di testo. L’agenda

contiene al massimo 200 nomi


I: nome, cognome, e n.ro di telefono


maggiore di 200

U: il file di testo con l’agenda telefonica salvata

Pu: nessuna



Esempio


Cognome stringa

nome stringa

telefono INT


agenda file di testo memorizzante l’agenda File




????


85





Esempio


…. lo studente riporti la descrizione dell’algoritmo da utilizzare

per il programma …



#include <stdio.h>

#include <string.h>

void legge(char campo[], int max) // legge una stringa

// da tastiera

{ int i = 0; char c;

while ( (c=getchar())!='\n' && (i < max))

{campo[i] = c;

i++;

}

campo[i] = '\0';

}


86





main ()

{

const card=200;

int i, riemp;

struct persona

{char nome[20];

char cogno[20];

char tel[15];

};

struct persona pers[card];

FILE*Fmio;

char risp='S';

i=0;




while (((risp=='S')||(risp=='s'))&&(i<card))

{ fflush(stdin);

printf("Nome: \n"); legge(pers[i].nome, 20);

printf("Cognome: \n"); legge(pers[i].cogno, 20);

printf(" Tel. : \n"); legge(pers[i].tel, 20);

i++;

printf(" Vuoi inserire altre persone? (S/N) ");

risp=getchar();

}

riemp=i;

// stampa contenuto array


{

printf(" Cognome = %s - ",pers[i].cogno);

printf(" Nome = %s - ", pers[i].nome);

printf(" Tel = %d \n", pers[i].tel);

}


87





printf(" Vuoi salvare i dati su un file? (S/N) ");


if ((risp=='S')||(risp=='s'))

{ Fmio=fopen("agenda.txt","w");

if (Fmio == NULL)


else


fprintf(Fmio,"%s %s %s\n",pers[i].cogno,

pers[i].nome, pers[i].tel);

printf("Agenda Salvata \n");

Fclose(Fmio);

}

else

printf("Agenda non Salvata \n");

}





88





Lo studente scriva un programma (o modifichi il precedente)

che carichi in un array di struct i dati del file agenda.txt

e permetta di effettuare la ricerca per cognome in tale

array.

…………………


{

………………

}

Esempio



…………………


{Fmio=fopen("agenda.txt","r");

if (!feof(Fmio))

{ i=0;

fscanf(Fmio,"%19s %19s %14s", &pers2[i].cogno,pers2[i].nome,

&pers2[i].tel);

while (!feof(Fmio))

{ printf(" Cognome = %19s - ",pers2[i].cogno);

printf(" Nome = %19s - ", pers2[i].nome);

printf(" Tel = %14s \n", pers2[i].tel);

i++;

fscanf(Fmio,"%19s %19s %14s",&pers2[i].cogno,

&pers2[i].nome, &pers2[i].tel);

}

printf("FINE CARICAMENTO\n");

}

else printf("RAGGIUNTA FINE FILE");

fclose(Fmio);

}

Esempio

89



177

Definizione del problema: In un file sequenziale in cui è registrata una agenda

telefonica (cognome, nome, n.ro di telefono), si vogliono cercare i dati di una persona in

base al cognome dato in input.


I: il file di testo registrante l’agenda telefonica, il cognome della persona da

cercare

Pi: nessuna

U: il cognome, il nome ed il numero di telefono della persona trovata

Pu: nessuna

File sequenziale

178


…. apre in lettura il file …

… legge il cognome da trovare, ….

... Cerca sul file il cognome ...

... Se trova il cognome immesso visualizza cognome nome e n.ro di telefono, altrimenti il

messaggio ‘Cognome non trovato in archivio’.

Chiude il file


90



179

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// Cerca un cognome in una agenda telefonica

// registrata in un file sequenziale

main ()

{

struct persona

{ char cogn[20];

char nome[20];

char tel[15];

};


char cognome[20];

int nontrovato=1;

FILE*Fmio;


180

Fmio=fopen("agenda.txt","r"); //apre file in lettura

nontrovato=1;



if (Fmio != NULL)


if (feof(Fmio))


else



{ printf(“Cogn.= %s, Nome=%s, Tel.=%s \n\n", pers.cogn, pers.nome, pers.tel);

nontrovato=0;}


}



}// fine else

}

else



}

91





Esempio Definizione del problema:

Dato un array monodimensionale VET di interi di 20 elementi tutti

diversi da zero, si vuole determinare se in esso esistono elementi con

valori uguali; si vuole indicare quali sono gli indici di posizione degli

elementi uguali e porre pari a zero tutti gli elementi duplicati (lasciando

invariato quello 'origine').


I: il valore di ciascun elemento dello array; il riempimento dello array.

Pi: il riempimento non può essere maggiore della cardinalità di riga.

Ogni elemento di VET è diverso da zero

U: Gli indici degli elementi duplicati; lo array VET con gli elementi

doppioni contenenti tutti elementi pari a zero.

Pu: nessuna



Esempio

Se lo array ‘riempito’ in input è:

13

21

44

13

47

44

13

22

13

21

44

0

47

0

0

22

Lo array in output sarà:

92







VET Array monodimensionale INT

Riemp Riempimento di riga INT



VET Array di ingresso con elementi INT

doppioni tutti pari a zero

i Indici delle coppie di righe doppioni INT







93






E’ immesso il riempimento dello array: tale valore deve essere non maggiore della

cardinalità.

Si legge, tramite un ciclo ripetitivo, il valore di ciascun elemento di VET e si verifica

che esso sia diverso da zero, in tal caso il valore dell'elemento deve essere re-immesso.

Si confronta, tramite un ciclo ripetitivo, ciascun elemento, dal primo al penultimo, di

VET con i successivi; se due elementi sono uguali si stampao i valori degli indici degli

elementi uguali e si azzera l’elemento doppione.

Si evita di analizzare le gli elementi eventualmente già azzerati (perché doppioni di

altri) verificando l’elemento considerato sia diverso da zero (la specifica dice che gli

elementi iniziali di VET devono essere tutti diversi da zero).

Infine si stampano i valori dello array VET.




main()

{const card=20;

int VET[card], i, k, riemp;

// Immissione riempimento

do

{ printf("Quanti elementi vuoi inserire?\n");

scanf("% d", &riemp);

}

while (riemp>card);


{ // Legge ciascun elemento e verifica che esso non è pari a zero, richiedendone

// eventualmente il reinserimento

do

{ printf(" dammi el. %d di VET\n", i);

scanf("%d", &VET[i]);

}

while(VET[i]==0);

}

94





Esempio //Confronta gli elementi dal primo al penultimo con i successivi

for (i=0; i<(riemp-1); i++)

{ //Verifica che l’elemento considerato non è già azzerato perché doppione di un altro

if(VET[i]!=0)

{ //Ciclo per considerare gli elementi successivi allo i-esimo

for(k= i+1; k<riemp; k++)

if (VET[i]==VET[k]

{ printf(“elemento in %d ed elemento in %d uguali a %d\n",i,k, VET[i]);

VET[k]=0;

}

}

}

// Stampa array finale

for (i=0;i<riemp; i++)

printf(“VET[%d]= %d \n", i,VET[i]);

}



Esempio


Dato un array bidimensionale MAT di interi di 20 righe e 15 colonne i cui elementi, letti in

input da tastiera, sono tutti diversi da zero. Si vuole determinare se in esso esistono righe

uguali; si vuole indicare quali sono gli indici di riga delle coppie di righe uguali e porre pari

a zero tutti gli elementi di ciascuna riga duplicata (lasciando invariata la prima riga

'origine'). Strutturare il programma con sottoprogrammi


I: il valore di ciascun elemento dello array bidimensionale MAT; il riempimento di riga dello

array, il riempimento di colonna dello array.

Pi: il riempimento di riga e di colonna non può essere maggiore delle rispettive cardinalità di

riga e di colonna. Ogni elemento di MAT è diverso da zero

U: Gli indici delle coppie di righe duplicate; lo array MAT con le righe doppioni contenenti

tutti elementi pari a zer.

Pu: nessuna

95





0

1

2

3

4

0 1 2 3 4

23 47 63 96 8

27 66 23 44 567

47

...

23

... 15

32 ...

63 MAT 96 8

0

1

2

3

4

0 1 2 3 4

23 47 63 96 8

27 66

0

…

0

... 15

32 …

0 MAT

23 44 567

0 0





MAT Array bidimensionale INT

riempR Riempimento di riga INT

riempC Riempimento di colonna INT



MAT Array di ingresso con le righe INT

doppioni con elementi tutti pari a zero

i, k Indici delle coppie di righe doppioni INT

96










x Indice di controllo di ciclo INT

trovato Contatore indicante quanti INT

elementi di una riga sono

uguali a quelli di un'altra




Sono immessi i riempimenti di riga e di colonna dello array MAT: tali valori devono

essere non maggiori delle rispettive cardinalità di riga e di colonna.

Si legge, tramite un ciclo ripetitivo, il valore di ciascun elemento di MAT e si verifica

che esso sia diverso da zero, in tal caso il valore dell'elemento deve essere reimmesso.

Si confronta, tramite un ciclo ripetitivo, ciascuna riga, dalla prima alla penultima, di

MAT con le successive; in particolare ciascun elemento di una riga viene confrontato

(tramite un ciclo ripetivo che scandisce le colonne di MAT) con ciascun elemento di una

riga successiva in posizione omologa: se i due elementi sono uguali si incrementa il

contatore trovato. Analizzata tutta una riga, se il valore di trovato è pari a quello

di riempC (riempimento di colonna) allora le due righe sono uguali: si stampano i

valori degli indici dell due righe uguali e, tramite un ciclo ripetitivo si procede

all'azzeramento degli elementi della riga doppione.

Si evita di analizzare le righe eventualmente azzerate (perché doppioni di altre)

verificando che il primo elemento di ciascuna riga sia diverso da zero (la specifica dice

che gli elementi iniziali di MAT devono essere tutti diversi da zero).

Infine si stampano i valori dello array MAT eventualmente modificato

97





Esempio

… STRUTTURAZIONE IN SOTTOPROGRAMMI …

main

legggiRIEMP stampaMAT leggiMAT

doppioni



Esempio #include<stdio.h

#define COL 15

void legggiRIEMP (int *R, int maxcard)

{do


scanf("%d", &*R);

} while (*R>maxcard);

}

void stampaMAT(int R, int C, int FMAT[][COL])

{ int i, j;

for (i=0;i<R; i++)

{for (j=0;j<C;j++)

printf("%d - ", FMAT[i][j]);

printf("\n");

}

}

98





void leggiMAT( int R, int C, int FMAT[][COL])

{ int i, j;

for(i=0; i<R; i++)

for (j=0; j<C; j++)

{/*Legge ciascun elemento, verifica che non è pari a zero,

richiedendone in tal caso il reinserimento */

do

{ printf(" dammi el. (%d , %d) della Matrice\n", i,j);

scanf("%d", &FMAT[i][j]);

} while(FMAT[i][j]==0);

}

}

Esempio



void doppioni (int R, int C, int FMAT[][COL])

main()

{const cardR=20, cardC=COL;

int MAT[cardR] [cardC], i,j, k, x, riempR, riempC, trovato;

printf("Immissione riempimento di riga\n");

legggiRIEMP (&riempR, cardR);

printf("Immissione riempimento di colonna\n");

legggiRIEMP (&riempC, cardC);

leggiMAT(riempR,riempC, MAT);

stampaMAT(riempR,riempC, MAT);

printf("\n\n");

doppioni (riempR,riempC, MAT);

// Stampa array finale MAT

printf("\n Stampa array con righe doppioni azzerate \n");

stampaMAT(riempR,riempC, MAT);

system("Pause");

}

Esempio

99





void doppioni (int R, int C, int FMAT[][COL])

{int trovato, i, k, j, x;

for (i=0; i<(R-1); i++)

{ if(FMAT[i][0]!=0)

{ for(k=i+1; k<R; k++) // scandisce le righe successive alla i-esima

{trovato=0;

for(j=0; j<C; j++) // verifica se gli elementi nelle due righe i e k sono uguali

if (FMAT[i][j]==FMAT[k][j])

trovato++;

if (trovato==C)

{ printf("la riga %d e la riga %d sono uguali\n\n",i,k);

for (x=0;x<C; x++) FMAT[k][x]=0; //azzera riga doppione

}

}

}

}

}

Esempio



Esempio

senza sottoprogrammi #include<stdio.h>

main()

{

// LO STUDENTE DEFINISCA UN MAIN CHE ATTIVI I VARI

// SOTTOPROGRAMMI PER RISOLVERE IL PROBLEMA

}

100





Esempio

senza sottoprogrammi #include<stdio.h>

main()

{

const cardR=20, cardC=15;

int MAT[cardR] [cardC], i,j, k, x, riempR, riempC, trovato;

// Immissione riempimento di riga

do

{ printf("Quante Righe vuoi inserire?\n");

scanf("% d", &riempR);

}

while (riempR>cardR);

// Immissione riempimento di colonna

do

{ printf("Quante Colonne vuoi inserire?\n");

scanf("% d", &riempC);

}

while (riempC>cardC);



// Legge in input tutti gli elementi della matrice, tutti diversi da zero

for(i=0; i<riempR; i++)

for (j=0; j<riempC; j++)

{

// Legge ciascun elemento e verifica che esso non è pari a zero, richiedendone

eventualmente il reinserimento

do



}

while(MAT[i][j]==0);

}

Esempio

senza sottoprogrammi

101





//Confronta le righe dalla prima alla penultima con le successive

for (i=0; i<(riempR-1); i++)

{ //Verifica che quella considerata non è una riga già azzerata perché doppione di

un'altra

if(MAT[i][0]!=0)

{ //Ciclo per considerare le righe successive alla i-esima

for(k= i+1; k<riempR; k++)

{trovato=0;

for(j= 0; j<(riempC); j++) // Ciclo per scandire le colonne

// Se gli elementi in posizioni omologhe nelle due righe sono uguali

incrementa la variabile trovato

if (MAT[i][j]==MAT[k][j]) trovato++;

// Se tutti gli elementi delle due righe sono uguali stampa indici di

righe doppioni ed azzera la riga doppione

if (trovato==riempC)

{ printf("la riga %d e la riga %d sono uguali\n",i,k);

for (x=0;x<(riempC); x++) MAT[k][x]=0;

}

}

}

}



// Stampa array finale MAT

for (i=0;i<riempR; i++)

for (j=0;j<riempC;j++)

printf("MAT[%d][%d]= %d \n", i,j, MAT[i][j]);

}

Esempio

senza sottoprogrammi

102





Esempio

Definizione del problema: Calcolare il prodotto (riga per colonna) tra due matrici

Definizione dei dati del problema :

I: i due array bidimensionali; il valore di ciascun elemento degli array

Pi: il numero di colonne del primo array deve essere uguale al numero di righe del

secondo

U: l’array bidimensionale risultante dal prodotto dei due in ingresso

Pu: nessuna

Descrizione del metodo di elaborazione: Si legge, in ordine di riga, il valore di

ciascun elemento del primo array. Si legge, in ordine di riga, il valore di ciascun elemento

del secondo array. Si verifica che il numero di colonne del primo array sia uguale al

numero di righe del secondo. Si calcola il valore di ciascun elemento della matrice prodotto

secondo la nota regola:

n

k

jkkiji BAC1

,,, *

Stampare la matrice prodotto risultante C



7 3 1

2 6 4

1 5 2

3 6 4

3 4

2 1

6 5

33 36

42 34

25 19

45 38

(7*4)+(3*1)+(1*5) = 36 (7*3)+(3*2)+(1*6) = 33

(3*3)+(6*2)+(4*6) = 45 (3*4)+(6*1)+(4*5) = 38

A B

C = A * B

n

k

jkkiji BAC1

,,, *

103





Esempio


MAT1 prima matrice di interi INT

MAT1(I,J) elemento della prima matrice INT

MAT2 seconda matrice di interi INT

MAT2(I,J) elemento della seconda matrice INT


MATP Matrice prodotto di MAT1 e MAT2 INT






main()

{ const cardR=5, cardC=7, cardC2=3;

int MAT1[cardR] [cardC], MAT2 [cardC] [cardC2];

int MATP[cardR] [cardC2],k , i,j;

// Legge in input tutti gli elementi della prima matrice

for (i= 0; i< cardR; i++)


{ printf(" dammi el. (%d , %d) di MAT1\n", i,j);

scanf("%d", &MAT1[i][j]);

}

// Legge in input tutti gli elementi della seconda matrice

for (i= 0; i< cardC; i++)

for (j= 0; j< cardC2; j++)

{printf(" dammi el. (%d , %d) di MAT2\n", i,j);

scanf("%d", &MAT2[i][j]);

}

104





Esempio - il programma // Calcolo prodotto tra MAT1 e MAT2


for(j=0;j<cardC2;j++)

{

MATP[i,j]=0;

for (k=0; k<cardC;k++)

MATP[i][j]=MATP[i][j]+MAT1[i][k]*MAT2[k][j];

}

// Visualizzazione valori elementi matrice prodotto


for(j=0;j<cardC2;j++)

printf(“MATP(%d, %d) = %d \n”, i,j,MATP[i] [j]);

}



Esempio

Definizione del problema: Scrivere, producendo la necessaria documentazione, un programma che,

dato un array monodimensionale VET di caratteri, con cardinalità pari a 30:

• Consente il riempimento dello array con i soli caratteri corrispondenti alla

dieci cifre decimali (0,1,2,3,4,5,6,7,8,9) ed al carattere '+' e, dopo che è

stato riempito, verifica che in esso non esistano due segni '+' consecutivi

e per ogni volta che ciò accade elimina uno dei due segni consecutivi

compattando lo array;

• Aggiunge, se possibile, automaticamente nella prima posizione dello

array il carattere '=' (segno di uguale) e accoda all'ultimo carattere

presente nello array il carattere ';' (punto e virgola).

105





Esempio

Definizione dei dati del problema: I: il valore di ciascun elemento dello array monodimensionale; il

riempimento dello array.

Pi: il riempimento non può essere maggiore della cardinalità. Il valore di

ciascun elemento dello array deve essere compreso tra i caratteri 0 e 9

(estremi inclusi) o essere il carattere '+';

U: array compattato dopo l'eliminazione degli elementi '+' consecutivi, ed

eventualmente con l'aggiunta dei caratteri '=' e ';' in prima ed ultima

posizione.

Pu: nessuna


Prof. G. A. Di Lucca - Univ. del Sannio 210 210




vett Array monodimensionale CHAR

riemp Riempimento array INT

Nome

Variabile

Descrizione Tipo

vett array compattato dopo l'eliminazione degli elementi '+'

consecutivi, ed eventualmente con l'aggiunta dei caratteri

'=' e ';' in prima ed ultima posizione

CHAR





106






E' immesso il riempimento dell'array vett controllando che esso non sia superiore alla cardinalità

dello stesso. Sono immessi i valori dello array vett controllando che ciascuno di essi è un carattere

compreso tra 0 e 9 oppure il caratere '+'. Questa verifica può essere effettuata valutando l'espressione

booleana: (((vett[i]<'0') || (vett[i]>'9')) && (vett[i]!='+')). Se tale espressione è vera, dovrà essere

ripetuta l'immissione del carattere in quanto quello immesso non rispetta la precondizione.

Si stampa lo array così riempito.

Si visita lo array vett e si verifica se l'elemento considerato e quello immediatamente ad esso

successivo sono pari a '+': in tal caso, se l'elemento considerato non è l'ultimo elemento dello array, si

traslano, per eliminare tale elemento e compattare lo array, di una posizione tutti gli elementi di vett

in posizioni successive a quello considerato e si decrementa di 1 il riempimento riemp (se l'elemento

pari a '+' è l'ultimo elemento dello array basta decrementare di 1 riemp).

Si stampa lo array vett compattato.

Si verifica se esistono due posizioni libere nello array per inserire i caratteri '=' e ';' in esso,

rispettivamente in testa ed in coda agli altri elementi già presenti in esso. Per inserire il carattere '=' in

testa agli altri, bisogna prima shiftare di una posizione tutti quelli presenti. Si incrementa di 1 il

riempimento e si inserisce '=' nella prima posizione dello array. Si incrementa di 1 il riempimento e

nella ultima posizione indicata da esso si inserisce il valore ';'.

Esempio



#include<stdio.h>

main()

{ const int card=30;

int i, j, riemp;

char vett[card];

// Immissione riempimento

do


scanf(“%d", &riemp);

}

while (riemp>card);


for (i= 0; i< riemp; i++)

do

{ printf(" dammi elemento di posto %d\n", i);

scanf("\n%c", &vett[i]);

}

while (((vett[i]<'0') || (vett[i]>'9')) && (vett[i]!='+'));

// verifica valore immesso compreso tra 0 e 9 e uguale a +

// stampa lo array vett riempito

for (i= 0; i< riemp; i++) printf(" VETT[%d]= %c\n", i, vett[i]);


107





// Si verifica se esistono segni '+' consecutivi

//e li si elimina compattando lo array

i=0;

do

{if ((i!=riemp-1) && (vett[i]=='+') && (vett[i+1]=='+'))

{//se l'uguaglianza non si è verificata per l'elemento nell'ultima

//posizione si compatta lo array spostando gli elementi di 1 posto

// Ciclo per compattare lo array

for (j=i;j<(riemp-1);j++)

vett[j]=vett[j+1];

riemp--; //decrementa riempimento e riprende il ciclo dalla stessa

//posizione nello array (possono esserci elementi uguali

// a '+' in posizioni consecutive dello array)

}

else i++; // se l'elemento considerato è diverso da '+'

// passa alla posizione successiva dello array

}

while (i<riemp-1);



// stampa lo array vett compattato


// Inserisce, eventualmente, i caratteri '=' e ';'

if (riemp<=(card-2))

{

riemp++;

for (j=(riemp-1);j>0;j--) vett[j]=vett[j-1];

vett[0]= '=';

vett[riemp]=';';

riemp++;

}

// stampa lo array vett finale


}


108





Esempio

Analisi e Specifica

Definizione del problema: Sviluppare un programma per

generare un mazzo di carte ‘francesi’e mescolarlo.


I: il mazzo di carte (ciascuna carta è identificata dal valore e

dal seme);

Pi: il numero delle carte è 52, con 4 semi e 13 valori per ogni

seme

U: mazzo di carte mescolato

Pu: nessuna



Esempio


carta Carta composta da un valore e seme record

mazzocarte[] Array formante il mazzo di carte Array di

carta



mazzocarte[] Array formante il

mazzo di carte

mescolate

Array di carta

Tabella delle variabili di Uscita

109





Esempio


valore[] Array dei valori di una carta char

seme[] Array dei semi delle carte char

i, k, j indici int




Esempio


Si dichiara una struttura (struct) per definire la composizione di una carta

formata dai due campi valore e seme; si dichiara un array di tale struttura.

Si dichiarano ed inizializzano due array di semi e valori.

Si inizializza il ‘seme’ della funzione rand().

Si genera un ‘nuovo’ mazzo di carte in cui le carte sono ordinate per valore

e seme.

Si mescola il mazzo di carte ‘swappando’ in modo random le carte in esso

Si stampa il contenuto del mazzo di carte.

110





Esempio #include <stdio.h>

#include <stdlib.h>

#include <time.h>

main()

{

struct carta {

char valore;

char seme;

};

struct carta mazzocarte[52], temp;

char valore[] = {'A', '2', '3', '4', '5',

'6', '7', '8', '9', '0',

'J', 'Q', 'K'};

char seme[4] = {'C', 'Q', 'F', 'P'};

int i,k, j;

srand(time(NULL));



Esempio // crea il mazzo di carte

for (i = 0; i < 52; i++)

{ k=(i%13);

mazzocarte[i].valore = valore[k];

mazzocarte[i].seme = seme[(i / 13)];

}

// mescola il mazzo di carte

for (i = 0; i < 52; i++)

{ j = rand() % 52;

temp = mazzocarte[i];

mazzocarte[i] = mazzocarte[j];

mazzocarte[j] = temp;

}

//stampa la sequenza delle carte nel mazzo mescolato

for (i = 0; i < 52; i++)

printf("%5c of %c", mazzocarte[i].valore,

mazzocarte[i].seme);

}

111





Esempio

Definizione del problema: Scrivere, producendo la necessaria documentazione, un programma che,

dato un array bidimensionale MAT di reali, di 15 righe e 15 colonne:

(1)riempie automaticamente lo array in modo che il valore di ciascun

elemento sia pari alla somma tra il triplo del valore dell’indice di riga e la

metà del valore dell’indice di colonna (ad es. per l’elemento MAT[4][7]

dovrà essere MAT[4][7]=(4*3)+(7/2)=15,5 , e stampa lo array così

ottenuto;

(2)Calcola la produttoria degli elementi di MAT con valori dell’indice di

riga pari, e la sommatoria degli elementi con valori dell’indice di colonna

dispari (il valore 0 è considerato pari) e calcola e stampa la media di

questi due valori.



Esempio

Definizione dei dati del problema: I: i valori degli indici di riga e di colonna.

Pi: i valori degli indici di riga e di colonna non devono essere maggiori delle

cardinalità di riga e di colonna rispettivamente

U: Lo array MAT riempito con valori calcolati come specificato

la produttoria degli elementi di MAT con valori dell’indice di riga pari

la sommatoria degli elementi con valori dell’indice di colonna è dispari

la media tra il valore della produttoria e della sommatoria

Pu: i valori degli elementi di MAT e della media sono non negativi

112





Esempio



i, j indici, rispettivamente, di riga e

di colonna dello array MAT

INT



mat array bidimensionale MAT riempito con valori calcolati

come specificato

FLOAT

media la media tra il valore della produttoria (degli elementi di

MAT con valori dell’indice di riga pari) e della sommatoria

(degli elementi con valori dell’indice di colonna è dispari)

FLOAT

somma sommatoria degli elementi di MAT con valori dell’indice di

colonna è dispari

FLOAT

prod produttoria degli elementi di MAT con valori dell’indice di

riga pari

FLOAT



Definizione del problema: Si vuole realizzare un programma per giocare a battaglia

navale. Il calcolatore posiziona automaticamente le navi sul campo di battaglia ed il

giocatore le deve colpire tutte. Ad ogni tiro il calcolatore dirà se è stata colpita o meno una

nave. Alla fine sarà indicato quanti tiri sono stati effettuati. Viene visualizzato il campo di

battaglia con gli esiti di ciascun tiro: ‘C’ = nave Colpita – ‘A’ tiro in Acqua.

ESERCIZIO


I: dimensione del campo di battaglia; numero di navi; coordinate tiro;

Pi: dimensione massima 26 x 26; numero navi massimo il 35 per cento della

dimensione

U: per ciascun tiro indicazione se è stata colpita una nave numero totale di tiri

effettuati per colpire tutte le navi

Pu: tutte le navi sono state colpite

113






….

si inizializza il campo definedone le dimensioni e la percentuale di riempimento di navi….

… il sistema inserisce automaticamete le navi nel campo di battaglia scrivendo una ‘N’

nella posizione occupata da una nave…

… si effettua lo sparo fornendo le coordinate del tiro (riga e colonna)…

… si verifica l’esito del tiro : dovrà essere indicato se è stata colpita o meno una nave

(coordinate di tiro corrispondenti ad una posizione con una ‘N’) e visualizzazione del

messaggio ‘COLPITO’ o ‘ ACQUA’. Se una nave è colpita su deve decrementare il numero

totali delle navi rimaste.

… si continua ad effettuare spari finchè vi sono ancora navi

… colpite tutte le navi, si stampa la matrice con l’esito dei tiri ed il numero dei tiri

effettuati.

ESERCIZIO



ESERCIZIO

main

inizializza riempicampo spara esitotiro stampamat

114





#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define MAXPERC 35

#define DIM 26

void inizializza(char batna[][DIM],int DI, int *riem, int MAXPER, int *percent, int *nnavi);

void riempicampo(char Mat1[][DIM],int riemp, int nnavi);

void spara(int *ri, int *col, int riem);

void esitosparo(char batna[][DIM], int rig, int col, char *ris, int *nav);

void stampamat(char Mat1[][DIM], int riemp);

Il programma C



#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define MAXPERC 35

#define DIM 26

void inizializza(char batna[][DIM],int DI, int *riem, int MAXPER, int *percent, int *nnavi);

void riempicampo(char Mat1[][DIM],int riemp, int nnavi);

void spara(int *ri, int *col, int riem);

void esitosparo(char batna[][DIM], int rig, int col, char *ris, int *nav);

void stampamat(char Mat1[][DIM], int riemp);

Il programma C

115





main ()

{char batnav[DIM][DIM], esitotiro;

int riga, colonna, riemp, percento, navi, tiri=0;

inizializza(batnav, DIM, &riemp, MAXPERC, &percento, &navi);

riempicampo(batnav, riemp, navi);

do

{ spara(&riga, &colonna, riemp);

esitosparo(batnav, riga, colonna, &esitotiro, &navi);

switch (esitotiro)

{ case 'C': printf("**** COLPITA ****\n"); break;

case 'P': printf(" nave GIA COLPITA PRIMA \n"); break;

case 'A': printf(" --- ACQUA ---\n");

}

tiri++;

} while (navi>0) ;

printf(" Colpite tutte le navi con %d tiri\n", tiri);

stampamat(batnav, riemp);

}

Il programma C



void inizializza(char batna[][DIM], int DI, int *riem,int MAXPER, int *percent, int *nnavi)

{

do

{

printf("Immetti dimensione campo battaglia (max %d) \n", DIM);

scanf("%d", &(*riem));

} while ((*riem<=0) || (*riem>DI));

do

{ printf("Immetti densità percentuale bersagli (max %d %) \n", MAXPERC);

scanf("%d", &(*percent));

} while ((*percent<=0) || (*percent>MAXPER);

*nnavi=(((*riem)*(*riem))*(*percent))/100;

printf("Saranno inserite %d navi \n", *nnavi);

}

Il programma C

116





void riempicampo(char Mat1[][DIM], int riemp, int nnavi)

{int I, J, k;

srand(time(NULL)); // inizializza il seed di rand() in modo da generare

// valori diversi ad ogni esecuzione

//Imbianca campo

for (I=0;(I< riemp); I++)

for (J=0;J<riemp;J++)

Mat1[I][J]=' ';

// riempe campo

for (k=0;k<nnavi;k++)

{do

{ I=rand()%riemp;

J=rand()%riemp; }

while (Mat1[I][J]=='N');

Mat1[I][J]= 'N';

}

}

Il programma C



void spara(int *ri, int *col, int riem)

{

printf("\n immissione coordinate tiro ");

do

{printf("\n - immettere riga: ");

scanf("%d", &(*ri));

}

while((*ri<=0)||(*ri>=riem));

do

{ printf("\n - immettere colonna: ");

scanf("%d", &(*col));

}

while ((*col<=0)||(*col>=riem));

}

Il programma C

117





void esitosparo(char batna[][DIM], int rig, int col, char *ris, int *nav)

{

if (batna[rig][col] == 'N')

{*ris='C';

batna[rig][col] = 'C';

*nav=*nav-1;

}

else

{if (batna[rig][col] == 'C') *ris='P';

else

{ *ris='A';

batna[rig][col] = 'A';

}

}

printf("navi = %d\n", *nav);

}

Il programma C



void stampamat(char Mat1[][DIM], int riemp)

{int a, b;

for (a=0;a< riemp; a++)

{printf("\n");

for (b=0;b<riemp;b++)

printf("%c - ", Mat1[a][b]);

}

}

Il programma C

118






Dato un array monodimensionale A di di interi, di 40 elementi, scrivere,

producendo la necessaria documentazione, un programma che, dato un

array monodimensionale A di interi, di 40 elementi permette di:

• Effettuare il riempimento, tramite input da tastiera, dello intero array

con valori tutti pari;

• Calcolare la media dei valori inseriti nello array e contare il numero

degli elementi con valore inferiore o pari a quello della media e degli

elementi con valore superiore a quello della media;

• Costruire un nuovo array monodimensionale B, di 40 elementi, in cui

ciascun elemento in posizione ‘i’ ha il valore uguale alla sommatoria

degli elementi di A fino alla posizione ‘i’;

• Salva lo array B in un file sequenziale.

Esercizio




I: il valore di ciascun elemento dello array A.

Pi: elementi di A devono essere numeri pari.

U: media dei valori in A; numero di elementi di A con valore inferiore o

uguale alla media; numero di elementi di A con valore superiore alla media; array monodimensionale B; il file sequenziale ("fileVET.txt“) in cui

è salvato lo array B.

Pu: il valore dell’elemento di B in posizione ‘i’ ha il valore uguale alla

sommatoria degli elementi di A fino alla posizione ‘i’

119






A[i] Elemento Array monodimensionale int



containf numero di elementi di A con valore inferiore o uguale alla media INT

contasup numero di elementi di A con valore superiore alla media INT

media media dei valori degli elementi in A FLOAT

B Array il cui elemento in posizione i ha il valore uguale alla

sommatoria degli elementi di A fino alla posizione ‘i’

INT

*FVET Puntatore al file sequenziale "fileVET.txt“ in cui è salvato lo

array B

FILE



somma sommatoria di elementi di A INT

i, j Indice di controllo di ciclo INT





Si azzerano i valori delle variabili somma, containf, contasup.

Si riempie, con un ciclo ‘for’, completamente lo array A verificando che si immettano

solonumeri pari, l’immissione è ripetuta, con un ciclo ‘do ... while’, finché non è immesso

non è immesso un valore valido.

Man mano che si immettono i valori validi di A[i] si incrementa il valore di somma del

valore valido immesso e si assegna il valore di somma all’elemento B[i].

Alla uscita dal ciclo ‘for’ per il riempimento di A, si calcola la media dei valori immessi

dividendo il valore di somma per la cardinalità di A, facendo la conversione di tipo da intero

a reale.

Con un nuovo ciclo ‘for’ si calcolano i valori di containf, contasup , confrontando ciascun

elemento di A con il valore della media: se A[i] è inferiore o uguale alla media si incrementa

di 1 il valore di containf, altrimenti quello di contasup .

Si stampano i valori di containf e contasup ottenuti e lo array B.

Si salva lo array B sul file sequenziale ‘fileVET.txt’

120





#include<stdio.h>

main()

{const int card=40;

int i, somma, containf, contasup;

int A[card], B[card];

float media;

FILE*FVET;

somma=0; containf=0; contasup=0;

for(i=0;i<card;i++)

{do

{printf(" dammi elemento A[%d] \n", i);

scanf("\n%d", &A[i]);

}

while((A[i]%2!=0));

somma=somma+A[i];

B[i]=somma;

}

for(i=0;i<card;i++)

printf(" B[%d]= %d \n", i, B[i]);



media=(float)somma/(float)card;

for(i=0;i<card;i++)

if (A[i]<=media) containf++;

else contasup++;

printf("Media dei valori di A = %f\n", media);

printf

("Numero elementi con valore inferiore o pari alla media = %d\n", containf);

printf

("Numero elementi con valore superiore alla media = %d\n", contasup);

// Salva B su un file sequenziale

FVET=fopen("fileVET.txt","w"); //apre file VET.txt in scrittura

if (FVET == NULL)


else

{ for (i=0;i<card;i++) // scrive i valori di B nel file

fprintf(FVET,"%d\n", B[i]);

}

fclose(FVET);

}

121






Scrivere, producendo la necessaria documentazione, un programma che,

dato un array bidimensionale MAT di interi, di 10 righe e 15 colonne:

• Consente il riempimento, tramite input da tastiera, dello array in

modo che i valori siano compresi in (-47 , 52) estremi inclusi;

• Calcoli quanti elementi di MAT sono multipli di 3 , 7 , -11;

• Calcoli quanti sono i valori negativi e quanti i positivi in MAT

• Calcoli la media dei valori multipli di 7;

• Salva lo array MAT in un file sequenziale.

LO STUDENTE SVILUPPI IL PROGRAMMA

Esercizio

Hardware e Software - unisannio.it · 2014-12-28 · minimo e della posizione in cui esso si trova...

Documents

Transcript of Hardware e Software - unisannio.it · 2014-12-28 · minimo e della posizione in cui esso si trova...