Università degli Studi di Firenze, Scuola di Ingegneria – Corso di Laurea in Ingegneria Informatica – Prof.

Stefano Berretti

Fondamenti di Informatica
SECONDA PROVA IN ITINERE – testo B – 10 gennaio 2020

COGNOME________________________ NOME________________________

Esercizio 1. (10 punti)

Scrivere la funzione C che riceve in ingresso una lista collegata con array ed indici di valori float ed una
variabile target di tipo float e rimuove dalla lista tutti gli elementi uguali a target. La funzione restituisce
TRUE nel caso in cui sia stato rimosso almeno un elemento dalla lista, FALSE in caso contrario.

Esercizio 2. (10 punti)

Scrivere la funzione C che riceve in ingresso una lista sequenziale di valori interi e la partiziona con l’algoritmo
partition. Scrivere anche la complessità dell’algoritmo.

Esercizio 3. (12 punti)

Scrivere la funzione C che riceve in ingresso una lista collegata con puntatori di valori interi ed opera nel modo
seguente:
• Gli elementi della lista sono scanditi a partire dalla testa: Se l’elemento corrente con valore i è seguito
da un elemento con valore j, j >= i+1, allora la lista è completata inserendo tra l’elemento con valore i e
l’elemento con valore j, tuti gli elementi con valori da i+1 a j-1;
• Se l’elemento corrente con valore i è seguito da un elemento con valore j, j <= i, allora l’elemento con
valore j è rimosso dalla lista. Gli elementi rimossi sono inseriti in un array V restituito tra i parametri
formali della funzione, insieme con il numero di valori rimossi dalla lista.
Scrivere anche l’equazione di costo e la complessità dell’algoritmo.
(Esempio: lista di ingresso {2,4,6,5,8}, lista di uscita {2,3,4,5,6,7,8}, array V = {5})
 Università degli Studi di Firenze, Scuola di Ingegneria – Corso di Laurea in Ingegneria Informatica – Prof. Stefano Berretti

Soluzione

Esercizio 1.
#define epsilon 0.00001
#define TRUE 1
#define FALSE 0
typedef unsigned short int Boolean;

struct record {
float value;
int next;
};

struct list {
struct record * buffer;
int free;
int first;
int size;
};

Boolean target_remove(struct list * ptr, float target) {

int * position, moved;
Boolean found = FALSE;

if( ptr->first != ptr->size ) { // not void

position = &ptr->first;
// find the position to remove
while( ptr->buffer[*position].next != ptr->size )
if( isequal(ptr->buffer[position].value,target,epsilon) ) {
// remove element
found = TRUE;
moved = *position;
*position = ptr->buffer[*position].next;
ptr->buffer[moved].next = ptr->free;
ptr->free = moved;
}
else
position = &(ptr->buffer[*position] .next);
}
return found;
}

Boolean isequal(float a, float b, float epsilon) {

float diff, largest;
diff = fabs(a-b);
a = fabs(a);
b = fabs(b);
largest = a > b ? a : b;
if( diff <= epsilon*largest )
return TRUE;
else
return FALSE;
}

Esercizio 2.
 Università degli Studi di Firenze, Scuola di Ingegneria – Corso di Laurea in Ingegneria Informatica – Prof. Stefano Berretti

struct list {
struct int * buffer;
int head;
int tail;
int free;
};

int partition(struct list * ptr) {

int l, r, pivot;

pivot = ptr->buffer[ptr->head];
l = ptr->head;
r = ptr->tail;
while( l != r) {
do{ r=(r-1+ptr>size)%ptr->size; } while( r != l && ptr->buffer[r] > pivot );
if( r != l ) {
do{ l=(l+1)%ptr->size; } while( r != l && ptr->buffer[l] <= pivot );
swap(ptr->buffer,l,r);
}
}
swap(ptr->buffer,l,ptr->head);
return l;
}

void swao(int * V, l, r) {
int tmp;

tmp = ptr->buffer[l];
ptr->buffer[l] = ptr->buffer[r];
ptr->buffer[r] = tmp;
}

Indicando con N il numero di elementi presenti nella lista, l’equazione di costo può essere scritta come:

c1 N N>0
partition(N) =
c2 N == 0

La complessità dell’algoritmo è perciò lineare C parttition(N) = (N).

Esercizio 3.
struct list {
int value;
struct list * next_ptr;
};

Boolean complete_list(struct list * ptr, int ** V, int * n_removed) {

struct list * tmp_ptr;
int count, N, value;

// count the number N of elements in the list

 Università degli Studi di Firenze, Scuola di Ingegneria – Corso di Laurea in Ingegneria Informatica – Prof. Stefano Berretti

N = 0;
tmp_ptr = ptr;
while( ptr != NULL ) {
N++;
ptr = ptr->next_ptr;
}
*V = (int *)malloc(sizeof(int)*(N-1));

*n_removed = 0;
ptr = tmp_ptr;
while( ptr != NULL && ptr->next_ptr != NULL ) {
if( ptr->value < ptr->next_ptr->value ) {
// complete the list with elements with values [value+1, value+diff-1]
diff = ptr->next_ptr->value - ptr->value;
for( count=1; count<diff; count++ ) {
pre_insert(&(ptr->next_ptr), ptr->value+count);
ptr = ptr->next_ptr;
}
ptr = ptr->next_ptr;
}
else {
// remove the next element
pre_remove(&(ptr->next_ptr),value);
V[(*n_removed)++] = value;
}
}
}

Indicando con N il numero di elementi della lista, l’equazione di costo può essere scritta come:

c1 + complete_list(N-1) N>0
complete_list(N) =
c2 N == 0

La complessità dell’algoritmo è perciò lineare Ccomplete_list(N) = (N).