hardware e software - università degli studi del sannio ... · 3 elementi di informatica a.a....

1

Elementi di Informatica a.a. 2019/20 - 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, e dopo calcolare la sommatoria degli

elementi di indice dispari (l’indice 0 è considerato pari) e la produttoria

degli elementi con valore 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, la produttoria degli elementi con valore pari

Pu: lo array non può essere ‘vuoto’; la produttoria deve essere un numero

pari



Esempio

Nome variabile Descrizione Tipo

VET(I) elemento dell’array INT


VET array di interi con i valori immessi INT

SommaIndicidispari sommatoria elementi indice dispari INT

ProduttoriaPari produttoria elementi con valore pari 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

Si Inizializza a zero il valore della sommatoria dei valori nelle posizioni di

indice dispari, ed a uno la produttoria degli elementi con valore pari.

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.

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

incremento pari a 1 si visitano gli elementi dello array si verifica se il valore

dell’elemento è pari ed in tal caso lo si moltiplica al valore corrente della

produttoria. . Si stampa il risultato ottenuto.



#include< stdio. h>

main()

{const int CARD=50;//costante con nome con valore 50

int Vett[CARD], i, SommaIndicidispari,

ProduttoriaPari;

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

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

{

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

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

}

// Stampa tutti gli elementi dello array


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

Esempio - il programma C

3





// calcola la sommatoria degli elementi di indice dispari

SommaIndicidispari=0;

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

SommaIndicidispari= SommaIndicidispari + Vett[i];

printf(“Sommatoria valori elementi in posti di

indice dispari=% d\n", SommaIndicidispari);




// calcola la produttoria degli elementi con valore pari

Produttoriapari = 1;


{ if (Vett[i]%2 == 0)

Produttoriapari= Produttoriapari * Vett[i];

}

printf(“Produttoria elementi con valore pari = %d\n”,

Produttoriapari);

} // fine programma


4





// calcola la sommatoria degli elementi di indice dispari

// un altro modo ma meno efficiente

Sommadispari=0;

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

{if ((i%2)!=0) // verifica se il valore di è

// un numero dispari

Sommadispari= Sommadispari+Vett[i];

}

printf(“Sommatoria valori elementi in posti di

indice dispari=% d\ n", Sommadispari);




Esempio

Analisi e Specifica

Definizione del problema: ....

.... Calcolare la produttoria degli elementi con valore multiplo di 5.


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; produttoria elementi con valore

multiplo di cinque

Pu: lo array non può essere ‘vuoto’

5





…

float Produttoria_5;

…

// calcola la produttoria degli elementi di valore multiplo 5

Produttoria_5 = 1;

for (i= 1; i< CARD; i++)

{if (Vett[i] % 5 == 0)

Produttoria_5 = Produttoria_5 * Vett[i];

}

printf(“Produttoria valori multipli di 5 = %f\ n",

Produttoria_5);

} // fine programma




Esempio

Definizione del problema: Trovare il valore minimo e quello massimo 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/massimo va indicata la

posizione solo del primo elemento ‘minimo’/’massimo’). 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, il valore massimo nello array; la posizione dell’elemento con

valore massimo

Pu: la posizione del minimo/massimo non maggiore del riempimento

6





Esempio


riemp riempimento INT



MIN Elemento con il valore minimo INT

POSMIN Posizione dove è contenuto MIN INT

MAX Elemento con il valore massimi INT

POSMAX Posizione dove è contenuto MAX INT




I Indice array INT




Esempio Descrizione del metodo di elaborazione:

... Usando sottoprogrammi ...

È chiamato il sottoprogramma leggivett(int Vet1[], int card1, int *riemp1), per riempire

parzialmente lo array.

È chiamato il sottoprogramma stampavet(int Vet1[ ],int riemp1) , per visualizzare i valori

immessi nello array

È chiamato il sottoprogramma

trovaMax_Min(int Vet1[], int *F_MAX, int *F_MIN, int *PS_MAX, int *PS_MIN, int

riemp1);

per trovare i valori minimo e massimo contenuti nello array.

Nel sottoprogramma trovaMax_Min si pone il minimo pari al primo elemento dell’array e la

sua posizione pari all’indice zero. Analogamente si pone il massimo pari al primo elemento

dell’array e la sua posizione pari all’indice zero.

Usando un ciclo, si ‘visita’ lo array verificando:

se ciascun 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

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

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

Nel main si stampano i valori del minimo e del massimo e le posizioni in cui essi si trovano

associati ai paramentri scambiati per riferimento ritornati dal sottoprogramma

7





#include<stdio.h>

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

void trovaMax_Min(int Vet1[], int *F_MAX, int *F_MIN,

int *PS_MAX, int *PS_MIN, int riemp1);

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

main()

{ const int cardinalita=50;

int VET[cardinalita], I, riemp, MIN, POSMIN, MAX, POSMAX;

leggivett (VET, cardinalita, &riemp);

stampavet (VET, riemp);

trovaMax_Min (VET, &MAX, &MIN, &POSMAX, &POSMIN, riemp);

printf("il valore minimo = %d si trova nella posizione di

indice %d\n" , MIN, POSMIN);

printf("il valore massimo = %d si trova nella posizione

di indice %d\n" , MAX, POSMAX);

system("Pause");

}


Con sottoprogrammi



void leggivett(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]);

}

}

Esempio - il programma C con sottoprogrammi

void stampavet(int Vet1[ ],int riemp1)

{ int I; ;

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

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

}

8





void trovaMax_Min(int Vet1[], int *F_MAX, int *F_MIN,

int *PS_MAX, int *PS_MIN, int riemp1)

