Gli array. impone al programma, in fase di esecuzione, di riservare dello spazio in memoria per 10 variabili di tipo int

Transcript

1 Gli array Gli array rappresentano una modalità molto compatta per accedere ad un gruppo di variabili; tale gruppo è identificato dal nome dell'array; i tipi delle variabili appartenenti al gruppo devono essere tutti uguali. All'intero della memoria del calcolatore, ciascuna variabile occupa una ben definita posizione; le variabili che compongono l'array sono disposte una vicino all'altra. la dichiarazione int vettore[10]; impone al programma, in fase di esecuzione, di riservare dello spazio in memoria per 10 variabili di tipo int Ad ogni elemento del gruppo si accede conoscendo: il nome dell'array la posizione occupata da tale elemento all'interno del gruppo il secondo elemento dell'array, cui corrisponde l'indice 1, viene individuato scrivendo: vettore[1] indice: valore:

2 Gli array: ordinamento con diversi criteri Scriviamo un programma basato sulla seguente traccia: dichiarare un array di variabili di tipo char; la dimensione dell'array deve essere fissata utilizzando la direttiva per il preprocessore #define inizializzare l'array assegnando a ciascun elemento un valore casuale di tipo intero compreso tra 65 e 122 (in termini di codice ASCII, questo corrisponde alle minuscole, maiuscole e ad alcuni altri caratteri compresi tra questi due gruppi). Implementare questa funzionalità definendo un'opportuna funzione. visualizzare i valori contenuti negli elementi dell'array (usando %c come specificatore di formato) controllare se ci sono valori compresi tra 91 e 96, estremi inclusi; se ci sono valori che soddisfano a questa condizione, il loro valore deve essere diminuito di 8 (questa operazione corrisponde all'eliminazione di tutti i caratteri che non sono lettere minuscole o maiuscole). Implementare questa funzionalità definendo un'opportuna funzione. codice ASCII carattere... X Y Z [ \ ] ^ _ ` a b visualizzare i valori contenuti negli elementi dell'array (usando %c come specificatore di formato) contare quante lettere di un determinato valore siano presenti nel gruppo (ovvero quante 'A' siano presenti, quante 'B', etc. etc.) disporre in ordine crescente i valori contenuti nell'array (questo corrisponde ad ordinare le lettere in ordine alfabetico, prima le maiuscole e poi le minuscole) visualizzare i valori contenuti negli elementi dell'array (usando %c come specificatore di formato) applicare all'array il seguente criterio di ordinamento: una lettera maiuscola non deve essere seguita da una minuscola... qual è l'effetto di questo criterio di ordinamento? 10. visualizzare i valori contenuti negli elementi dell'array (usando %c come specificatore di formato)

3 Passo 1: quali sono le direttive del preprocessore da utilizzare? quali i loro parametri? per visualizzare dei valori -> printf() -> #include stdio.h per poter generare numeri casuali -> rand() -> #include stdlib.h per distinguere le lettere maiuscole dalle minuscole -> #include ctype.h per poter definire una macro e assegnare una dimensione all'array -> #define SIZE 60 Passo 2: debbono essere implementate funzioni? quale deve essere il loro prototipo? 1. Una funzione deve generare numeri casuali compresi tra 65 e 122. Per preparare una funzione riutilizzabile anche in futuro si può scegliere il seguente prototipo: char RandChar(char min,char max); ove min e max rappresentano il minimo ed il massimo valore da generare La funzione dovrà restituire un valore compreso tra min e max, estremi inclusi. 2. La seconda funzione deve analizzare un carattere e scegliere se modificarlo o meno. Tale modifica deve essere "resa nota" al programma che richiama lafunzione; un modo per implementare questa funzionalità consiste nel far restituire alla funzione il valore del carattere (sia nel caso in cui esso venga modificato che nel caso in cui esso non venga modificato). char ScegliChar(char car); La funzione deve restituire un valore pari a quello di car, se car non risulta compreso tra 91 e 96, mentre deve restituire un valore pari a quello di car diminuito di 8 unità, se car è compreso tra 91 e 96, estremi inclusi. Passo 3: di che variabili ho bisogno per la preparazione del programma?

4 a. array di char b. un indice, ovvero una variabile di tipo int (per scorrere l'array) c. d. e. una variabile temporanea, dello stesso tipo delle variabili presenti nell'array (per poter effettuare gli scambi connessi con l'applicazione di un criterio di ordinamento) una seconda variabile di tipo intero (per poter determinare quando terminare l'applicazione del criterio di ordinamento) devo contare quante volte ciascuna lettera minuscola o maiuscola è presente nel gruppo; ho bisogno quindi di due array di interi, ciascuno dei quali mi permetta di memorizzare quante volte ogni lettera compaia nell'array di char int NumMinuscole[26]; int NumMaiuscole[26]; perché 26? NumMinuscole[0] indicherà quante siano le occorrenze della lettera 'a' NumMinuscole[1] indicherà quante siano le occorrenze della lettera 'b'... NumMaiuscole[0] indicherà quante siano le occorrenze della lettera 'A' NumMaiuscole[1] indicherà quante siano le occorrenze della lettera 'B' Come faccio a contare quante volte compare la 'f', ad esempio, senza usare il costrutto if-else e senza utilizzare il costrutto switch()? Se la 'f' è presente, devo incrementare il valore dell'elemento dell'array NumMinuscole che corrisponde alla lettera 'f'; la 'f' è la sesta lettera dell'alfabeto, quindi le compete l'elemento con indice pari a 5, NumMinuscole[5]. Se inizio a contare dalla 'a', la "distanza" tra la 'f' e la 'a' è pari a 'f' - 'a' = 5... che, guarda caso, è l'indice che corrisponde alla lettera 'f'... iniziamo a scrivere... /* inizio codice */ #include <stdio.h>

5 #include <stdlib.h> #include <ctype.h> #define SIZE 60 /* inseriamo qui i prototipi delle funzioni essi devono essere letti dal compilatore PRIMA che le funzioni stesse vengano utilizzate */ char RandChar(char,char); char ScegliChar(char); int main() {char vettore[size]; int NumMinuscole[26]; int NumMaiuscole[26]; char temp; int i,scambio; /* inizializzo gli array che serviranno per il conteggio delle lettere */ for( i = 0 ; i < 26; i++ ) {NumMinuscole[i] = 0; NumMaiuscole[i] = 0; /* l'array di caratteri viene inizializzato e si visualizzano i valori in esso contenuti */ putchar('\n'); for( i = 0 ; i < SIZE ; i++ ) {vettore[i]=randchar(65,122); printf("%c", vettore[i] ); /* viene effettuato il controllo sull'array */ putchar('\n'); for( i = 0 ; i < SIZE ; i++ ) {vettore[i]=sceglichar(vettore[i]); printf("\n Nella posizione %d è presente il valore %c", i, vettore[i] ); /* i caratteri vengono riconosciuti e contati; essi vanno prima suddivisi tra minuscole */ for( i = 0 ; i < SIZE ; i++ ) {if(islower(vettore[i])) { NumMinuscole[ vettore[i]-'a' ]++; if(isupper(vettore[i])) { NumMaiuscole[ vettore[i]-'a' ]++; /* visualizzo le occorrenze di ciascun carattere */ putchar('\n');

6 for( i = 0 ; i < 26; i++ ) {printf("\n Nell'array %c compare %d volte",'a'+i, NumMinuscole[i]); printf("\n Nell'array %c compare %d volte",'a'+i, NumMaiuscole[i]); /* gli elementi dell'array vengono disposti in ordine crescente */ scambio = 1; while(scambio) { scambio = 0; for( i=0 ; i < ( SIZE - 1 ) ; i++) {if( vettore[i] > vettore[i+1] ) /*se non sono in ordine crescente, scambio i valori */ {temp = vettore[i]; vettore[i] = vettore[i+1]; vettore[i+1] = temp; scambio = 1; /* visualizzo i valori contenuti nell'array dopo l'ordinamento */ putchar('\n'); for( i = 0 ; i < SIZE ; i++ ) {printf("%c", vettore[i] ); /* applico il secondo criterio di ordinamento */ scambio = 1; while(scambio) { scambio = 0; for( i=0 ; i < ( SIZE - 1 ) ; i++) {/*se non soddisfano il criterio, scambio i valori */ if( isupper(vettore[i]) && islower(vettore[i+1]) ) {temp = vettore[i]; vettore[i] = vettore[i+1]; vettore[i+1] = temp; scambio = 1; /* visualizzo i valori contenuti nell'array dopo l'ordinamento */ putchar('\n'); for( i = 0 ; i < SIZE ; i++ ) {printf("%c", vettore[i] ); return 0;

7 /* inseriamo ora le implementazioni delle funzioni */ char RandChar(char min,char max) {char CarCasuale; CarCasuale = min + rand() % (max - min + 1) ; /* perché +1?*/ return CarCasuale; /*... una versione un po' più sintetica... char RandChar(char min,char max) {return ( min + rand() % (max - min + 1) ) ; */ char ScegliChar(char valore) {if( (valore >= 91) && (valore <= 96) ) {valore -= 8; return valore; /*... un'altra versione... char ScegliChar(char valore) {if( (valore >= 91) && (valore <= 96) ) {return (valore - 8); return valore;? Perché non serve l' else? */ /* fine codice */ Nell'ipotesi in cui l'eseguibile si chiami ordering, ecco l'output. /home/studente>./ordering jxmu^guksovpxhl\funk\oqfc]viybvchwns`zjct`czjydxhy\ein\jxxfy Nella posizione 0 è presente il valore j Nella posizione 1 è presente il valore X Nella posizione 2 è presente il valore M Nella posizione 3 è presente il valore u Nella posizione 4 è presente il valore V Nella posizione 5 è presente il valore G Nella posizione 6 è presente il valore u Nella posizione 7 è presente il valore K Nella posizione 8 è presente il valore s Nella posizione 9 è presente il valore o Nella posizione 10 è presente il valore V

8 Nella posizione 11 è presente il valore P Nella posizione 12 è presente il valore X Nella posizione 13 è presente il valore H Nella posizione 14 è presente il valore l Nella posizione 15 è presente il valore T Nella posizione 16 è presente il valore f Nella posizione 17 è presente il valore u Nella posizione 18 è presente il valore N Nella posizione 19 è presente il valore k Nella posizione 20 è presente il valore T Nella posizione 21 è presente il valore o Nella posizione 22 è presente il valore Q Nella posizione 23 è presente il valore f Nella posizione 24 è presente il valore C Nella posizione 25 è presente il valore U Nella posizione 26 è presente il valore V Nella posizione 27 è presente il valore i Nella posizione 28 è presente il valore y Nella posizione 29 è presente il valore B Nella posizione 30 è presente il valore v Nella posizione 31 è presente il valore c Nella posizione 32 è presente il valore h Nella posizione 33 è presente il valore w Nella posizione 34 è presente il valore N Nella posizione 35 è presente il valore S Nella posizione 36 è presente il valore X Nella posizione 37 è presente il valore Z Nella posizione 38 è presente il valore j Nella posizione 39 è presente il valore c Nella posizione 40 è presente il valore t Nella posizione 41 è presente il valore X Nella posizione 42 è presente il valore C Nella posizione 43 è presente il valore z Nella posizione 44 è presente il valore j Nella posizione 45 è presente il valore Y Nella posizione 46 è presente il valore D Nella posizione 47 è presente il valore x Nella posizione 48 è presente il valore H Nella posizione 49 è presente il valore Y Nella posizione 50 è presente il valore T Nella posizione 51 è presente il valore e Nella posizione 52 è presente il valore I Nella posizione 53 è presente il valore n Nella posizione 54 è presente il valore T Nella posizione 55 è presente il valore j Nella posizione 56 è presente il valore X Nella posizione 57 è presente il valore x Nella posizione 58 è presente il valore f Nella posizione 59 è presente il valore Y Nell'array a compare 0 volte Nell'array A compare 0 volte Nell'array b compare 0 volte Nell'array B compare 1 volte Nell'array c compare 2 volte Nell'array C compare 2 volte Nell'array d compare 0 volte

9 Nell'array D compare 1 volte Nell'array e compare 1 volte Nell'array E compare 0 volte Nell'array f compare 3 volte Nell'array F compare 0 volte Nell'array g compare 0 volte Nell'array G compare 1 volte Nell'array h compare 1 volte Nell'array H compare 2 volte Nell'array i compare 1 volte Nell'array I compare 1 volte Nell'array j compare 4 volte Nell'array J compare 0 volte Nell'array k compare 1 volte Nell'array K compare 1 volte Nell'array l compare 1 volte Nell'array L compare 0 volte Nell'array m compare 0 volte Nell'array M compare 1 volte Nell'array n compare 1 volte Nell'array N compare 2 volte Nell'array o compare 2 volte Nell'array O compare 0 volte Nell'array p compare 0 volte Nell'array P compare 1 volte Nell'array q compare 0 volte Nell'array Q compare 1 volte Nell'array r compare 0 volte Nell'array R compare 0 volte Nell'array s compare 1 volte Nell'array S compare 1 volte Nell'array t compare 1 volte Nell'array T compare 4 volte Nell'array u compare 3 volte Nell'array U compare 1 volte Nell'array v compare 1 volte Nell'array V compare 3 volte Nell'array w compare 1 volte Nell'array W compare 0 volte Nell'array x compare 2 volte Nell'array X compare 5 volte Nell'array y compare 1 volte Nell'array Y compare 3 volte Nell'array z compare 1 volte Nell'array Z compare 1 volte BCCDGHHIKMNNPQSTTTTUVVVXXXXXYYYZccefffhijjjjklnoostuuuvwxxyz ccefffhijjjjklnoostuuuvwxxyzbccdghhikmnnpqsttttuvvvxxxxxyyyz /home/studente>

10 Esercizi proposti: 1. Verificare che rand() è un buon generatore di numeri casuali. A questo scopo, utilizzare la funzione che genera numeri casuali tra un valore massimo ed uno minimo e farle generare valori casuali compresi tra 97 e 122 (lettere minuscole) per un numero molto elevato di volte (ad esempio alcuni miliardi). Man mano che la funzione genera caratteri, contare quante 'a', quante 'b',... etc., vengano generate usando la procedura presentata sopra. se rand() è un buon generatore di numeri casuali, quanto deve valere il rapporto tra il numero di volte in cui è comparsa la 'a' ed il numero di volte in cui è comparsa, ad esempio, la 'k'? Per generare le lettere, supponendo che i sia una variabile di tipo intero, implementare un costrutto ciclico di questo tipo: for( i=1 ; i>0 ; i++ ) {... istruzioni... E' possibile effettuare quanto richiesto o si tratta di un ciclo infinito? 2. L'ultimo ordinamento applicato all'array vettore considerato durante l'esempio impone alle lettere maiuscole di posizionarsi alla fine dell'array ed alle minuscole di raggrupparsi all'inizio dell'array stesso. Utilizzando lo stesso criterio di ordinamento e le funzioni tolower() e toupper(), è possibile fare in modo che le lettere minuscole si spostino alla fine dell'array e le maiuscole vadano all'inizio dell'array stesso?