[C++] esercizio ok?
Devo fare l'esame di informatica per ingegneria meccanica e sto cercando di risolvere alcuni esercizi.
"Siano dati in ingresso due vettori V1 e V2 di numeri interi. Si supponga che entrambi i vettori siano disordinati. Scrivere un programma (in C++) che identifichi la più lunga sequenza di elementi ordinati del vettore V1 (denominata S1) e la più lunga sequenza di elementi ordinati del vettore V2 (denominata S2). Si provveda poi a scambiare tali sequenze: la sequenza S1 trovata nel vettore V1 deve essere inserita nel vettore V2 al posto della sequenza S2 e viceversa. Stampare infine i vettori V1 e V2."
Io l'ho risolto così:
Pare che funzioni, voi che dite? Grazie
"Siano dati in ingresso due vettori V1 e V2 di numeri interi. Si supponga che entrambi i vettori siano disordinati. Scrivere un programma (in C++) che identifichi la più lunga sequenza di elementi ordinati del vettore V1 (denominata S1) e la più lunga sequenza di elementi ordinati del vettore V2 (denominata S2). Si provveda poi a scambiare tali sequenze: la sequenza S1 trovata nel vettore V1 deve essere inserita nel vettore V2 al posto della sequenza S2 e viceversa. Stampare infine i vettori V1 e V2."
Io l'ho risolto così:
#include <iostream>
using namespace std;
int main() {
cout<<"Scegliere la dimensione del primo vettore:\n";
int dim1;
int dim2;
cin>>dim1;
cout<<"Scegliere la dimensione del secondo vettore:\n";
cin>>dim2;
int vett1[dim1];
int vett2[dim2];
int i;
for (i=0;i<dim1;i++)
{cout<<"Inserisci l'elemento numero "<<i+1<<" del primo vettore:\n";
cin>>vett1[i];
}
for (i=0;i<dim2;i++)
{cout<<"Inserisci l'elemento numero "<<i+1<<" del secondo vettore:\n";
cin>>vett2[i];
}
cout<<"Il primo vettore è:\n";
for(i=0;i<dim1;i++)
{cout<<" "<<vett1[i];}
cout<<"\nIl secondo vettore è:\n";
for(i=0;i<dim2;i++)
{cout<<" "<<vett2[i];}
//introduco il vettore lunghezza1 e indpar1 in cui memorizzare le lunghezze e gli indici di partenza delle serie trovate
int j1=-1; int lunghezza1[dim1]; int uno1=1; int k1=0; int indpar1[dim1];
//azzero i vettori lunghezza1 e indpar1
for(i=0;i<dim1;i++)
{lunghezza1[i]=0;}
for(i=0;i<dim1;i++)
{indpar1[i]=0;}
//memorizzazione di lunghezze e indici nelle componenti dei vettori
for(i=1;i<dim1;i++)
{
if(vett1[i-1]<vett1[i])
{j1++; lunghezza1[j1]=++uno1; indpar1[j1]=k1;}
else
{uno1=1; k1=i;}
}
//calcolo dell'elemento massimo e sua posizione
int massimo1; int posmax1=0;
massimo1=lunghezza1[0];
for(i=1;i<dim1;i++)
{
if(massimo1<lunghezza1[i])
{massimo1=lunghezza1[i]; posmax1=i;}
}
cout<<"\nLa sequenza crescente più lunga del primo vettore ha lunghezza "<<massimo1<<" e parte dalla posizione "<<indpar1[posmax1]+1;
cout<<"\nEssa è:\n";
for(i=indpar1[posmax1];i<indpar1[posmax1]+massimo1;i++)
{cout<<" "<<vett1[i];}
//Faccio la stessa cosa per il secondo vettore
int j2=-1; int lunghezza2[dim2]; int uno2=1; int k2=0; int indpar2[dim2];
for(i=0;i<dim2;i++)
{lunghezza2[i]=0;}
for(i=0;i<dim2;i++)
{indpar2[i]=0;}
for(i=1;i<dim2;i++)
{
if(vett2[i-1]<vett2[i])
{j2++; lunghezza2[j2]=++uno2; indpar2[j2]=k2;}
else
{uno2=1; k2=i;}
}
int massimo2; int posmax2=0;
massimo2=lunghezza2[0];
for(i=1;i<dim2;i++)
{
if(massimo2<lunghezza2[i])
{massimo2=lunghezza2[i]; posmax2=i;}
}
cout<<"\nLa sequenza crescente più lunga del secondo vettore ha lunghezza "<<massimo2<<" e parte dalla posizione "<<indpar2[posmax2]+1;
cout<<"\nEssa è:\n";
for(i=indpar2[posmax2];i<indpar2[posmax2]+massimo2;i++)
{cout<<" "<<vett2[i];}
//scambio le sequenze ordinate e mostro i risultati
cout<<"\nSostituendo la sequenza ordinata del primo vettore con quella del secondo, il primo vettore diventa:\n";
for(i=0;i<indpar1[posmax1];i++)
{cout<<" "<<vett1[i];}
for(i=indpar2[posmax2];i<indpar2[posmax2]+massimo2;i++)
{cout<<" "<<vett2[i];}
for(i=indpar1[posmax1]+massimo1;i<dim1;i++)
{cout<<" "<<vett1[i];}
cout<<"\nSostituendo la sequenza ordinata del secondo vettore con quella del primo, il secondo vettore diventa:\n";
for(i=0;i<indpar2[posmax2];i++)
{cout<<" "<<vett2[i];}
for(i=indpar1[posmax1];i<indpar1[posmax1]+massimo1;i++)
{cout<<" "<<vett1[i];}
for(i=indpar2[posmax2]+massimo2;i<dim2;i++)
{cout<<" "<<vett2[i];}
}
Pare che funzioni, voi che dite? Grazie
Risposte
Ho prodotto questi due codici che secondo me sono necessari per risolvere gli esercizi.
Il primo elimina k elementi consecutivi a partire da una posizione nel vettore.
Il secondo si serve del primo per mostrare solo gli elementi di un vettore che sono a distanza maggiore di k tra loro (penso che intenda questo il professore).
Ora mi studio le vostre risposte e cerco di completare l'esercizio. Lo vedo duro questo esame, ci metto ancora troppo tempo ed energie per scrivere cose quasi elementari. Comunque mi sono abituato ad allocare vettori e matrici variabili in modo dinamico, secondo voi il professore potrebbe farmi storie? Non mi piace allocarli in modo statico scegliendo una dimensione molto grande in quanto il codice perderebbe generalità.
Il primo elimina k elementi consecutivi a partire da una posizione nel vettore.
Il secondo si serve del primo per mostrare solo gli elementi di un vettore che sono a distanza maggiore di k tra loro (penso che intenda questo il professore).
Ora mi studio le vostre risposte e cerco di completare l'esercizio. Lo vedo duro questo esame, ci metto ancora troppo tempo ed energie per scrivere cose quasi elementari. Comunque mi sono abituato ad allocare vettori e matrici variabili in modo dinamico, secondo voi il professore potrebbe farmi storie? Non mi piace allocarli in modo statico scegliendo una dimensione molto grande in quanto il codice perderebbe generalità.
#include <iostream>
using namespace std;
//programma che elimina k elementi consecutivi a partire da pos
void elimina_elem(int k, int pos, int dim, int* v)
{
for(int i=0;i<=(dim+k-pos-1);i++)
{
v[pos-1+i]=v[pos-1+k+i];
}
}
int main()
{
int k;
int pos;
int dim;
cout<<"Scegli la dimensione del vettore ";
cin>>dim;
int* v=new int[dim];
cout<<"\n";
for(int i=0;i<dim;i++)
{
cout<<"Inserisci l'elemento numero "<<i+1<<" ";
cin>>v[i];
}
cout<<"\nIl vettore inserito è\n";
for(int i=0;i<dim;i++)
{
cout<<" "<<v[i]<<" ";
}
cout<<"\nNumero di elementi da eliminare ";
cin>>k;
cout<<"\nPosizione inizio eliminazione ";
cin>>pos;
elimina_elem(k, pos, dim, v);
dim=dim-k;
cout<<"\nIl vettore modificato è\n";
for(int i=0;i<dim;i++)
{
cout<<" "<<v[i]<<" ";
}
}
#include <iostream>
#include<cmath>
using namespace std;
void elimina_elem(int k, int pos, int dim, int* v)
{
for(int i=0;i<=(dim+k-pos-1);i++)
{
v[pos-1+i]=v[pos-1+k+i];
}
}
//programma che modifica un vettore mostrando solo gli elementi che sono a distanza maggiore di k tra loro.
int main()
{
int i;
int dim;
cout<<"Scegli la dimensione del vettore ";
cin>>dim;
int* v=new int[dim];
for(i=0;i<dim;i++)
{
cout<<"\nInserisci l'elemento numero "<<i+1<<" ";
cin>>v[i];
}
cout<<"\nIl vettore inserito è\n";
for(i=0;i<dim;i++)
{
cout<<" "<<v[i]<<" ";
}
cout<<"\nImposta la distanza fra gli elementi ";
int dis;
cin>>dis;
cout<<"\nIl vettore che contiene gli elementi distanti tra loro più di "<<dis<<" è\n";
for(i=1;i<dim;i++)
{
while(abs(v[i-1]-v[i])<=dis)
{
elimina_elem(1,i,dim,v);
dim=dim-1;
}
}
for(i=0;i<dim;i++)
{
cout<<" "<<v[i]<<" ";
}
}
Questo è l'esercizio. Ci sono ovviamente varie cose da rivedere, è solo una bozza. Provate a testarlo con una matrice con qualche colonna crescente.
Non sono sicuro di interpretare correttamente la richiesta di lasciare solo gli elementi a distanza maggiore di K tra loro.
Ad esempio, dato un vettore, considero la prima coppia di elementi e se la loro differenza assoluta è <=K la butto altrimenti la tengo......quindi passo alla coppia successiva e cos' via?
#include <iostream>
#include<cmath>
using namespace std;
int nrig;
int ncol;
int i;
int j;
void elimina_elem(int k, int pos, int dim, int* v)
{
for(int i=0;i<=(dim+k-pos-1);i++)
{
v[pos-1+i]=v[pos-1+k+i];
}
}
void imatrice(int** matrice)
{
for(int i=0;i<nrig;i++)
{
for(int j=0;j<ncol;j++)
{
cout<<"\nInserisci l'elemento posizionato sulla riga "<<i+1<<" e sulla colonna "<<j+1<<" ";
cin>>matrice[i][j];
}
}
}
void omatrice(int** matrice)
{
for(int i=0;i<nrig;i++)
{
cout<<"\n";
for(int j=0;j<ncol;j++)
{
cout<<" "<<matrice[i][j]<<" ";
}
}
}
int testasecolonnacrescente(int** matrice, int col)
{
for(int i=1;i<nrig;i++)
{
if(matrice[i-1][col]>=matrice[i][col])
{
return 0;
}
}
return 1;
}
int main()
{
cout<<"Inserisci il numero di righe della matrice ";
cin>>nrig;
cout<<"\nInserisci il numero di colonne della matrice ";
cin>>ncol;
//allocazione matrice
int** matrice=new int* [nrig];
for(i=0;i<nrig;i++)
{
matrice[i]=new int[ncol];
}
imatrice(matrice);
cout<<"\nLa matrice che hai inserito è\n";
omatrice(matrice);
//introduco un vettore di dimensione dim=nrig*ncol in cui memorizzare le colonne crescenti
int dim=nrig*ncol;
int* V=new int[dim];
int col;
int progressione=-1;
for(col=0;col<ncol;col++)
{
if(testasecolonnacrescente(matrice,col))
{
cout<<"\nLa colonna "<<col+1<<" è crescente.";
//fase di memorizzazione delle colonne crescenti in V
for(i=0;i<nrig;i++)
{
++progressione;
V[progressione]=matrice[i][col];
}
}
else
cout<<"\nLa colonna "<<col+1<<" non è crescente.";
}
//ridimensiono V
dim=progressione+1;
//"filtro" V tenendo solo gli elementi che distano più di k.
unsigned int k;
cout<<"\nScegli un numero intero positivo ";
cin>>k;
cout<<"\nIl vettore completo delle colonne crescenti è\n";
for(i=0;i<dim;i++)
{
cout<<" "<<V[i]<<" ";
}
cout<<"\nIl vettore che contiene solo gli elementi delle colonne crescenti distanti tra loro più di "<<k<<" è\n";
for(i=1;i<dim;i++)
{
while(abs(V[i-1]-V[i])<=k)
{
elimina_elem(1,i,dim,V);
dim=dim-1;
}
}
for(i=0;i<dim;i++)
{
cout<<" "<<V[i]<<" ";
}
}
Non sono sicuro di interpretare correttamente la richiesta di lasciare solo gli elementi a distanza maggiore di K tra loro.
Ad esempio, dato un vettore, considero la prima coppia di elementi e se la loro differenza assoluta è <=K la butto altrimenti la tengo......quindi passo alla coppia successiva e cos' via?
"selfmademan":
Non sono sicuro di interpretare correttamente la richiesta di lasciare solo gli elementi a distanza maggiore di K tra loro.
Ad esempio, dato un vettore, considero la prima coppia di elementi e se la loro differenza assoluta è <=K la butto altrimenti la tengo......quindi passo alla coppia successiva e cos' via?
Sinceramente penso che quella frase abbia un significato chiaro e univoco solo nella mente del tuo professore. Non solo non esiste un modo univoco per filtrare un insieme ordinato in base a quella condizione (neanche se aggiungiamo qualche condizione di massimalità) ma dubito che il filtraggio si comporti bene con l'operazione di unione. Insomma unire tutto e poi filtrare non produce lo stesso risultato di filtrare ogni volta che si fa l'unione di due vettori.
Comunque penso che sia più utile, ai fini del compito, che tu sappia fare bene la prima parte. Per la seconda potremmo proporti noi un qualche filtraggio alternativo per cui risulta possibile scrivere un test indipendente dall'implementazione.
Il primo elimina k elementi consecutivi a partire da una posizione nel vettore.
Invece della posizione (con cui credo tu intenda l'indice + 1), meglio lavorare direttamente con l'indice.
Visto che ci tieni così tanto a non sprecare memoria, bisogna sottolineare che quello che fai non è una vera e propria eliminazione di elementi dall'array, ma ti limiti semplicemente a spostarli e a considerare i primi dim - k. Per "eliminarli" avresti dovuto allocare un vettore in cui inserire i dim - k elementi e poi deallocare il vettore di partenza. Con ciò non voglio dire che hai sbagliato, anzi in questo caso il metodo da te utilizzato risulta essere la scelta migliore.
La funzione elimina_elem secondo me può essere semplificata e avrei aggiunto dei controlli circa i valori di pos e k. Utilizzando array statici avrei fatto una cosa del genere:
#include <iostream>
using namespace std;
void i_vettore(int *v, int dim)
{
for(int i = 0; i < dim; i++)
{
cout << "v[" << i << "] = ";
cin >> v[i];
}
}
void o_vettore(int *v, int dim)
{
for(int i = 0; i < dim; i++)
{
cout << v[i] << " ";
}
}
void sposta_elementi(int *v, int dim, int ind, int k)
{
for(int i = ind; i < dim - k; i++)
{
v[i] = v[i + k];
}
}
int main()
{
int dim, ind, k, v[50];
cout << "dim(MAX 50): ";
cin >> dim;
i_vettore(v, dim);
cout << "vettore inserito:" << endl;
o_vettore(v, dim);
cout << endl << "ind(MAX " << dim - 1 << "): ";
cin >> ind;
cout << "k(MAX " << dim - ind << "): ";
cin >> k;
sposta_elementi(v, dim, ind, k);
dim = dim - k;
cout << "vettore modificato:" << endl;
o_vettore(v, dim);
}Il secondo si serve del primo per mostrare solo gli elementi di un vettore che sono a distanza maggiore di k tra loro (penso che intenda questo il professore).
Ripetendo le stesse parole usate dal prof nella traccia non chiarisci molto la questione, in ogni caso dando uno sguardo al codice mi sembra di capire che tu abbia optato per la differenza in valore assoluto tra elementi successivi.
A tal proposito, come già detto in precedenza e come spiegato da vict85, la faccenda non è cmq chiarita...
Credo comunque che all'esame tu possa scegliere tra diverse tracce, quindi cerca di individuare (ammesso che esista) una in cui le richieste sono chiare e non soggette ad interpretazioni personali.
Magari posta qualche prova d'esame e dicci quale traccia vorresti risolvere.
P.S.
Ricordati sempre di deallocare la memoria allocata quando questa non ti serve più.
Vediamo di chiarire un po' sull'allocazione di memoria e il suo costo computazionale. Allocare o ridimensionare una memoria precedentemente allocata ha un costo computazionale proporzionale alla memoria da allocare. Diciamo quindi, per semplicità, che allocare \(\displaystyle N \) elementi ha un costo pari a \(\displaystyle N \).
Supponiamo di non sapere a priori il numero \(\displaystyle N \) di elementi andremo ad allocare. Allora esistono varie tecniche:
[list=1][*:7gzpppx1] Se sappiamo che \(\displaystyle N \le K \) per un qualche \(\displaystyle K \), allora possiamo allocare direttamente \(\displaystyle K \) elementi. Il costo sarà quindi costante e uguale a \(\displaystyle K \) e il massimo spreco è pari a \(\displaystyle K-1 \) elementi (possiamo supporre che la memoria non venga allocata finché non è strettamente necessario farlo).[/*:m:7gzpppx1]
[*:7gzpppx1] Il caso opposto è quello in cui allochiamo esattamente quando serve e nulla più. Quindi si ha che \(\displaystyle s_0 = 0 \), \(\displaystyle s_i = s_{i-1}+1 = i \), \(\displaystyle C_i = C_{i-1} + s_i = \sum_{j=1}^i s_j = \sum_{j=1}^i j = \frac{i(i+1)}{2} \). Pertanto il costo di allocare \(\displaystyle N \) elementi sarà \(\displaystyle \frac{N^2 + N}{2} \). Lo spreco è ovviamente nullo.[/*:m:7gzpppx1]
[*:7gzpppx1] Similare è il caso in cui ingrandiamo la memoria allocata di un numero fisso \(\displaystyle K \) di elementi, con \(\displaystyle K \) piccolo. Si ha che \(\displaystyle s_0 = 0 \), \(\displaystyle s_i = s_{i-1}+K = iK \), \(\displaystyle C_i = C_{i-1} + s_i = \sum_{j=1}^i s_j = K\sum_{j=1}^i j = K\frac{i(i+1)}{2} \). Siccome \(\displaystyle s_i \ge N \) per \(\displaystyle i \ge \biggl\lceil \frac{N}{K} \biggr\rceil \) allora il costo di allocare \(\displaystyle N \) elementi sarà tra \(\displaystyle \frac{N^2 + KN}{2K^2} \) e \(\displaystyle \frac{(N+K)^2 + K(N+K)}{2K^2} = \frac{N^2 + 2NK^2 + K^2 + KN + K^2}{2K^2} = \frac{N^2 + 3NK^2 + 2K^2}{2K^2} \). Lo spreco massimo è ovviamente \(\displaystyle K-1 \).[/*:m:7gzpppx1]
[*:7gzpppx1] Un metodo alternativo consiste nel raddoppiare la memoria allocata ogni volta. In questo caso si ha che \(\displaystyle s_1 = 1 \), \(\displaystyle s_i = 2s_{i-1} = 2^i \), \(\displaystyle C_i = C_{i-1} + s_i = \sum_{j=1}^i 2^j = 2^{i+1}-1 \). Siccome \(\displaystyle s_i \ge N \) per \(\displaystyle i \ge \lceil \log_2 N\rceil \) allora il costo di allocare \(\displaystyle N \) elementi sarà tra \(\displaystyle 2^{\log_2 N+1} - 1= 2N - 1 \) e \(\displaystyle 2^{\log_2 2N+1} = 4N - 1\). Lo spreco massimo è ovviamente \(\displaystyle 2N-3 \).[/*:m:7gzpppx1]
[*:7gzpppx1] Un metodo dalle caratteristiche simili consiste nel porre \(\displaystyle s_1 = 1 \), \(\displaystyle s_2 = 2 \) e \(\displaystyle s_i = s_{i-1} + s_{i-2} \). In pratica cresce usando la sequenza di Fibonacci. Cresce un po' più lentamente del raddoppio, ma ha anche sprechi inveriori. [/*:m:7gzpppx1][/list:o:7gzpppx1]
Esistono anche altre possibilità. Per esempio si potrebbe porre \(\displaystyle s_i = s_{i-1} + iK \) che cresce usando i numeri triagonali.
L'approccio da usare dipende dal problema. Nel tuo caso puoi tranquillamente usare il metodo (1) perché esistono delle buone metriche con cui puoi identificare un valore \(K\) soddisfacente.
In primo luogo puoi dividere in due il problema e identificare tutte le colonne prima di allocare la memoria per i merging. In secondo luogo, siccome i valori nel vettore finale dovranno essere tutti diversi e distanti almeno \(K\) allora il vettore finale non avrà più di \(\displaystyle\biggl\lceil \frac{\max f(M) - \min f(M)}{K}\biggl\rceil \) elementi dove \(\displaystyle f(M) \) è la matrice in cui abbiamo rimosso le righe che non soddisfano la condizione.
Supponiamo di non sapere a priori il numero \(\displaystyle N \) di elementi andremo ad allocare. Allora esistono varie tecniche:
[list=1][*:7gzpppx1] Se sappiamo che \(\displaystyle N \le K \) per un qualche \(\displaystyle K \), allora possiamo allocare direttamente \(\displaystyle K \) elementi. Il costo sarà quindi costante e uguale a \(\displaystyle K \) e il massimo spreco è pari a \(\displaystyle K-1 \) elementi (possiamo supporre che la memoria non venga allocata finché non è strettamente necessario farlo).[/*:m:7gzpppx1]
[*:7gzpppx1] Il caso opposto è quello in cui allochiamo esattamente quando serve e nulla più. Quindi si ha che \(\displaystyle s_0 = 0 \), \(\displaystyle s_i = s_{i-1}+1 = i \), \(\displaystyle C_i = C_{i-1} + s_i = \sum_{j=1}^i s_j = \sum_{j=1}^i j = \frac{i(i+1)}{2} \). Pertanto il costo di allocare \(\displaystyle N \) elementi sarà \(\displaystyle \frac{N^2 + N}{2} \). Lo spreco è ovviamente nullo.[/*:m:7gzpppx1]
[*:7gzpppx1] Similare è il caso in cui ingrandiamo la memoria allocata di un numero fisso \(\displaystyle K \) di elementi, con \(\displaystyle K \) piccolo. Si ha che \(\displaystyle s_0 = 0 \), \(\displaystyle s_i = s_{i-1}+K = iK \), \(\displaystyle C_i = C_{i-1} + s_i = \sum_{j=1}^i s_j = K\sum_{j=1}^i j = K\frac{i(i+1)}{2} \). Siccome \(\displaystyle s_i \ge N \) per \(\displaystyle i \ge \biggl\lceil \frac{N}{K} \biggr\rceil \) allora il costo di allocare \(\displaystyle N \) elementi sarà tra \(\displaystyle \frac{N^2 + KN}{2K^2} \) e \(\displaystyle \frac{(N+K)^2 + K(N+K)}{2K^2} = \frac{N^2 + 2NK^2 + K^2 + KN + K^2}{2K^2} = \frac{N^2 + 3NK^2 + 2K^2}{2K^2} \). Lo spreco massimo è ovviamente \(\displaystyle K-1 \).[/*:m:7gzpppx1]
[*:7gzpppx1] Un metodo alternativo consiste nel raddoppiare la memoria allocata ogni volta. In questo caso si ha che \(\displaystyle s_1 = 1 \), \(\displaystyle s_i = 2s_{i-1} = 2^i \), \(\displaystyle C_i = C_{i-1} + s_i = \sum_{j=1}^i 2^j = 2^{i+1}-1 \). Siccome \(\displaystyle s_i \ge N \) per \(\displaystyle i \ge \lceil \log_2 N\rceil \) allora il costo di allocare \(\displaystyle N \) elementi sarà tra \(\displaystyle 2^{\log_2 N+1} - 1= 2N - 1 \) e \(\displaystyle 2^{\log_2 2N+1} = 4N - 1\). Lo spreco massimo è ovviamente \(\displaystyle 2N-3 \).[/*:m:7gzpppx1]
[*:7gzpppx1] Un metodo dalle caratteristiche simili consiste nel porre \(\displaystyle s_1 = 1 \), \(\displaystyle s_2 = 2 \) e \(\displaystyle s_i = s_{i-1} + s_{i-2} \). In pratica cresce usando la sequenza di Fibonacci. Cresce un po' più lentamente del raddoppio, ma ha anche sprechi inveriori. [/*:m:7gzpppx1][/list:o:7gzpppx1]
Esistono anche altre possibilità. Per esempio si potrebbe porre \(\displaystyle s_i = s_{i-1} + iK \) che cresce usando i numeri triagonali.
L'approccio da usare dipende dal problema. Nel tuo caso puoi tranquillamente usare il metodo (1) perché esistono delle buone metriche con cui puoi identificare un valore \(K\) soddisfacente.
In primo luogo puoi dividere in due il problema e identificare tutte le colonne prima di allocare la memoria per i merging. In secondo luogo, siccome i valori nel vettore finale dovranno essere tutti diversi e distanti almeno \(K\) allora il vettore finale non avrà più di \(\displaystyle\biggl\lceil \frac{\max f(M) - \min f(M)}{K}\biggl\rceil \) elementi dove \(\displaystyle f(M) \) è la matrice in cui abbiamo rimosso le righe che non soddisfano la condizione.
"selfmademan":
Il mio metodo di studio mi porta ad interagire con i docenti solo dopo aver sbattuto la testa a lungo da solo e aver appreso abbastanza gli argomenti. Sono fatto strano, se qualcuno mi parla di qualcosa di complicato e io non ci ho mai ragionato prima ho difficoltà a seguire il discorso.
In questo caso ci hai tuttavia sbattuto già la testa sopra e credo che ti avrebbe permesso di comprendere meglio che cosa desidera il professore e quali errori hai commesso. Un aspetto che il tuo professore potrebbe per esempio valutare importante è quello di arrivare alla fine e non solo impostare la parte iniziale. Se fosse così dovresti probabilmente cercare di esercitarti a fare esercizi in poco tempo.. Sarebbe anche opportuno, qualora trovassi la descrizione dell'esercizio poco chiara, se chiedessi al professore spiegazioni durante l'esame. Devi alla fine dimostrare di essere in grado di scrivere programmi in C, non di leggere nella mente del tuo professore.
Se lo ritieni utile possiamo fornirti noi degli esercizi che siano meno ambigui. Un esempio potrebbe essere il seguente:
Supponiamo di aver un insieme di sensori che misurano lo stress meccanico (come singolo valore - per esempio Von Mises) in alcuni punti di un oggetto che stiamo testando. Il tuo programma deve leggere da file (o da console se i file non facevano parte del programma) i dati forniti da questi sensori e scrivere in output, per ogni sensore, gli intervalli di tempo (maggiori di 0.1s) in cui il valore registrato sia maggiore di un qualche valore fissato. Ci sono al più 10 sensori e ogni riga di input contiene il tempo corrente (in millisecondi dall'inizio della simulazione) e i valori di ogni sensore separati da spazi. Chiedi pure se hai dubbi o se vuoi un possibile esempio di input.
P.S. Ho ovviamente cercato di creare un esercizio che possa in qualche modo sembrare sensato e legato al tuo corso di studi di ingegneria meccanica piuttosto che scrivere qualcosa di astratto.
Accedi a tutti gli appunti
Tutor AI: studia meglio e in meno tempo