{int I;

*F_MIN = Vet1[0]; *PS_MIN=0;

*F_MAX = Vet1[0]; *PS_MAX=0;

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

{ if (Vet1[I]<*F_MIN)

{ *F_MIN=Vet1[I];

*PS_MIN=I;

}

else

if (Vet1[I]>*F_MAX)

{ *F_MAX=Vet1[I];

*PS_MAX=I;

}

}

}


Con sottoprogrammi



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; riempimento

Pi: riempimento 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

9





Esempio




VAL valore da cercare nell’array INT


TROVATO Indica se esiste un elemento pari a VAL BOOL

POS Posizione dove è contenuto VAL INT




I indice array INT




Esempio

Descrizione del metodo di elaborazione:

è immesso il numero di quanti elementi si vogliono inserire: se immesso un

valore maggiore della cardinalità dello array deve essere richiesta

l’iimmissione di un valore valido

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

Si immette il valore che si vuole cercare nello array.

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

viene visualizzata la posizione del primo elemento che lo contiene ed il ciclo

termina appena lo si trova;

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

array’.

10





#include<stdio.h>

main()

{const int cardinalita=50;

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

int trovato;

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]);

}

// Immissione valore da cercare

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

scanf (“%d”, &VAL);




… usando un sottoprogramma per riempire lo array …

#include<stdio.h>

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

/* per il codice di leggivett vedere la procedure dell’

esercizio svolto per trovare I valori MAX e Min in un array */

main()


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

int trovato;

leggivett(VET, cardinalita, &riemp);





11





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

POS=0; trovato=0; // trovato = falso

I=0;

do

{ if (VET[I] == VAL)

{trovato = 1; // valore trovato in array

POS=I;}

I++;

}

while ( (trovato == 0) && ( 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);

}



// Cerca se valore immesso esiste in array (ricerca lineare)

POS=0; trovato=0; // trovato = falso

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


array\n”, VAL);

}

… un’altra soluzione …

12





// Cerca se valore immesso esiste in array (ricerca lineare)

trovato=0;

I=0;

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

{trovato = (VET[I]==VAL);//assegna a trovato il risultato

//del confronto (0 se falso)

I++;

}

if (trovato != 0)

printf(‘il valore immesso %d in posizione %d\n”,

VAL, (I-1));

else


array\n”, VAL);

}

… ancora un’altra soluzione …



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

13





Esempio






NumOccorrenze Numero occorrenze pari a VAL INT

I Indice posizione elemento uguale a 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 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.

14





#include<stdio.h>

main()


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

do

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





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


}







// Conta le occorrenze di VAL (ricerca lineare)



{NumOccorrenze++;

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

}

}

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

NumOccorrenze);

}

15





VAL = 23

5

28

23

47

25

VET

0

1

2

3

4

5

…...

49

6

23

riemp = 6

NumOccorrenze = 2

valore 23 trovato 2 volte

nelle posizioni:

posizione = 2

posizione = 5

posizione

0

1

2

3

4

5

…...

49

6

2

5

... Una differente soluzione : usando un array in cui memorizzare le posizioni



... Una differente soluzione // Conta le occorrenze di VAL (ricerca lineare)

// usando un array in cui memorizzare le posizioni

int posizione[cardinalita];

… …



{posizione[NumOccorrenze]=I;

NumOccorrenze++;

}

}

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

NumOccorrenze);

printf (“valore trovato nelle posizioni:\n”);

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

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

}

16





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



Ordinamento di un array monodimensionale

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

17







VET Array ordinato INT


Ordinamento di array: per selezione




Nome variabile Descrizione Tipo I indice array INT

???




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.

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

18





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


In blu parte già ordinata

In rosso minimo della

parte NON ancora

ordinata

9

5

8

2

4

222

5

8

9

4





VET Array 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


19





Il programma in C

Ordinamento di array:

per selezione

#include<stdio.h>

main()


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

do

{ printf (“quanti elementi vuoi inserire? (Max=%d)\n”, cardinalita);





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


}





.......

• Usando un ciclo si visita completamente lo array T[] e ad ogni passo del

ciclo:

• Si trova il valore minimo T[p] della parte NON ancora ordinata dello array e

si scambia il valore di T[p] con quello in prima posizione di tale parte NON

ancora ordinata (inizialmente la parte non ancora ordinata coincide con

l’intero array)

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

20





// 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;


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; ...

9

5

8

2

4

temp= VET[0];

temp

2

5

8

2

4

9

VET[0]= VET[3];

VET[3]=temp;

21





... swapping ...

ATTENZIONE A NON FARE:

VET[I]= VET[POS];

VET[POS]=VET[I];

E’ ERRATO !!!


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

!!??



#include <stdio.h>

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

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

void swap(int *a, int *b);

void ordina_vet_selezione(int Vet1[],int riemp1);

Il programma in C strutturato con sottoprogrammi Ordinamento di array: per selezione

main()

{const int card=20;

int vet[card], i, j,riemp, temp, min, pos;

leggivet_riemp(vet, card, &riemp);

printf("Array immesso:\n");

stampavet(vet, riemp);

ordina_vet_selezione(vet, riemp);

printf("\n \n Array Ordinato:\n");

stampavet(vet, riemp);

}

22





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

{int I;

do

{printf("quanti elementi vuoi inserire (MAX %d)?\n", card1);


}



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


}

}

void stampavet(int Vet1[], int riemp1)

{ int I; ;

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

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

}



void swap(int *a, int *b)

{int temp;

temp=*a;

*a=*b;

*b=temp;

}

void ordina_vet_selezione(int Vet1[],int riemp1)

