Sei sulla pagina 1di 105

Fondamenti di Informatica 2016-2017

Funzioni

Paola Mussida
Area Servizi ICT
Esercizio F_1 - Quadrato 2

Scrivere una funzione per il


calcolo del quadrato di un
intero.
La funzione riceve in ingresso
un intero e restituisce l’intero
corrispondente al quadrato.

Paola Mussida
Esercizio F_1 - Quadrato - funzione 3

... /*funzione che calcola il quadrato del valore di “in”*/


int squ(int in)  
{
 
 
 
}
 
main() /* Programma principale */
{
int x,y;
for(x = 0;x <= 7;x++)   {
y =

printf("Il quadrato di %d e’ %d\n", x, y);


}
for (x = 0;x <= 7;++x)
printf("Il quadrato di %d e’ %d\n", x,         );
}
Paola Mussida
Esercizio F_1 - Quadrato - esecuzione 4

Paola Mussida
Esercizio F_2 - Somma di due interi 5

Scrivere una funzione per


calcolare la somma di due
interi passati per valore.

Paola Mussida
Esercizio F_2 - Somma di due interi 6

int somma(int,int);         /* prototipo funzione somma  */


 
main() {
        int a=5, b=7, c=2, d=9, z;
 
        z=somma(a,b);
        printf("\nz = %d ",z);
        z=somma(a,b) * somma(c,d);
        printf("\nz = %d ",z);
        z=somma(a,somma(b,c));
        printf("\nz = %d ",z);
}
 
/* definizione della funzione somma */
int somma(int x, int y) {
 
 
 
}
Paola Mussida
Esercizio F_2 - Somma di due interi 7

Paola Mussida
Esercizio F_3 - Stampa * 8

Scrivere una funzione che


stampa un numero di
asterischi passato per valore.

Paola Mussida
Esercizio F_3 - Stampa * 9

Output:
 
1  ************* 13
2  *** 3
3  ********* 9
4  *********************** 23
5  *************** 15
...
20 ********* 9

Paola Mussida
Esercizio F_3 - Stampa * 10

#define MAX 20
 
void riga(int n); /*stampa una riga di <n> asterischi*/

void main() {
int n, i;
 
/* visualizza MAX righe */
for (i=0 ; i < MAX ; i++)       {
n=rand() % 50; /* generazione numero casuale */
 
riga(n);   /*visualizzazione riga di asterischi*/
 
printf(" %d", n); /* stampo n che non è variato*/
}
}
Paola Mussida
Esercizio F_3 - Stampa * 11

/* stampa una riga di <n> asterischi */


 
void riga (int n) {
 
       

}
Paola Mussida
Esercizio F_4 - Numero primo 12

Scrivere due funzioni per


verificare se un numero è
primo , utilizzando i
prototipi forniti; la prima
funzione chiama la seconda.

Paola Mussida
Esercizio F_4 - Numero primo 13

typedef enum {falso,vero} SiNo;


 /* prototipi delle funzioni */
SiNo primo (int);
   
SiNo divisibile (int,int);
 
