Prove d'esame svolti di Fondamenti di informatica

Esercizi

15/02/23:

20.3: Funzione che riceve in ingresso due matrici A e B di valori float di dimensione N×T e T×P, e accoda la matrice prodotto C di dimensione N×P. Le tre matrici sono rappresentate su array monodimensionali.

void Product(float *A, float *B, int N, int M, int P, float **C_PTR) { int n, m, mu, p; *C_PTR = (float*) malloc(N*P*sizeof(float)); for (n=0; n PTR->NEXT_PTR->VALUE)

RETURN FALSE;

PTR=PTR->NEXT_PTR;

}

RETURN TRUE;

01/02/23:

es. 3:

DEFINIRE LA STRUTTURA CHE RAPPRESENTA UN ELEMENTO DI

UNA LISTA DI VALORI DI TIPO FLOAT IN FORMA COLLEGATA

CON PUNTATORI.

DEFINIRE DUE FUNZIONI CHE RESTITUISCONO LA LUNGHEZZA

DI UNA TALE LISTA IN FORMA ITERATIVA E IN FORMA RICORSIVA.

STRUCT LIST {

FLOAT VALUE;

STRUCT LIST *NEXT_PTR;

};

INT ITERATIVE_LENGTH (STRUCT LIST * PTR){

INT LENGTH;

LENGTH =0;

WHILE ( PTR != NULL){

LENGTH++;

PTR=PTR->NEXT_PTR;

}

RETURN LENGTH;

}

INT RECURSIVE_LENGTH(STRUCT LIST *PTR) {

IF (PTR!=NULL)

RETURN 1 + RECURSIVE_LENGTH (PTR->NEXT_PTR);

ELSE

RETURN 0;

}

INITC2 ( &L2_HEAD_PTR);

C2_PTR_PTR = &L2_HEAD_PTR;

WHILE (PTR != NULL){

IF ((PTR->VALUE)%2 == 0){

PRE_INSERT_L2 (L2_PTR_PTR, PTR->VALUE);

PTR = PTR->NEXT_PTR;

WHILE (PTR != NULL && PTR->VALUE==(*L2_PTR_PTR)->VALUE){

(*L2_PTR_PTR)->OCCURRENCES ++;

PTR = PTR->NEXT_PTR;

}

L2_PTR_PTR =&((*L2_PTR_PTR)->NEXT_PTR);

}

ELSE{

PTR=PTR->NEXT_PTR;

}

}

RETURN L2_HEAD_PTR;

}

20 q:

SCRIVERE UNA FUNZIONE CHE RICEVE IN INGRESSO UN ARRAY DI FLOAT X E LA SUA DIMENSIONE N, E RESTITUISCE LA VARIANZA DELL'INSIEME DEGLI ELEMENTI DI X.

σ² = (x₁-N)²+...+(x_m-N)² / m            CON N: MEDIA DEGLI ELEMENTI DI X

FLOAT getVariance (FLOAT*X, UNSIGNED INT N){

INT UNSIGNED COUNT;

FLOAT MU, VARIANCE;

FOR (COUNT = 1, MU = X [0]; COUNT < N; COUNT++){

MU = MU + X [COUNT];

}

MU = MU / N;

FOR (COUNT = 1, VARIANCE = (X[0] - MU) * (X[0] - MU); COUNT < N; COUNT ++){

VARIANCE = VARIANCE + (X[COUNT] - MU) * (X[COUNT] - MU);

}

VARIANCE = VARIANCE / N;

RETURN VARIANCE;

}

20 S

Definire una struttura che rappresenta un elemento di una lista di float in forma collegata con puntatori. Definire una funzione che prende in ingresso una tale lista L ed un valore soglia T e restituisce il puntatore al primo elemento della nuova lista L’ tale che L’ ha lo stesso numero di elementi di L e L’_iesimo elemento di L’ vale 1, 0 oppure -1 se l’iesimo elemento di L è >, = oppure < di T. Non è richiesta l’implementazione delle funzioni elementari.

struct List{ float value; struct List *next_ptr;};struct List *createList(struct List *ptr, float T){ struct List *myListPtr; struct List **myListPtrPtr; myListPtrPtr = &myListPtr; init (myListPtrPtr); while (ptr != NULL){ if (ptr->value > T){ pre_insert (myListPtrPtr, 1); } else if (ptr->value == T){ pre_insert (myListPtrPtr, 0); } else{ pre_insert (myListPtrPtr, -1); } ptr = ptr->next_ptr; myListPtrPtr = &((*myListPtrPtr)->next_ptr); } return myListPtr;}

01/09/21

void recursiveFunction (struct list *ptr) { if (ptr != NULL) { if (ptr->value == 'A') { ptr->value = 'Z'; } recursiveFunction (ptr->next.ptr); }}

20:3

Definire una funzione che riceve in ingresso un intero senza segno maggiore di 1 e restituisce il suo massimo divisore (escluso il numero stesso).

unsigned int maxDivisor(unsigned int n) { unsigned int count; count = n/2; while (count > 0) { if (n%count == 0) return count; count--; } return count;}

20:4

Definire la struttura che rappresenta un oggetto di una lista di variabili int rappresentata in forma collegata da puntatori.

Definire una funzione che riceve in ingresso un array di N variabili di tipo int e restituisce il puntatore alla testa di una lista L di N elementi rappresentata in forma collegata con puntatori e c.:

• Il primo elemento di L contiene la somma di tutti gli N elementi di V
• Il secondo elemento di L contiene la somma dei N-1 elementi di V
• Il terzo " " " " " N-2 elementi di V
• L'N-esimo elemento di L contiene il primo elemento di V

Definire il tipo di dato Boolean (tramite typedef) e i valori di verità true e false (tramite #define).

Definire una funzione che riceve in ingresso 3 valori float: valore, threshold ed epsilon e restituisce true se la differenza in valore assoluto tra valore e threshold è inferiore ad epsilon, false altrimenti.

typedef unsigned short int Boolean;#define TRUE 1#define FALSE 0Boolean F(float value, float threshold, float epsilon){ if (value - threshold < epsilon && value - threshold > -epsilon) return TRUE; else return FALSE;}

Definire una struttura che rappresenta un elemento di una lista di int in forma collegata con puntatori.

Definire una funzione che:

• Riceve in ingresso due liste L1 e L2, rappresentate in forma collegata con puntatori, ed di uguale dimensione.
• Restituisce il numero di elementi di L1 e L2 che occupano la stessa posizione e sono multipli uno dell'altro.

struct list{ int value; struct list *next_ptr;};int elements (struct list *ptr1, struct list *ptr2){ int count; while (ptr1 != NULL){ if ((ptr1->value)%(ptr2->value)==0 || (ptr2->value)%(ptr1->value)==0) count++; ptr1 = ptr1->next_ptr; ptr2 = ptr2->next_ptr; } return count;}