{int i, j, min, pos, temp;

min=Vet1[0];pos=0;

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

{min=Vet1[i]; pos=i;

for (j=i+1; j<riemp1; j++)

{ if (Vet1[j]<min)

{ min=Vet1[j];

pos=j;

}

}

swap(&Vet1[i], &Vet1[pos]);

}

23





Ordinamento di array

… una variante …

... si confronta (nella parte non ancora ordinata) un elemento dello array con tutti i

successivi e si effettua lo swap se questo è minore dell’elemento in esame ...




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


... si confronta un

elemento dello array

con tutti i successivi e

si effettua lo swap se

questo è minore

dell’elemento in

esame ...

24





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


... si confronta un elemento dello

array con tutti i successivi e si

effettua lo swap se questo è

minore dell’elemento in esame ...




void ordina_vet(int Vet1[],int riemp1)

{int I, J, temp;

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

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

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

swap(&Vet1[J], &Vet1[I]);

}

}

}


... il sottoprogramma per l’ordinamento con scambi successivi...

25





Algoritmo

In un ciclo iterativo:

Si confrontano coppie di elementi consecutivi dello array e si scambiano di posizione se essi

non sono nel giusto ordine (ossia, caso ordinamento crescente, se il secondo elemento è

minore del primo).

Dopo la prima iterazione il valore massimo si troverà nella ultima posizione (quella sua

definitiva); dopo la seconda iterazione il secondo massimo si troverà in penultima posizione

e così via.

Ad ogni iterazione almeno un elemento va a collocarsi nella sua giusta posizione definitiva.

Il ciclo iterativo termina quando non sono più effettuati scambi.

… bubble sort…



9

5

8

2

4

5

9

8

2

4

5

8

9

2

4

5

8

2

9

4

5

8

2

4

9

5

8

2

4

9

5

8

2

4

9

5

2

8

4

9

5

2

4

8

9

5

2

4

8

9

2

5

4

8

9

2

4

5

8

9

2

4

5

8

9

2

4

5

8

9

bubble sort Scambio ? Si

Scambio ? Si

Scambio ? Si Scambio ? NO

Iterazione 1 Iterazione 2

Iterazione 3 Iterazione 4

26





void bubblesort(int vet1[ ], int riemp1)

{int i, scambio = 1;

while (scambio == 1)

{ scambio = 0;

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

{ if (vet1[i] > vet1[i+1])

{ swap(&vet1[i], &vet1[i+1]);

scambio = 1;

}

}

riemp1--;

}

}

… bubble sort… ... il sottoprogramma per l’ordinamento ...



Definizione del problema: Si vuole verificare se in un array i cui valori

sono ordinati in senso crescente esiste un elemento con un dato valore e se

esso esiste si vuole conoscere la sua posizione. Si vuole usare un algoritmo

di ricerca binaria.

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

27






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 è uguale 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 (quella tra il primo elemento e

quello in posizione centrale), 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 (quella tra l’elemento in

posizione centrale e l’ultimo), 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 Ricerca binaria



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

28





#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



// 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”);

}

29





#include <stdio.h>

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

{ int I;

do

{printf("immetti riemp\n");


}



{printf("immetti Vet[ %d ]= \n",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)

{//uno dei sottoprogrammi di ordinamento visti

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

}



Definizione del problema:

Scrivere, producendo la necessaria documentazione, un programma in

linguaggio C che, data una stringa di 130 caratteri:

• consente di riempire la stringa leggendone il valore da tastiera;

• cancella tutti i caratteri che sono cifre compattando, ad ogni

cancellazione, la stringa (lo array che la contiene) e stampa la stringa

risultante.

Esempio

30





Cancellazione di un elemento in un array e compattazione

a S P 3 k B 8 E V \0

riemp = 9

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

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

riemp--;

a S P k B 8 E V \0

riemp = 8

a S P k B E V \0

riemp = 7

pos = 4

pos = 6



Esempio


LO STUDENTE DEFINISCA I DATI, IL DIZIONARIO DATI E

L’ALGORITMO E QUINDI SCRIVA IL PROGRAMMA

STRUTTURANDOLO CON SOTTOPROGRAMMI

I: ....

Pi: .....

U: .....

Pu: .....

31






.... LO STUDENTE DEFINISCA L’ALGORITMO DA USARE .....




Cancellare tutte le cifre compattando, ad ogni cancellazione, la stringa (lo array che la

contiene) e stampa la stringa risultante:

Trovata una cifra, si traslano tutti gli elementi successivi a questa di una posizione verso la

testa dello array.

32





Cancellazione di un elemento in un array e compattazione

a S P 3 k B 8 E V \0

riemp = 9

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

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

riemp--;

a S P k B 8 E V \0

riemp = 8

a S P k B E V \0

riemp = 7

pos = 4

pos = 6



Esempio

#include<stdio.h>

/*Legge una linea in input */

void LeggiLinea(char ln[], int max, int *riemp)

{int i = 0; char c;

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

{ ln[i] = c;

i++;

}

ln[i] = '\0';

*riemp=i;

}

33





main ( )

{int const card = 131;

char VET[card], c;

int i, j, riemp;

printf("Immetti una stringa \n");

LeggiLinea(VET, card, &riemp);

i=0;

printf("Lunghezza della stringa: %d\n\n", riemp);

printf("\nStringa Immessa:\n");

while (VET[i]!='\0')

{ printf("%c", VET[i]);

i++;

}

printf("\n\n");



// Si cercano le cifre in VET e le si cancellano

// compattando lo array

i=0;


{if ((VET[i]>='0') && (VET[i]<= '9'))

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

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

riemp--;

// Aggiorna posizione fine stringa

VET[riemp]='\0';

}

else i++;

}

34





//Stampa stringa compattata senza le cifre

printf("\n Stringa compattata senza le cifre: \n");

if(riemp>0)

{i=0;

while(VET[i]!= '\0')

{printf ("%c",VET[i]);

i++;}

}

else printf("stringa vuota\n");

system("Pause");

}



…… modo alternativo per la stampa …

//Stampa stringa compattata senza le cifre


if(riemp>0)

puts(VET);

else

printf("stringa vuota\n");

system("Pause");

}