void main() {
int numero=1;
 
while(numero!=0) { /* fino all'inserimento del numero 0 ... */
printf("\nInserisci numero:");
scanf("%d",&numero);
               
       
       
 

}
Paola Mussida
Esercizio F_4 - Numero primo 14

/* la funzione restituisce vero se il numero


passato come parametro è primo */
SiNo primo(int num) {

 
 
 
 
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_4 - Numero primo 15

/* ritorna vero se il primo parametro è divisibile per


il secondo */
SiNo divisibile (int num, int divisore) {
 
 
 
 
 
 
 
 
 

 
}
Paola Mussida
Esercizio F_5 - Interessi 16

Scrivere una funzione che


calcoli gli interessi maturati
su un capitale in N anni.

Paola Mussida
Esercizio F_5 - Interessi 17

typedef enum {FALSO, VERO} boolean;


float pot(float x, int exp) {   /* calcolo di x elevato a exp */

}
Paola Mussida
Esercizio F_5 - Interessi 18

void main() {
       float cap, interes, montante, maturato;
        int anni;
 
        /* inserimento dati */
        printf("\nCapitale: ");
        scanf("%f", &cap);
       printf("\nInteresse: ");
        scanf("%f", &interes);
       printf("\nAnni: ");
        scanf("%d", &anni);
 
       /* calcolo interessi */
        montante =
        maturato = montante - cap;
 
        /* visualizzazione interessi maturati */
        printf("\nMontante: %f", montante);
        printf("\nMaturato: %f", maturato);
 }
Paola Mussida
Esercizio F_6 - Maggiore di tre 19

Scrivere una funzione che


riceve tre parametri di tipo
puntatore a intero e
restituisce il puntatore del
parametro con valore
maggiore.

Paola Mussida
Esercizio F_6 - Maggiore di tre 20

int a, b, c;
int *magg;
/* restituisce l'indirizzo del parametro maggiore */
int *maggiore(int *x, int *y, int *z) {
       

Paola Mussida
Esercizio F_7 - Ordina 3 parametri 21

Scrivere una funzione che


scambia i contenuti dei tre
parametri ricevuti in modo
che il primo contenga il valore
maggiore.
La funzione restituisce inoltre
la somma dei tre valori.
Paola Mussida
Esercizio F_7 - Ordina 3 parametri 22

int a, b, c, *p;
char risp;
/* ordina i tre parametri e restituisce la loro somma*/

Paola Mussida
Esercizio F_7 - Ordina 3 parametri 23

Paola Mussida
Esercizio F_7 - Ordina 3 parametri - Altra versione 24

Paola Mussida
Esercizio F_8 - Esempi 25

Simulazione di chiamate a
funzioni.

Paola Mussida
Esercizio F_8 - Esempi 26

int varA = 100;


 
int proc1(int par) {
varA=varA+1;           
par = par - 10;
return (par);
}
 
int proc2(int *par) {
*par = *par - 10;      
return (*par);
}
 
int proc3(int par) {
int varA;
varA = par + 1;
return (varA);
}
Paola Mussida
Esercizio F_8 - Esempi 27

void main() {
int varB=0, varC=50;
 
/* situazione iniziale */
printf ("0) varA = %d, varB = %d, varC = %d ", varA, varB, varC);
 
varB = proc1(varC); /* passo 1 */
printf ("1) varA = %d, varB = %d, varC = %d ", varA, varB, varC);
      
varB = proc2(&varC); /* passo 2 */
printf ("2) varA = %d, varB = %d, varC = %d ", varA, varB, varC);
 
varB = proc3(varC); /* passo 3 */
printf ("3) varA = %d, varB = %d, varC = %d ", varA, varB, varC);
 
varC = proc1(varA); /* passo 4 */
printf ("4) varA = %d, varB = %d, varC = %d ", varA, varB, varC);
}

Paola Mussida
Esercizio F_8 - Esempi - Risultato 28

Paola Mussida
Esercizio F_9 - Esempi 29

Simulazione di chiamate a
funzioni.

Paola Mussida
Esercizio F_9 - Esempi 30

#include <stdio.h>
int varA = 100, varB, varC = 56;
 
int proc1(int par) {
        par = varA + par;
        return (par);
}
 
int proc2(int *par) {
        varB = *par;
        *par = *par - varC;
        return (*par);
}
 
int proc3(int *par) {
        int varA = 5;
        *par = varB;
        return (varA + varC);
}
Paola Mussida
Esercizio F_9 - Esempi 31

void main() {
 
int varB=0, varC=50;

/* situazione iniziale */
printf ("0) varA = %d, varB = %d, varC = %d \n", varA, varB, varC);
 
varB = proc1(varC); /* passo 1 */
printf ("1) varA = %d, varB = %d, varC = %d \n", varA, varB, varC);
      
varB = proc2(&varC); /* passo 2 */
printf ("2) varA = %d, varB = %d, varC = %d \n", varA, varB, varC);
      
varA = proc3(&varC); /* passo 3 */
printf ("3) varA = %d, varB = %d, varC = %d \n", varA, varB, varC);
 
varC = proc1(varA); /* passo 4 */
printf ("4) varA = %d, varB = %d, varC = %d \n", varA, varB, varC);
}

Paola Mussida
Esercizio F_9 - Esempi _ Esecuzione 32

varA varB varC

varB varC par par

main proc1 proc2

par varA par

proc3 proc1
Paola Mussida
Esercizio F_9 - Esempi _ Risultato 33

Paola Mussida
Esercizio F_10 - Prima occorrenza 34

Ricerca della prima occorrenza di un


elemento in un vettore tramite funzione.
Il vettore è globale.
In caso di esito positivo della ricerca,
nella cella relativa all’elemento trovato
bisogna inserire la differenza, in valore
assoluto, tra l’elemento precedente e
quello successivo ad esso, oppure 0 in
caso di errore.

Paola Mussida
Esercizio F_10 - Prima occorrenza 35

0 1 2 3 4 5 6 7 8 9
vettore 8 23 37 22 51 85 23 68 12 5

Inserisci il valore da ricercare: 22

Elemento presente nella posizione 3

Modifica: vettore[3]= 14
Paola Mussida
Esercizio F_10 - Prima occorrenza 36

#include <stdio.h>
#define MAX 10
#define NOT_FOUND -1
int vettore[MAX];               /* variabile array globale */
int ricerca(int ricercato); /*dichiarazione della funzione ricerca*/
int differenza(int prec, int succ);

Paola Mussida
Esercizio F_10 - Prima occorrenza 37

/*Definizione della funzione ricerca*/


int ricerca(int ricercato)
{
 
 
 
 
 

 
 
 
 
}
Paola Mussida
Esercizio F_10 - Prima occorrenza 38

/*Definizione della funzione differenza*/


int differenza (int prec, int succ)
{
 
 
 
 
 
 
 
 
 
 
 
 
}                                                    
                       
Paola         
Mussida
Esercizio F_11 - Cerca ripetizione 39

Scrivere un programma che verifichi


la ripetizione di un elemento in un
array definito globalmente sfruttando
una funzione che trova la prima
occorrenza dell’elemento “corrente”
nelle posizioni successive dell’array
se presente.

Paola Mussida
Esercizio F_11 - Cerca ripetizione 40

Paola Mussida
Esercizio F_11 - Cerca ripetizione 41

Paola Mussida
Esercizio F_11 - Cerca ripetizione 42

#include <stdio.h>
#define MAX 10
int vett[MAX];   /* variabile array globale */
/* Ricerca di un elemento in un vettore globale; restituisce
la posizione dove viene trovato l’elemento ricercato o –1 se
non lo trova.
Parametri:
numero: numero da ricercare nell’array
inizio: posizione iniziale dalla quale iniziare la ricerca*/

Paola Mussida
Esercizio F_11 - Cerca ripetizione 43

void main() {
int i, k;
printf("\nInserisci il vettore di Numeri :");
for ( i=0; i<MAX; i++ ) {
printf("\nInserisci il %d elemento: ",i);
scanf("%d",&vett[i]);
}
for (i=0; i<(MAX-1); i++) { /* verifica ripetizioni*/
   
           
if ( k > 0 )
printf("Gli elementi %d e %d coincidono",i,k);
}
}

Paola Mussida
Esercizio F_12 - Pari o Dispari 44

Scrivere un programma che, generato


un numero casuale, determini se esso
è pari oppure dispari e lo memorizzi
tramite un’apposita funzione in uno
di due array (array dei pari ed array
dei dispari).

Paola Mussida
Esercizio F_12 - Pari o Dispari 45

#include <stdio.h>
#define MAX 10 /* dimensione dei vettori */
/* inserisce il parametro numero nell'array vett in una cella
contenente -1, se esiste*/
int ins_num(int vett[], int numero) {
 
 
 
 
 
 
 
 

void init(int vett[]) { /* inizializza un vettore */


       
 
 
 
}
Paola Mussida
Esercizio F_12 - Pari o Dispari 46

Paola Mussida
Esercizio F_13 - Ordinamento per selezione 47

Ordinamento per selezione


tramite funzioni.

Paola Mussida
Esercizio F_13 - Ordinamento per selezione 48

/* Prototipi delle funzioni: */

/* ordina il vettore ricevuto come parametro */


void ordina(int vett[]);
 

/* scambia due interi; in questo esercizio i due interi


sono due elementi di un vettore */
void scambio(int *a, int *b)
 

/* trova l'elemento minore in un vettore partendo


    da una posizione specificata */
int minore( int vett[ ] ,int iniz )

Paola Mussida
Esercizio F_13 - Ordinamento per selezione 49

#define MAX 20
void main() {
int i, vett[MAX];
/* popolamento del vettore con numeri casuali */
srand(time(NULL));
printf("\nVettore Originale:");
for ( i=0; i<MAX; i++ ) {
vett[i]=rand() % 100;
printf("\nVett[%d] = %d",i,vett[i]);
}
ordina(vett); /* ordinamento del vettore */
printf("\n\nVettore Ordinato:");
/* stampa del vettore finale ordinato */
for( i=0; i<MAX; i++ )
printf("\nVett[%d] = %d",i,vett[i]);
}
Paola Mussida
Esercizio F_13 - Ordinamento per selezione 50

/* ordina il vettore ricevuto come parametro */


void ordina(int vett[]) {
 
 
 
 
 
 
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_13 - Ordinamento per selezione 51

/* scambia due interi; in questo esercizio i


due interi sono due elementi di un vettore */
 
void scambio(int *a, int *b) {
 
 
 
 
 
 

 
 
}

Paola Mussida
Esercizio F_13 - Ordinamento per selezione 52

/* trova l'elemento minore in un vettore partendo


    da una posizione specificata */
int minore( int vett[ ] ,int iniz ) {
 
 
 
 
 
 
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_14 - Confronto di vettori 53

Scrivere una funzione che riceva 2


array di interi e la loro lunghezza e
restituisca “1” se essi hanno lo stesso
contenuto.

Paola Mussida
Esercizio F_14 - Confronto di vettori 54

Paola Mussida
Esercizio F_14 - Confronto di vettori 55

#define MAX_DIM 50

/* funzione che riceve e confronta i due vettori restituisce 1 nel caso il


contenuto dei due vettori sia identico */
 

 
{
 
        int i;
        if ( lungh_a != lungh_b )
                return (0);
 
        for ( i=0; i<lungh_a; i++ )
                if ( vett_a[i] != vett_b[i] )
                        return (0);
 
        return (1);
}

Paola Mussida
Esercizio F_14 - Confronto di vettori 56

void main()
{
 
int A[MAX_DIM], B[MAX_DIM];
int cont_A=0, cont_B=0;
 
printf("\nInserisci il primo numero per A:");
scanf("%d", &A[cont_A]);

while (A[cont_A] != -1)


{
        cont_A++;
        printf("\nInserisci il prox numero per A:");
        scanf("%d", &A[cont_A]);
}

/*...*/
Paola Mussida
Esercizio F_14 - Confronto di vettori 57

/*...*/

printf("\nInserisci il primo numero per B:");


scanf("%d", &B[cont_B]);
while ( B[cont_B] != -1 ) {
        cont_B++;
        printf("\nInserisci il prox numero per B:");
        scanf("%d", &B[cont_B]);
}
 
if
        printf("\nI vettori contengono gli stessi dati!");
else
        printf("\nI vettori contengono dati diversi!");
}

Paola Mussida
Esercizio F_15 - Lunghezza stringa 58

Scrivere una funzione che


calcoli la lunghezza di
una stringa passata come
parametro , sfruttando
l’aritmetica dei puntatori.

Paola Mussida
Esercizio F_15 - Lunghezza stringa 59

#include <stdio.h>
#include <stdlib.h>
 
                 /* prototipo */
 
void main()
{
char stringa[100];
 
printf("\nInserire la str. da analizzare (senza spazi): ");
fflush(stdin);
scanf("%s", stringa);
 
printf("\nLa lungh. della str. e’ : %d",           );
printf("\nLa stringa originale e’ %s", stringa);

}
Paola Mussida
Esercizio F_15 - Lunghezza stringa 60

/* funzione per calcolare la lunghezza della stringa */

Paola Mussida
Esercizio F_16 - Percentuali di stringa 61

Scrivere una funzione che calcoli la


percentuale di lettere e di cifre
numeriche presenti nella stringa
passata come parametro.
Il risultato (ovvero le due percentuali)
viene restituito utilizzando un’unica
struttura.

Paola Mussida
Esercizio F_16 - Percentuali di stringa 62

#define MAX 80
typedef struct {
        float carat;
        float cifre;
} analisi; /* tipo per contenere il risultato dell'analisi della stringa */

 
void main() {
analisi risultato;
char stringa[MAX];
printf("\nInserisci la stringa da analizzare: ");
scanf("%s",stringa);    /* inserimento stringa */
risultato.cifre=0.0;   
risultato.carat=0.0;           /* inizializzazione */

/* visualizzazione risultato */
printf("\nPercentuale di cifre = %5.2f%% e di caratteri =
%5.2f%%", risultato.cifre, risultato.carat);
}
Paola Mussida
Esercizio F_16 - Percentuali di stringa 63

/* la funzione conta le lettere e le cifre che compongono *


 * la stringa passata come parametro e calcola le relative *
 * percentuali */

Paola Mussida
Esercizio F_17 - To Upper 64

Implementare una funzione che


converta in maiuscolo una stringa
passata come parametro.

Paola Mussida
Esercizio F_17 - To Upper 65

#define NUM 3
#define MAX_STR 50
struct {
        char cognome[MAX_STR];
        char nome[MAX_STR];
        char indirizzo[MAX_STR];
        char citta[MAX_STR];
        int  anno_nascita;
} anagrafe[NUM];

/* converte in maiusc. la stringa passata come parametro*/


void maiuscole(char str[ ]) {      
 
 

 
}
Paola Mussida
Esercizio F_17 - To Upper 66

Paola Mussida
Esercizio F_18 - Elimina punti 67

Scrivere una funzione che, riceva


come parametro una stringa e, nel
caso essa inizi con dei punti, la
modifichi eliminando i punti stessi, e
restituisca il numero di punti tolti.

Paola Mussida
Esercizio F_18 - Elimina punti 68

/* Chiamata: */

nuovastr

stringa . . . parola\0

stringa
. . . parola\0

nuovastr
Paola Mussida
Esercizio F_18 - Elimina punti 69

#define MAX 80
/*dalla stringa passata come parametro vengono eliminati gli
eventuali punti. Il numero di questi punti viene restituito*/
 
int toglipunti(char **stringa) {
 
 
 
 
 
 
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_19 - Biblioteca 70

Definire le strutture dati e le funzioni


necessarie (inserimento e cancellazione
libri) per gestire molteplici biblioteche.
Una biblioteca contiene uno scaffale
composto da vari libri (possono esserci
posizioni vuote).
Ogni libro è caratterizzato da autore e
titolo.

Paola Mussida
Esercizio F_19 - Biblioteca 71

#define MAX_LIBRI 100  


#define MAX_STR 50
 
typedef enum {false, true} boolean;

Paola Mussida
Esercizio F_19 - Biblioteca 72

void main()
{
  Biblioteca Ragazzi, Fantascienza;
  char autore[MAX_STR], titolo[MAX_STR];
  int i;
 
  for (i=0; i<MAX_LIBRI; i++)
{
Ragazzi.validi[i] = false;
Fantascienza.validi[i] = false;
  }

/* Il main() prosegue ... */

Paola Mussida
Esercizio F_19 - Biblioteca 73

Paola Mussida
Esercizio F_19 - Biblioteca 74

/* …continua il main() */
strcpy(autore,"Rowling");
strcpy(titolo, "Harry Potter");
if (                                     == 0 )
{
printf("Errore\n");
exit(1);
}
strcpy(autore,"Asimov");
strcpy(titolo, "Fondazione e Terra");
if (                                       == 0 )
{
    printf("Errore\n");  
    exit(1);
  }
}
Paola Mussida
Esercizio F_19 - Biblioteca 75

Paola Mussida
Esercizio F_19 - Biblioteca 76

/* la Biblioteca va passata per indirizzo perché verrà modificata. Ritorna


zero se c'e` qualche errore, altrimenti il numero di libri nella biblioteca*/
int insLibro(Biblioteca * b,  char a[ ], char t[ ]) {
 
 
 
 

 
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_19 - Biblioteca 77

boolean delLibro(Biblioteca * b,  char a[ ], char t[ ])


{
 
 
 
 
 
 
 
 
 
 
 
 

 
 
 
}
Paola Mussida
Esercizio F_20 - Archivio 78

Implementare le funzioni necessarie


ad inserire ed eliminare interi da un
archivio con stato pieno/vuoto.
Il vettore dell’archivio viene passato
come parametro.

Paola Mussida
Esercizio F_20 - Archivio 79

Si consideri il problema di memorizzare N numeri interi in un


archivio, sfruttando un apposito flag per memorizzare lo stato
delle singole celle (usata, libera).
Si definiscano le strutture dati richieste per generare tale archivio
Si implementino, tramite apposite funzioni/procedure, le seguenti
funzionalità:
1. Aggiunta di un elemento all’archivio
2. Eliminazione di un elemento dall’archivio
3. Visualizzazione degli elementi presenti nell’archivio
4. Ricerca di un elemento nell’archivio
5. Inserimento di un elemento solo se esso non è già presente
nell’archivio
6. Incremento di una unità degli elementi presenti nell’archivio
7. Raggruppamento degli elementi validi all’inizio dell’archivio

Ottimizzare il codice implementando funzioni che possono essere


utilizzate in più punti del programma.
Paola Mussida
Esercizio F_20 - Archivio 80

#define MAX 10
 
typedef enum {VUOTA, PIENA} dispon;
typedef struct {
        int elemento;
        dispon stato;
} cella;
 
/* inizializzazione */
void init(cella *lista) {
        int i;
 
        for ( i=0; i<MAX; i++ )
                lista[i].stato=VUOTA;
}

Paola Mussida
Esercizio F_20 - Archivio 81

/* inserimento di un numero in una cella disponibile */


     ins (                            ) {
 
 
 
 
 
 
 
 
 
 
 
}
 
/* inserimento di un numero in una cella (solo se l’elemento non è già presente) */
    ins_esclusivo (                           ) {
 
 
 
 
}
Paola Mussida
Esercizio F_20 - Archivio 82

    esiste (                                      ) {
 
 
 
 
 

 
 
}

    del(                                               ) {
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_20 - Archivio 83

/* incrementa di una unità gli elementi validi */


    incrementa (                        ) {
 
 
 
 
 

 
 
 
}
Paola Mussida
Esercizio F_20 - Archivio 84

/* restituisce il primo elemento libero */


    primolibero (                             ) {
 
 

 
 
}
 
/* restituisce l'ultimo elemento valido */
    ultimovalido (                             ) {
 
 
 

 
 
}

Paola Mussida
Esercizio F_20 - Archivio 85

/* compatta le celle contenenti elementi validi */


    compatta (                            ) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}

Paola Mussida
Esercizio F_20 - Archivio 86

/* ulteriore ottimizzazione: riutilizzo della funzione


primolibero() */
 
/*inserimento di un numero in una cella disponibile*/
    ins (                                    ) {
       
 

 
 

 
 
 
 
}
Paola Mussida
Esercizio F_20 - Archivio 87

void main()
{
cella vett[MAX];
int operaz=-1, numero, posiz, ris;

/* inizializzazione */
init(vett);
while ( operaz!=0 )
{ /* richiesta operazione */
        /* richiesta operazione da eseguire */
        printf("\nInserisci l'operazione:");
        printf("\n\t0 fine");
        printf("\n\t1 aggiungi");
        printf("\n\t2 elimina");
        printf("\n\t3 visualizza");
        printf("\n\t4 ricerca");
        printf("\n\t5 inserisci esclusivo");
        printf("\n\t6 incrementa");
Paola Mussida
Esercizio F_20 - Archivio 88

printf("\n\t7 compatta");
printf("\n\t: ");
scanf("%d",&operaz);
 
/* elaborazione */
switch ( operaz )  
{
case 0:
        printf("\nFine Programma!");
  break;
case 1: /* inserimento */
        /* richiesta numero sul quale operare */
        printf("\nInserisci il numero positivo: ");
        scanf("%d",&numero);
        if (ins(vett,numero)==-1)
           printf("Non ci sono celle disponibili!")
  break;
Paola Mussida
Esercizio F_20 - Archivio 89

case 2: /* richiesta numero sul quale operare */


        printf("\nInserisci il numero positivo: ");
        scanf("%d",&numero);
        if (del(vett,numero)==-2) /* eliminazione */
          printf("Il numero richiesto non e’ stato
trovato!");
  break;

case 3: /* visualizzazione array */


        vis(vett);
  break;

Paola Mussida
Esercizio F_20 - Archivio 90

case 4: /* ricerca elemento */


 
        /* richiesta numero da ricercare */
        printf("\nInserisci il numero positivo: ");
        scanf("%d",&numero);
 
        /* ricerca */
        if ( (posiz=esiste(vett,numero)) == -1 )
           printf("Il numero richiesto non è stato
trovato!");
        else
           printf("Il numero richiesto è nella
posizione %d!", posiz);
  break;     

Paola Mussida
Esercizio F_20 - Archivio 91

case 5: /* inserimento esclusivo */


 
        /* richiesta numero da inserire */
        printf("\nInserisci il numero positivo: ");
        scanf("%d",&numero);
       ris = ins_esclusivo(vett,numero);
        switch (ris) {
                case -1:
                        printf("Non ci sono celle
disponibili!");
                  break;

                case -3:
                        printf("Elemento già presente!");
                  break;
        }
  break;

Paola Mussida
Esercizio F_20 - Archivio 92

case 6: /* visualizzazione array */


        printf("ho incrementato %d elementi!",
incrementa(vett));
  break;

case 7: /* visualizzazione array */


        compatta(vett);
  break;

default:
        printf("\nOperazione non supportata!");
  break;

}
}
}

Paola Mussida
Fondamenti di Informatica 2016-2017

Game of Life

Paola Mussida
Area Servizi ICT
Esercizio F_21 - Game of Life 94

✓ Il gioco della vita mostra l’evoluzione di un mondo molto


semplice costituito da cellule che possono essere vive o
morte.

✓ Il campo di gioco è una matrice le cui celle possono


contenere ciascuna un’unica cellula.

✓ Le regole dell’evoluzione sono le seguenti:


✓ una cellula muore per sovraffollamento nel caso in cui

abbia un numero di cellule vicine compreso tra 4 e 8;


✓ una cellula muore per “desertificazione” nel caso in

cui abbia 0 o 1 cellula vicina


✓ una nuova cellula nasce se ha tre cellule vicine

✓ una cellula rimane nel suo stato precedente nel caso

abbia due cellule vicine


Paola Mussida
Esercizio F_21 - Game of Life 95

✓ Si sviluppi un programma che mostri all’utente


l’evoluzione del gioco ad ogni passo.

✓ Si supponga che l’utente definisca lo stato iniziale del


gioco:
✓ indicando la dimensione del campo di gioco

✓ identificando il numero e la posizione delle cellule

vive

✓ ...e che possa controllare l’avanzamento del gioco e la


sua terminazione inserendo da tastiera opportuni
comandi

Paola Mussida
Esercizio F_21 - Game of Life 96

A. Inizializza lo scenario del gioco.

B. Assegna le celle che devono essere inizialmente vive


nella posizione indicata dall’utente.

C. Visualizza lo scenario.

D. Calcola il nuovo scenario in base alle regole del gioco.

E. Chiedi all’utente se vuole visualizzare il nuovo


scenario calcolato. In caso di risposta affermativa vai
al punto C, altrimenti termina il programma.

Paola Mussida
Esercizio F_21 - Game of Life 97

Paola Mussida
Esercizio F_21 - Game of Life - prototipi 98

Intestazioni delle funzioni individuate

Paola Mussida
Esercizio F_21 - Game of Life 99

void main()
{
  int viteIniziali;
  char scelta;
  scenario mioScenario;
  boolean continua=true;
 
  inizializza(&mioScenario);
  printf("\nInserisci il numero delle vite iniziali: ");
  scanf("%d",&viteIniziali);
  assegnaViteIniziali(&mioScenario,viteIniziali);
 
/* ... */

Paola Mussida
Esercizio F_21 - Game of Life 100

/* ... */
 
while (continua==true)
{
    visualizza(mioScenario);
    aggiorna(&mioScenario);

    printf("\nVuoi continuare? (N per terminare) ");


    fflush(stdin);
    scanf("%c", &scelta);

    if (scelta=='n' || scelta=='N')
        continua=false;
  }
}
Paola Mussida
Esercizio F_21 - Game of Life 101

void inizializza(scenario *scen) {

    
 
 
 
                             
 
 
 
 
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_21 - Game of Life 102

void assegnaViteIniziali(scenario *scen, int viteIniziali) {


   
 
 
 
 
 
 
 
 
 
 
 

 
 
 
}
Paola Mussida
Esercizio F_21 - Game of Life 103

void visualizza(scenario scen){


   
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}
Paola Mussida
Esercizio F_21 - Game of Life 104

int contaVicini(scenario s, int riga, int colonna) {


 
 
 
 
 
 
 
 
 
 
 
 

 
}

Paola Mussida
Esercizio F_21 - Game of Life 105

void aggiorna(scenario *scen) {


 
 
 
 

 
 
 
 
 
 
 
 
 
 
 
 
}
Paola Mussida