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
Nome variabile Descrizione Tipo
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
Nome variabile Descrizione Tipo
I Indice array INT
Tabella delle variabili di algoritmo
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 3
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 5
// 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);
}
Esempio - il programma C
// 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);
}
Esempio - il programma C
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 7
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.
Definizione dei dati del problema:
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
Nome variabile Descrizione Tipo riemp riempimento INT VET(I) elemento dell’array INT
Nome variabile Descrizione Tipo MIN Elemento con il valore del minimo INT POS Posizione dove è contenuto MIN INT
Tabella delle variabili di ingresso
Tabella delle variabili di uscita
Nome variabile Descrizione Tipo
I Indice array INT
Tabella delle variabili di algoritmo
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 9
Esempio
Descrizione del metodo di elaborazione:
è 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]);
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 11
// 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 - il programma C
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 13
Esempio
Nome variabile Descrizione Tipo riemp riempimento INT VET(I) elemento dell’array INT
VAL valore da cercare nell’array INT
Nome variabile Descrizione Tipo TROVATO Indica se esiste un elemento pari a VAL LOGICAL POS Posizione dove è contenuto VAL INT
Tabella delle variabili di ingresso
Tabella delle variabili di uscita
Nome variabile Descrizione Tipo
I indice array INT
Tabella delle variabili di algoritmo
Esempio
Descrizione del metodo di elaborazione:
è 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’.
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 15
#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);
Esempio - il programma C
// 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);
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 17
// Cerca se il valore immesso esiste nello array (ricerca lineare) 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
printf(“il valore indicato %d non esiste nello array\n”, VAL);
}
… un’altra soluzione …
// Cerca se il valore immesso esiste nello array (ricerca lineare) 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
printf(“il valore indicato %d non esiste nello array\n”, VAL);
}
… ancora un’altra soluzione …
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 19
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
Nome variabile Descrizione Tipo riemp riempimento INT VET(I) elemento dell’array INT
VAL valore da cercare nell’array INT
Nome variabile Descrizione Tipo NumOccorrenze Numero occorrenze pari a VAL INT
I Indice posizione elemento uguale a VAL INT Tabella delle variabili di ingresso
Tabella delle variabili di uscita
Nome variabile Descrizione Tipo
I indice array INT
Tabella delle variabili di algoritmo
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 21
Esempio
Descrizione del metodo di elaborazione:
è 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()
{ const int cardinalita=50;
int VET[cardinalita], I, riemp,VAL, NumOccorrenze = 0;
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);
Esempio - il programma C
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 23
// Conta le occorrenze di VAL (ricerca lineare)
for (I= 0; I< riemp; I++)
{ if (VET[I] == VAL) { 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];
…..
for (I= 0; I< riemp; I++) { if (VET[I] == VAL)
{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]);
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 25
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 27
/* 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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 29
// 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]);
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 31
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 ordinareTabella delle variabili di ingresso
Nome variabile Descrizione Tipo
VET Array da ordinato INT
Tabella delle variabili di uscita
Ordinamento di array: per selezione
Nome variabile Descrizione Tipo riemp riempimento INT VET(I) elemento dell’array INT
Nome variabile Descrizione Tipo
I indice array INT
???
Tabella delle variabili di algoritmo
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 33
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
Ordinamento di array: per selezione
9 5 8 2 4
222 5 8 9 4
In blu parte già ordinata In rosso minimo parte NON ancora ordinata
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 35
Tabella delle variabili di ingresso
Nome variabile Descrizione Tipo
VET Array da ordinato INT
Tabella delle variabili di uscita
Ordinamento di array: per selezione
Nome variabile Descrizione Tipo riemp riempimento INT VET(I) elemento dell’array 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
Tabella delle variabili di algoritmo
Il programma in C
Ordinamento di array:
per selezione
#include<stdio.h>
main()
{ const int cardinalita=50;
int VET[cardinalita], I, riemp, J, POS, temp, MIN;
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]);
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 37
// 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
Ordinamento di array:
per selezione
... swapping ...
temp= VET[I];
VET[I]= VET[POS];
VET[POS]=temp;
Il programma in C
Ordinamento di array:
per selezione Lo swapping
9 5 8 2 4 9
temp
2 5 8 9 4
temp
9
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 39
... swapping ...
ATTENZIONE A NON FARE:
VET[I]= VET[POS];
VET[POS]=VET[I];
E’ ERRATO !!!
Il programma in C
Ordinamento di array:
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
Ordinamento di array:
per selezione
… un’altra soluzione …
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 41
Ordinamento di array: per selezione
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 52 14
52 52
28 10 3 31 40 33 57 93 52 52 14
Definizione del problema: Si vogliono aggiungere uno o più elementi in un array monodimensionale di interi già parzialmente riempito e
visualizzare lo array risultante.
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 43
Aggiunta di elementi in un array non ordinato
Riemp = 10 Card = 12 14
14 14 52
52 52
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
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 52 14
52 52
28 10 3 31 40 33 57 93 52 52 14
Definizione del problema: Si vogliono aggiungere uno o più elementi in un array monodimensionale di interi già parzialmente riempito e
visualizzare lo array risultante.
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 45
Aggiunta di elementi in un array non ordinato
Definizione dei dati:
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
Tabella delle variabili di ingresso
Nome variabile Descrizione Tipo Tabella delle variabili di uscita
Nome variabile Descrizione Tipo riemp riempimento INT
.... ... ... ... ...
Nome variabile Descrizione Tipo
Tabella delle variabili di algoritmo
Aggiunta di elementi in un array non ordinato
... LO STUDENTE COMPLETI LE TABELLE ....
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 47
Descrizione del metodo di elaborazione:
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
Aggiunta di elementi in un array non ordinato: il programma C
#include<stdio.h>
main()
{ const int cardinalita=50;
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));
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 49
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
Definizione dei dati:
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)
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 51
14
Riemp = 9 Card = 12 3 10 14 28 31 33 40 57 93
14 14
14 52
3 10 14 28 31 33 40 52 57 93
Riemp = 10 Card = 12 52
52 52
Aggiunta di elementi in un array ordinato
Card = 12 3 10 28 31 33 40 57 93
Riemp = 8
VET
Aggiunta di elementi in un array ordinato
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 53
Aggiunta di elementi in un array ordinato 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];
Aggiunta di elementi in un array ordinato 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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 55
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
Tabella delle variabili di ingresso
Nome variabile Descrizione Tipo Tabella delle variabili di uscita
Nome variabile Descrizione Tipo riemp riempimento INT
.... ... ... ... ...
Nome variabile Descrizione Tipo
Tabella delle variabili di algoritmo
Aggiunta di elementi in un array non ordinato
... LO STUDENTE COMPLETI LE TABELLE ....
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 57
Descrizione del metodo di elaborazione:
• 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
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
………
// 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));
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 59
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 }
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()
{ const int cardinalita=50;
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);
// 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));
il programma C con sottoprogrammi
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 61
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 63
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
Definizione dei dati:
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
Descrizione del metodo di elaborazione:
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 65
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 33 3 10 28 31 33
3 10 28 31 33 40 57 93 98
Inf = 6 Sup = 9
Posizione elemento centrale:
P=(Sup+Inf)/2=8
93
3 10 28 31 33 3 10 28 31 33
3 10 28 31 33 40 57 40 57 40 57 93 98
Inf = 8 Sup = 9
93
Posizione elemento centrale:
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 67
// 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) {
...
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 69
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
Definizione dei dati del problema:
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’.
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 71
Esempio
Nome Variabile Descrizione Tipo
VET[i] Elemento Array
monodimensionale
char
Nome Variabile Descrizione Tipo
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
Nome Variabile Descrizione Tipo
riemp riempimento dello
array VET
INT
i, j Indice di controllo di ciclo
INT
Tabella delle variabili di algoritmo:
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 73
Esempio
Descrizione del metodo di elaborazione:
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]);
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 75
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]);
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 77
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
Definizione dei dati del problema:
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
Nome variabile Descrizione Tipo
MAT array bidimensionale di interi INT MAT(I,J) elemento dell’array INT
Nome variabile Descrizione Tipo
MAT array di interi con i valori immessi INT Tabella delle variabili di ingresso
Tabella delle variabili di uscita
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 79
Esempio - Array Bidimensionale Descrizione del metodo di elaborazione:
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.
Esempio - il programma C
#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]);
}
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 81
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 83
#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
Definizione del problema:
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
Descrizione del metodo di elaborazione:
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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 85
Esempio
Nome variabile Descrizione Tipo MAT array bidimensionale di interi INT MAT(I,J) elemento dell’array INT
Tabella delle variabili di ingresso
Nome variabile Descrizione Tipo MAX Elemento con il valore del massimo INT RIGA Riga dove è contenuto MAX INT COL Colonna dove è contenuto MAX INT Tabella delle variabili di uscita
#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
for (I=0; I<cardriga; I++) for (J=0; J<cardcol; J++)
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];
for (I=0; I<cardriga; I++) for (J=0; J<cardcol; J++) { 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
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 87
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.
Definizione dei dati del problema:
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
Nome variabile Descrizione Tipo MAT array bidimensionale di interi INT MAT(I,J) elemento dell’array INT
VAL valore da cercare nell’array INT
Tabella delle variabili di ingresso
Nome variabile Descrizione Tipo TROVATO Indica se esiste un elemento pari a VAL LOGICAL I, J Posizione dove è contenuto VAL INT Tabella delle variabili di uscita
Elementi di Informatica
Prof. G. A. Di Lucca - Univ. del Sannio 89
Esempio
Descrizione del metodo di elaborazione:
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);
// Immissione valore da cercare
printf(“Immetti il valore da cercare\n”);
scanf("%d", &VAL);