35





… altra soluzione per compattare, usando un ciclo iterativo … e per la stampa …

//Ricerca le cifre in VET le cancella e compatta lo array

i=0;


{if ((VET[i]>='0') && (VET[i]<= '9'))

{ j=i;

while (VET[j]!='\0')

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

j++;

}

riemp--;

}

else i++;

}


if(VET[0]!='\0') puts(VET);

else printf("stringa vuota\n");

system("Pause");

}



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.

36






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


37







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 ....

38






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));

39





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


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)

40





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

41






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

42





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 ....

43






• 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 crescente 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 è falsa (o quando sono stati esaminati

tutti i Riemp elementi dello array): il valore di I per cui la condizione è falsa è 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

int vet[cardinalita], …………. ;

// codice per immissione di riemp elementi nell’array

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

………


if(cardinalita>riemp)

{ do






44





// immissione nuovi valori

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

{ 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;

} // fine for immissione nuovi valori

} // fine ramo vero if (cardinalita>riemp)

else

printf(“array pieno!! Impossibile aggiungere valori!!\n);

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

printf("%d\n", vet[i]); // Stampa array

system(“Pause”);

}

45





Aggiunta di elementi in un array ordinato #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);


if(cardinalita>riemp)

{ do






il programma C strutturato

con sottoprogrammi



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 nuovo elemento

VET[pos]= el_da_inserire;

} // fine for immissione nuovi valori

} // fine ramo vero if (cardinalita>riemp)

else printf(“array pieno!! Impossibile aggiungere valori!!\n);

stampavet(Vet, riemp);

System(“Pause”);

}

46





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

{ int I;

do

{printf("immetti riemp\n");


}



{printf("immetti Vet[ %d ]= \n",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



Esempio



linguaggio C che, data 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’), ‘filtrando’ ogni altro carattere;

• 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.

47





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; la

stringa compattata

Pu: Nella stringa (array) non ci sono vocali ‘o’.



Esempio

Nome Variabile Descrizione Tipo

VET[i] Elemento dello 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:

48





Esempio


riemp riempimento dello array VET INT

i, j Indice di controllo di ciclo INT

Tabella delle variabili di algoritmo:




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

Si stampa la stringa di sole vocali immessa

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 è uguale alla vocale ‘o’ si cancella la ‘o’ e si compatta VET :

con un ciclo ripetitivo, di indice j iniziante dalla posizione dove si trova la ‘o’ e

terminante al penultimo elemento di VET, usando l’istruzione VET[j]=VET[j+1];

alla fine del ciclo ripetitivo si decrementa di 1 il riempimento di VET e si aggiorna

la posizione di fine stringa ponendo VET[riemp]=‘\0’;

(dopo la compattazione si riprende la visita di VET dalla stessa posizione in cui si

è trovata la ‘o’.)

Altrimenti si passa all’elemento successivo di VET

Si stampa la stinga (lo array VET) compattata, senza le ‘o’.

49





Esempio

#include<stdio.h>

//Legge in input una stringa formata da sole vocali

void LeggiLinea(char ln[], int max, int *riemp)

{int i = 0; char c;

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

{if((c=='a')||(c=='e')||(c=='i')||(c=='o')||(c=='u'))

{ln[i] = c;

i++;

}

}

ln[i] = '\0';

*riemp=i;

}



Esempio

main ( )

{int const card=31;

char VET[card];

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

printf("Immettere solo vocali minuscole\n");

LeggiLinea(VET, card, &riemp);

50





Esempio

// Stampa stringa con sole vocali immessa

i=0;

printf("Lunghezza della stringa: %d\n\n", riemp);

printf("\nStringa Immessa di sole vocali:\n");


{ printf("%c", VET[i]);

i++;

}

printf("\n\n");



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

contaA=0; contaE=0; contaI=0; contaO=0; contaU=0;

i=0;

//Conteggio occorrenze di ciascuna vocale


{ switch (VET[i])

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

case 'e': contaE++; break;

case 'i': contaI++; break;

case 'o': contaO++; break;

case 'u': contaU++; break;

}

i++;

}

51





Esempio

// stampa occorrenze di ciascuna vocale

printf("Vocale a presente %d volte \n", contaA);

printf("Vocale e presente %d volte \n", contaE);

printf("Vocale i presente %d volte \n", contaI);

printf("Vocale o presente %d volte \n", contaO);

printf("Vocale u presente %d volte \n", contaU);



Esempio

// ricerca delle 'o' e compattazione dello array

i=0;


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

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

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

riemp--;

// Aggiorna posizione fine stringa

VET[riemp]='\0';

}

else i++;

}

52





Esempio //Stampa stringa compattata senza le 'o'

printf("\n Stringa compattata senza le o: \n");

if(riemp>0)

{i=0;

while(VET[i]!='\0')

{printf ("%c",VET[i]);

i++;}

}

else


printf("\n\n");

system("Pause");

}



Esempio

// Stampa stringa compattata senza le 'o'

// usando un ciclo ripetitivo

if(riemp>0)

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

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

}

Else


system("Pause");

}

53






Trovare il valore massimo ed il valore minimo tra gli elementi di un array

bidimensionale, di 5 righe e 7 colonne, ed indicarne la posizione (riga e

colonna). Riempire lo array con valori generati in modo random (se i valori

massimo e minimo sono presenti più volte nello array, indicare solo le

posizioni della prima volta che essi sono trovati).

Definizione della specifica del programma:

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

Pi: nessuna

U: il valore e la posizione dell’elemento con valore massimo e con

valore minimo

Pu: nessuna



Esempio


MAT array bidimensionale di interi INT

MAT(I,J) elemento dell’array INT



MAX Elemento con il valore del massimo INT

RIGAMAX Riga dove è contenuto MAX INT

COLMAX Colonna dove è contenuto MAX INT

MIN Elemento con il valore del minimo INT

RIGAMIN Riga dove è contenuto MIN INT

COLMIN Colonna dove è contenuto MIN INT


54






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

Si pone il massimo/minimo pari al primo elemento dell’array (elemento

posto nella prima riga e prima colonna).

Si effettua una visita completa (scandendola per riga e colonne) della

matrice:

si verifica se ciascun altro elemento dell’array è superiore al

massimo/(inferiore al minimo) fissato, in tal caso si aggiorna il valore

del massimo/minimo e della posizione in cui esso si trova nella matrice



#include <stdio.h>

#include <stdlib.h>

#include<time.h>

main ()

{ // Trova Max_e Min in_array_bidimensionale;

const cardriga=5, cardcol=7;

int MAT[cardriga] [cardcol], I, J, MAX, MIN, RIGAMAX, COLMAX,

RIGAMIN, COLMIN;

// Riempimento array in modo random

srand(time(0));

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

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

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

Esempio - il programma

55





// Stampa array



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




// Cerca il valore massimo e minimo nello array bidimensionale

RIGAMAX=0; COLMAX=0; MAX = MAT[0][0];

RIGAMIN=0; COLMIN=0; MIN = MAT[0][0];



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

{ MAX=MAT[I][J];

RIGAMAX=I; COLMAX=J;

}

else

if (MAT[I][J]<MIN)

{ MIN=MAT[I][J];

RIGAMIN=I; COLMIN=J;

}

}

56





// Stampa il risultato

printf (“massimo = %d in riga %d e colonna %d \n", MAX, RIGAMAX,

COLMAX);

printf (“il minimo= %d in riga %d e colonna %d \n", MIN, RIGAMIN,

COLMIN);

}



Array e sottoprogrammi in C

• In C, nell’attivazione di un sottoprogramma lo scambio di parametri

(effettivi – formali) di tipo array è sempre effettuato per riferimento

• Nel caso di array monodimensionali per il parametro formale non va

indicata la cardinalità dello array

• Nel caso di array bidimensionali va indicata per il paramentro formale

la cardinalità della seconda dimensione dello array

• Nel caso di array multi-dimensionali vanno indicate per il paramentro

formale tutte le cardinalità eccetto quella della prima dimensione dello

array

57





Array e sottoprogrammi in C Es.

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

main ()

{ const card=10;

int Vet[card],I;

leggivet(Vet,card); }

Es.

void leggimat(int Mat1[][4],int cardr, int cardc)

main ()

{ const cardr=2; const cardc=4;

int Mat[cardr][cardc],I,J;

leggimat(Mat,cardr,cardc);}

Array monodimensionale: non è

necessario indicare la cardinalità

nel parametro formale

Array bi-dimensionale:

deve essere indicata la

cardinalità della seconda

dimensione nel relativo

parametro formale




Es.

void leggimat(int Mat1[][4],int cardr, int cardc)

main ()

{ const cardr=2; const cardc=4;

int Mat[cardr][cardc],I,J;

leggimat(Mat,cardr,cardc);}

… quando il numero di colonne è diverso da quello indicato

(nell’esempio è 4), il sottoprogramma deve essere modificato e

ricompilato … !!

… qualche considerazione …

58






#include <stdio.h>

#define COL 5 // crea un nome (un simbolo) associato al valore costante

// indicato. Nel programma le occorrenze del simbolo sono

// automaticamente sostituite dal valore ad esso associato

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

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

main ()

{ const cardc=COL; const cardr=7;

int Mat[cardr][cardc];

leggimat (Mat,cardr,cardc);

stampamat (Mat,cardr,cardc);

printf("\n");

}

… una possibile soluzione




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]);

}

}


59






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

{ int I,J;

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

{ printf("\n");

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

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

}

}




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

positivi, 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. Usare sottoprogrammi per il riempimento e la stampa

dello array.


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; il valore di ciascun elemento dello array

deve essere > 0

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 non

possono essere maggiore delle rispettive cardinalità di riga/colonna

60





Esempio


MAT array bidimensionale di interi INT

MAT(I,J) elemento dell’array INT




TROVATO Indica se esiste un elemento pari a VAL LOGICAL

I, J Posizione dove è contenuto VAL INT




Esempio


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

assegnare a ciascun elemento dello array, controllando che il valore sia

maggiore di zero e ripetendo l’immissione se ciò non è verificato.

Si stampa il contenuto dello array così riempito

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”.

61





#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);




// Cerca se il valore immesso esiste nello array

(ricerca lineare)

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


array\n”, VAL);

} // fine main

62





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

{int I, J;

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


{ do

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

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

}

while (Mat1[I][J] <= 0);

}

}



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

{int I,J;

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


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

}

63





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



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

64





Esempio


MAT prima matrice di interi INT

MAT(I,J) elemento della prima matrice INT


MATTR Matricetrasposta di MAT INT





Esempio


Si legge, in ordine di riga, il valore di ciascun elemento dello array.

Si calcola il valore di ciascun elemento della matrice trasposta

ponendo: MATTR(I,J)=MAT(J,I).

Si stampa la matrice trasposta risultante.

65





Esempio - il programma #include<stdio.h>

#define col 5

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

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++)

{

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

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

}



// Visualizzazione valori elementi matrice MAT

printf(“\n\n *** MATRICE MAT ***\n\n”);

stampamat( MAT, card, card);

// Calcola matrice trasposta


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

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

// Visualizzazione valori elementi matrice trasposta

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

stampamat(MATTR, card, card);

system("Pause");

}

66





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(" %d - ", Mat1[I][J]);

printf("\n");

}

}



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.

67





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++)

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

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


}

// 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]);

}

68






// Calcola matrice trasposta

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

for (j= 0; j< cardR; j++) // a 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]);

}

}



Esercizio Definizione del problema:

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 zero.

Pu: nessuna

69





0

1

2

3

4

0 1 2 3 4

23 47 63 96 8

27 66 23 44 567

47

...

23

... 15

63 MAT 96 8

0

1

2

3

4

0 1 2 3 4

23 47 63 96 8

27 66

0

…

0

... 15

0 MAT

23 44 567

0 0

27 66 23 44 567

0 0 0 0 0



Esempio Tabella delle variabili di Ingresso:


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

70





Esempio Tabella delle variabili di algoritmo:


i Indice di controllo di ciclo INT

j Indice di controllo di ciclo INT

k Indice di controllo di ciclo INT

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

71





Esempio

… STRUTTURAZIONE IN SOTTOPROGRAMMI …

main

legggiRIEMP stampaMAT leggiMAT

doppioni



#include<stdio.h

#define COL 15

void legggiRIEMP (int *R, int maxcard);

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

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

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);

Esempio

72





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

void legggiRIEMP (int *R, int maxcard)

{do

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

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

}

while (*R>maxcard);

}



Esempio

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);

}

}

73





Esempio 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");

}

}



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) // verifica se riga già azzerata

{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) // se il conteggio è uguale al numero di colonne …

{ 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 elementi riga doppione

}

}

}

}

}

Esempio

74





Esempio



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).



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

75





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



Esempio





76





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 è.



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

void Leggivet(int vet[], int card)

{int i, j


{do

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

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

}

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

}

}

main()

{ const int cardA=15, cardB=25;

int i, j, contenuto, conta;

int A[cardA], B[cardB];

Leggivet(A, cardA);

Leggivet(B, cardB);

77





// 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);

}




// 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");

}

78






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 uguale 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à:

79







VET Array monodimensionale INT

Riemp Riempimento INT



VET Array di ingresso con elementi INT

doppioni tutti pari a zero

i Indici dei valori doppioni INT







80






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.




#include<stdio.h>

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);

81






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

{ // 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);

}



Esempio //Confronta ciascun elemento dello array dal primo al penultimo

// con quelli a lui 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 fino all’ultimo

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

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

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

VET[k]=0; // azzera valore ‘doppione’

}

}

}

82





Esempio

// Stampa array finale

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

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

system(“Pause”);

}



Esempio


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

determinare se essa è simmetrica rispetto alla diagonale principale.





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

83





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

Verificare se gli elementi in posizione (i, j) sono uguali a

quelli in posizione (j, i) … con i < > j



Esempio

4 10 22 82

10 11 24 52

22 24 24 45

82 52 45 53

Verificare se gli elementi in posizione (i, j) sono uguali a

quelli in posizione (j, i) … con i < > j

84





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






85






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

Elementi al di sopra della diagonale principale …

… data la riga i iniziano dalla colonna j = i + 1 …

86






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 (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!=0)&&(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!=0)&&(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");

}


87






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.





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




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

88










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.

89






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 …

90






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 …

91





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

longint fatt (int n)

{ long a;

if (n==0) a=1;

else

a= n * fat(n-1);

return a; }

…………..


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]); }

}}

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

indici\n", contafatt);

}

Esempio - il programma … una versione più elegante …

… con sottoprogramma ricorsivo …



Esempio


Scrivere, producendo la necessaria documentazione, un programma che,

dato un array bidimensionale MAT di caratteri, con 20 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 ‘-‘

92





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 ‘-‘.



Esempio


MAT[i][j] Elemento Array bidimensionale CHAR

Tabella delle variabili di Ingresso


sommaAst, sommaPiu,

sommaMeno

Numero di caratteri ‘*’, ‘+’,

‘-‘ in ciascuna riga di MAT INT

percAst, percPiu,

percMeno

Percentuale di caratteri

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

FLOAT

VET Array con caratteri

ordinati come richiesto

CHAR

Tabella delle variabili di Uscita

93





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



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.

94





Esempio #include<stdio.h>

main()

{const int cardR=20;

const int cardC=10;

int i, j, sommaAst, sommaPiu, sommaMeno;

int totAst, totPiu, totMeno, kAst, kPiu, kMeno;

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

float percMeno, percAst, percPiu;


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

{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]!='-'));

}



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", i,

sommaAst, sommaPiu, sommaMeno);

}

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

totPiu, totMeno);

95





Esempio

// calcola e stampa percentuali simboli

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 // posiziona i simboli nello array VET

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]);

}

96





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

// posiziona i simboli nello array VET

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

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

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

… … …



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

97





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

C(1,2)=(7*4)+(3*1)+(1*5) = 36 C(1,1)=(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

,,, *

C(2,1)=(2*3)+(6*2)+(4*6) = 42 C(2,2)=(2*4)+(6*1)+(4*5) = 34



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



98






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++)

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

{ 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]);

}



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]);

}

99





Esempio

Analisi e Specifica

Definizione del problema: Sviluppare un programma per il

gioco: ’chi resta con l’ultimo cerino in mano?’.

Regole del gioco:

•Ci sono 30 cerini e 2 giocatori.

•Ciascun giocatore, a turno, prende minimo 3 cerini e massimo 7 cerini.

•Perde il giocatore che prende l’ultimo cerino.



Esempio

Analisi e Specifica


I: gli identificativi di ciascun giocatore;

la quantità di cerini presi da un giocatore

Pi: la quantità di cerini presi da un giocatore deve essere

compresa tra 3 e 7, estremi inclusi

U: identificativo del giocatore che ha vinto

Pu: il vincitore è uno dei due giocatori

100





Esempio


presi N.ro cerini presi da un giocatore INT

Nome1 Identificativo del primo giocatore STRINGA

Nome2 Identificativo del secondo giocatore STRINGA




Esempio


Vince Identificativo del giocatore vincente STRINGA




TotCerini Numero Totale dei cerini in gioco INT

Gioca Identificativo del giocatore attuale STRINGA

101





Esempio Progettazione


1.È inizializzato a 30 il valore di TotCerini

2.Si immettono gli identificativi del primo e secondo giocatore (Nome1 e Nome2

rispettivamente)

3.Alla variabile Gioca è assegnato il valore di Nome1 (giocatore attuale)

4.Il giocatore attuale immette quanti cerini prende (ovvero si legge il valore della variabile

‘presi’); l’immissione di tale valore va ripetuta se è immesso un valore non compreso tra 3 e

7 o se si è immesso un valore maggiore dei cerini ancora in gioco

5.il valore di TotCerini è decrementato di’presi’

6.Se restano al più tre cerini (cioè 0< TotCerini <=3) il giocatore attuale ha vinto (Vince =

Gioca); se TotCerini==0 ha vinto l’altro giocatore (ovvero Vince = Nome2 se

Gioca==Nome1, o Vince = Nome1 se Gioca==Nome2);

7.Se TotCerini è maggiore di 3 tocca all’altro giocatore (cioè alla variabile Gioca è assegnato

il valore di Nome2, se Gioca==Nome1, o il valore di Nome1 se Gioca==Nome2)

8.Si ripetono le operazioni dal punto 4 fin quando restano più di tre cerini;

9.Si stampa il valore della variabile Vince.



#include <stdio.h>

#include <string.h>

main ()

{ // 30 cerini

char Nome1[10], Nome2[10], Vince[10], Gioca[10];

int presi, TotCerini;

printf ("Immetti identificativo primo giocatore\n");

gets(Nome1);

printf ("Immetti identificativo secondo giocatore\n");

gets(Nome2);

TotCerini=30;

strcpy(Gioca,Nome1);

printf(" Ci sono %d cerini\n", TotCerini);


102





do

{ do

{ printf ("Quanti cerini prende %s ?\n", Gioca);

scanf ("%d", &presi);

}

while ((presi<3) || (presi>7) || (presi>TotCerini));

printf("\n");

TotCerini = TotCerini - presi;

printf("Restano %d cerini\n", TotCerini);

if ((TotCerini > 0) && (TotCerini <= 3)) strcpy(Vince, Gioca);

else

if (strcmp(Gioca,Nome1)==0)

strcpy(Gioca, Nome2) ;

else strcpy(Gioca, Nome1);

if (TotCerini == 0) strcpy(Vince, Gioca);

}

while (TotCerini > 3);

printf ("Ha vinto %s \n", Vince);

system("Pause");

}



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

Definizione della specifica del programma:

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

103






….

si inizializza il campo definedone le dimensioni e la percentuale (massimo 35%) 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 si 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

104





#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);

LO STUDENTE COMPLETI L’ESERCIZIO

Il programma C



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

105





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



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

106





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



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

107





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

hardware e software - università degli studi del sannio ... · 3 elementi di informatica a.a....

Documents

Il Potenziamento di Marca e la Brand Experience · PDF file“Il Potenziamento di Marca e la Brand Experience” Alessandro De Nisco Università del Sannio Corso Marketing Strategico

Elementi di Reti di Calcolatori · 2020. 12. 21. · Dipartimento di Ingegneria –Università del Sannio - CdL Ingegneria Energetica – 21: –

Tesi di Laurea di Relatore Gianmarco Aversano Gaetano Continillo Correlatrice Correlatrice Katarzyna Bizon Katarzyna Bizon UNIVERSITÀ DEGLI STUDI DEL SANNIO

WWF Sannio...alimenta la centrale idroelettrica di San Mango sul Calore, dopo di che queste acque tornano ad immettersi nel fiume. Comune di Taurasi in collaborazione con WWF Sannio

L’architettura italiana e i terremoti: la situazione ... 1... · Campania Campania Sannio Abruzzo Sannio Stretto di Messina Sicilia Benevento Roma Veneto Sannio Messina Rossano

Seduta del Consiglio del Dipartimento di Management in ... · 4. Cristini Guido (Università di Parma) 5. Resciniti Riccardo (Università del Sannio) 6. Ugolini Marta Maria (Università

Comune di San Giorgio del Sannio (BN) · sannio lavori di bonifica e messa in sicurezza permanente ex discarica san giovanni 03-procedura negoziata previa pubblicazione del bando

UNIVERSITA’ DEL SANNIO CORSO DI FISICA 1 ESERCIZI ...stefaniapetracca.weebly.com/uploads/1/3/3/8/13387498/05...UNIVERSITA’ DEL SANNIO CORSO DI FISICA 1 ESERCIZI – DINAMICA I

Corrado Aaron Visaggio 1 Algebra e Calcolo Relazionale Università degli Studi del Sannio Facoltà di Ingegneria Corso di Laurea in Ingegneria Informatica

Prof. Nicola Fontana Università degli Studi del Sannio Dipartimento di Ingegneria

in GIURISPRUDENZA · Università degli Studi del Sannio. CORSO DI LAUREA MAGISTRALE A CICLO UNICO in . GIURISPRUDENZA D.M. 22 ottobre 2004, n. 270. STRUTTURA DEL CORSO DI LAUREA E

1 MATHESIS Società Italiana di Scienze Matematiche e Fisiche Sezione di Lanciano-Ortona 24 febbraio 2010 Ferdinando Casolaro - Università del Sannio [email protected]

Università degli Studi del Sannio Centro Linguistico di Ateneo C.L.A.U.S. CORSO DI FORMAZIONE E AGGIORNAMENTO PER LA DIDATTICA DELLA LINGUA STRANIERA

ELENCO SOCI IGI - itaca.org · Prof. Fabio AMATUCCI Università degli Studi del Sannio Offerta anomala Avv. Francesco ROTA Università degli Studi del Sannio Recesso, risoluzione

TRASPORTI Appunti di - Università del Sannio - …old.ing.unisannio.it/ding/ricerca2/gruppi/ingciv/gallo/...Mariano Gallo Appunti di Tecnica ed Economia dei Trasporti 5 Introduzione

Napoli, 5 e 6 dicembre 2018 - scuolacivica.it · Fabio Amatucci, Professore di Economia Aziendale, Università degli Studi del Sannio, Ricercatore CERGAS Università Bocconi e Docente

Corso di una giornata in Reti di sensori Reti di... · 11:15 Prof. Giorgio Ventre (Università di Napoli “Federico II”) Protocolli di comunicazione ... (Università del Sannio)

Soluzioni innovative MultifunzionAli peR Ttimizzazione dei … · 2018. 12. 14. · PER RICERCA APPLICATA INNOVATIVA O DI DIMOSTRAZIONE Università degli Studi del Sannio – Dipartimento

Goal 3 Activity 9 (Workflow) links with A9 (Selflets), 7, 10, 11 Eugenio Zimeo Università del Sannio

Marisa Pecce - Università del Sannio - Facoltà di …old.ing.unisannio.it/ding/ricerca/gruppi/ingciv/pecce...27 ottobre 2009 Marisa Pecce Professore Ordinario di Tecnica delle Costruzioni

COMUNICARE IL TERRITORIO Lucia DAmbrosi SEA Facoltà di Scienze economiche e aziendali Università del Sannio

VIIIForum - fiaso.it · Fabio Amatucci, CERGAS Bocconi e Università del Sannio Lorenzo Giovanni Mantovani , Università degli Studi Milano Bicocca Paolo Francesco Maria Saccà ,

CORSO DI PROGRAMMAZIONE I - Dipartimento … 3.pdf23/11/2018 1 UNIVERSITÀ DEGLI STUDI DEL SANNIO Benevento DING DIPARTIMENTO DI INGEGNERIA Prof. Franco FRATTOLILLO Dipartimento di

UNIVERSITÀ DEGLI STUDI DEL SANNIO Facoltà di Ingegneria CdiL in Ingegneria Informatica Tesi di Laurea in Ingegneria del Software MODEL-DRIVEN DEVELOPMENT

· Università degli Studi del Sannio Sicurezza nei luoghi di lavoro Attestato di Frequenza al corso di 60 ore Corso di Formazione sulla Sicurezza nei luoghi di lavori

Concetto di ElaborazioneElementi di Informatica a.a. 2020/21 - Prof. G.A. Di Lucca Dipartimento di Ingegneria Università del Sannio CdL Ingegneria Energetica 1 66 Elementi di Informatica

PARETI DIPINTE - museoarcheologiconapoli.it · Chiara Germinario (Università del Sannio), Alberto De Bonis (Università di Napoli Federico II) Un banchetto per l’eternità. Nuove

Concetto di Elaborazione - unisannio.it · Elementi di Informatica a.a. 2015/16 - Prof. G.A. Di Lucca Dipartimentodi Ingegneria Università del Sannio - CdL Ingegneria Energetica

Renato Civitillo Research fellow Dipartimento di Economia, Management e Metodi Quantitativi (DEMM) Università degli Studi del Sannio – Benevento (BN) [email protected]

Samex.it: Circuito di Credito Commerciale Molise/Sannio. Analisi di prefattibilità

Benevento 26/27 novembre 2012 · 2012-11-21 · Università Cattolica del Sacro Cuore di Milano ... Ordinario di lingua francese Università del Sannio e Direttore ... Prof.ssa Sabrina

Realizzazione di moduli applicativi per messaggistica e gestione preferenze nel «carpooling» Università degli Studi del Sannio Dipartimento di Ingegneria

UNIVERSITÀ DEGLI STUDI DEL SANNIO Facoltà di Ingegneria CdiL in Ingegneria Informatica

PIRAMIDE UNIVERSALE - siac.gdf.it · Cinque anni di Dieta Mediterranea UNESCO ... Professore di Storia economica e di Storia dell’impresa, Università degli Studi del Sannio intervengono

Rappresentanza di genere e organismi a tutela delle pari … · 2015. 6. 9. · uominiedonne, (…)”. Università del Sannio 7. Il Regolamento Generale di Ateneo