Algoritmo somma vettori sparsi

[xber-gigi]

algoritmo di somma di due vettori sparsi, memorizzati nel formato a coordinate. Nei test usare vettori di ordine 100, 200, 500, in cui solo il 5% degli elementi è non nullo. Generare a caso sia il valore di un elemento non nullo (un intero in 0,1,..,10) sia il suo indice. Usare la function rand() in <stdlib.h> per generare numeri casuali; per esempio, se numero_casuale è un int, la chiamata numero_casuale=rand()%11; genera un numero casuale intero (distribuzione uniforme) nell’insieme (0,1,2,..,10).

Ragazzi per favore potreste spiegarmi cosa richiede questo esercizio??? E' molto importante!!!

Ho realizzato il programma con due array creati casualmente ma mi hanno detto che non va bene in quanto devono essere vettori sparsi.
Per favore potreste aiutarmi???

[cionci]

Sparso significa che ci sono molti elemnti pari a 0... In questo caso ti da la percentuale degli elementi che devono essere diversi da zero...

In pratica fai un test sulla percentuale del 5% ed in tal caso generi un numero > 0...

[xber-gigi]

Io ho fatto nel seguente modo che ora incollo.
Mi è stato detto che non ho fatto un corretto uso del formato a coordinate e che quindi devo riprogettare completamente tutta la parte.
Per favore aiutatemi!!! Fatemi capire dove ho sbagliato!!!

#include <stdio.h>
#include <stdlib.h>

void main ()

{
int vett1[1000], vett2[1000];
int n,i,nonulli,numero_casuale,posizione,prod_scalare;
printf ("Indicare la grandezza dei vettori: ");
scanf ("%d",&n);

/* CALCOLO DEL 5% DELLA GRANDEZZA DEL VETTORE*/

nonulli = (n * 5) /100;

/* INSERISCE IL VALORE 0 AD OGNI IDICE DEL VETTORE*/

for (i=0;i<n;i++)
{
vett1[i] = 0;
}
for (i=0;i<n;i++)
{
vett2[i] = 0;
}

/* ATTRIBUISCE IN POSIZIONI CASUALI NUMERI CASUALI*/

for (i=1;i<=nonulli;i++)
{
numero_casuale=1+rand()%10;
posizione=rand()%(n-1);

/* SE LA POSIZIONE USCITA è GIà OCCUPATA DA UN INTERO, UTILIZZA LA PROSSIMA DIVERSA DA ZERO */

while (vett1[posizione]!=0)
{
posizione=(posizione+1) %n;
}

vett1[posizione]=numero_casuale;
}

for (i=1;i<=nonulli;i++)
{
numero_casuale=1+rand()%10;
posizione=rand()%(n-1);

while (vett2[posizione]!=0)
{
posizione=(posizione+1) %n ;
}

vett2[posizione]=numero_casuale;
}

/* STAMPA DEI VETTORI*/

printf ("STAMPA VETTORE NUMERO UNO\n");
for (i=0;i<n;i++)
{
printf ("%d ", vett1[i]);
}
printf ("\n\n");

printf ("STAMPA VETTORE NUMERO DUE\n");
for (i=0;i<n;i++)
{
printf ("%d ", vett2[i]);
}

[cionci]

Mi sembra che sia fatto come richiedeva il testo...ci sono però alcune cose che potevi compattare molto di più...ad esempio:

#include <stdio.h>
#include <stdlib.h>

void main ()

{
int vett1[1000], vett2[1000];
int n,i,nonulli,numero_casuale,posizione,prod_scalare;
printf ("Indicare la grandezza dei vettori: ");
scanf ("%d",&n);

/* CALCOLO DEL 5% DELLA GRANDEZZA DEL VETTORE*/

nonulli = (n * 5) /100;

/* INSERISCE IL VALORE 0 AD OGNI IDICE DEL VETTORE*/

for (i=0;i<n;i++)
vett2[i] = vett1[i] = 0;

/* ATTRIBUISCE IN POSIZIONI CASUALI NUMERI CASUALI*/

for (i=1;i<=nonulli;i++)
{
numero_casuale=1+rand()%10;
posizione=rand()%(n-1);

/* SE LA POSIZIONE USCITA è GIà OCCUPATA DA UN INTERO, UTILIZZA LA PROSSIMA DIVERSA DA ZERO */

while (vett1[posizione]!=0)
{
posizione=(posizione+1) %n;
}

vett1[posizione]=numero_casuale;

numero_casuale=1+rand()%10;
posizione=rand()%(n-1);

while (vett2[posizione]!=0)
{
posizione=(posizione+1) %n ;
}

vett2[posizione]=numero_casuale;
}

/* STAMPA DEI VETTORI*/

printf ("STAMPA VETTORE NUMERO UNO\n");
for (i=0;i<n;i++)
{
printf ("%d ", vett1[i]);
}
printf ("\n\n");

printf ("STAMPA VETTORE NUMERO DUE\n");
for (i=0;i<n;i++)
{
printf ("%d ", vett2[i]);
}
}

[cionci]

Ora che ci penso...che intende per "formato a coordinate" ?

[xber-gigi]

Per le matrici o i vettori formati per la maggiorparte da zero è preferibile usare il criterio di memorizzazione a coordinate.
Questo è formato da tre array 1D.
Il primo contiene tutti gli elementi non nulli della matrice (o vettore).
Il secondo contiene l'indice della colonna.
Il terzo contiene l'indice della riga.

[cionci]

Ah...ok... Questa cosa non l'hai fatta per niente nel tuo programma...

[xber-gigi]

Si ma cmq non so proprio come proseguire ora!!!
Come dichiaro l'array se non so quanto è lungo?!?!?
Devo immettere io la grandezza del vettore!
Brother of true metal! Help me!!!

[cionci]

Nemmeno prima sapevi quanto era lungo...eppure la dimensione l'hai data ;)

Fai lo stesso discorso di prima oppure procedi con l'allocazione dinamica che non so se hai già fatto...

[cionci]

Ah...ricordati che non hai una matrice...quindi non ti serve un vettore in meno...

[xber-gigi]

Ti rigrazio per le rispote!

Sapete per caso la formula per la somma di due vettori?!?!??

[xber-gigi]

Sono proprio in difficoltà!!!
Aiuto!!!

Ora che genero l'array con le coordinate attraverso una rand come faccio a vedere se la stessa coordinata non mi è uscita prima??? Ovvero che non mi escano due numeri uguali nello stesso array?!?!?!

Per favore help!!! Sto entrando in pallone con la testa!!!

[cionci]

Ci sono diversi modi...

1) Estrai un nuovo nume3ro fino a quando non esiste all'interno delle coordinate (soluzione non buone secondo me)

2) Estrai un numero...fai la scansione del vettore e verifichi se il numero è già presente fra le coordinate... Se è presente lo incrementi di uno (modulo N)... Riparti a fare la scansione... Così via fino a quando verifichi che il numero non è presente fra le coordinate...Ogni volta devi diminuire la qantità di numeri da cui fai l'estrazione (devi diminuire K di rand() % K + 1)...

[xber-gigi]

Non ci ho capito molto :(
che struttura interativa dovrei utilizzare???
Help!:cry:

[cionci]

Per il secondo:


numero_estratto = 1 + rand() % (N-1);


do {

for(i=0; i< quantità_estratti; ++i)
{
se vet[i] == numero_estratto allora 1 + (numero_estratto % (MAX-1));
}

} while(non ho aumentato il numero estratto);

N = N-1;

E riparti da capo...

[xber-gigi]

Dopo un intera giornata credendo di impazzire sono arrivato a questa conclusione. Credi che vada bene???
Praticamente nel momento in cui trova che il numero pescato casualmente è già nell'array, ripete l'estrazione di un nuovo numero casuale finchè questo non è diverso da quelli già presenti.
Cosa ne dici??? Cè qualche bug secondo te???

/*GENERAZIONE DELLE COORDINATE*/

for (i=0;i<nonulli;i++)
{
do
{
numero_cas = rand()%n;
y=-1;
x=0;

do
{
y=y+1
}
while (coordinate1[y]!=numero || y==nonnulli);

if (coordinate1[y] == numero_cas)
{
x=1;
}
}
while (x==1);
coordinate1[i] = numero_cas;
}

[cionci]

Sbagliato...questo potrebbe portare anche al blocco del programma... Ti ho scritto sopra cosa fare... C'è qualcosa che non ti torna ?

[xber-gigi]

Ok sono riuscito a creare le coordinate.
Ma ora la somma?
Come sommo i due array?

[xber-gigi]

Pensavo che devo lavorare anche sulle coordinate del risultato?!?
Questi maledetti vettori a coordinate mi stanno facendo impazzire!!!
Lo avevo già fatto utilizzando due vettori incizzati normalmente e ci avevo messo 5 minuti a realizzarlo!!!

[cionci]

Allora...per la somma è semplice...

Copia il contenuto del vettore "uno" nel vettore del risultato (fai una copia elemento per elemento dei dati e delle coordinate)...

Comincia a scorrere il vettore "due"... Per ogni elemento delle coordinate del vettore "due": se la coordinata in questione esiste anche nelle coordinate del risultato allora somma il dato corrispondente del vettore "due" al dato corrispondente alla stessa cooridinata nel vettore del risultato...altrimenti aggiungi una nuova coordinata e un nuovo dato al risultato...

[xber-gigi]

Credi che così vada bene?!?!?

for (i=0;i<grandezzavett;i++)
{
risultato[i]=vett1[i];
coordinate1[i]=coordinater[i];
}
k=-1;
y=1;
for (i=0;i<grandezzavett;i++)
{
do
{
k=k+1;
}
while (coordinate2[k]==coordinater[k] || k==grandezzavett);
if (coordinate2[k]==coordinater[k])
{
risultato[k]=risultato[k]+vett2[k];
}
else
{
coordinater[grandezzavett+y]=coordinate2[k];
risultato[grandezzavett+y]=vett2[k];
y=y+1;
}
}

[cionci]

Se funziona va bene ;) Devi provare da solo, altrimenti non impari niente...

[xber-gigi]

E' che il programma è talmente incasinato che avvolte è difficile trovare l'errore!!! E come se non bastasse devo assolutamente finirlo per domenica :(
Ma grazie al tuo aiuto sebra che stia ad un buon punto ;)

[cionci]

E' sbagliata la condizione di terminazione del while ;)

[xber-gigi]

Perchè??!?!
Continua il "do" finchè non ne trova uno uguale o finchè non ha finito si controlalre tutto l'harray. :confused:
dovè l'errore???!?!?

[/\/\@®¢Ø]

Non vorrei sbagliarmi, ma nel formato sparso gli elementi non sono ordinati comunque per colonna e per riga ? :confused:
In tal caso dovresti scorrere i due vettori parallelamente, prendendo sempre il valore di indice piu' piccolo (e sommando quando coincidono).

[cionci]

Appunto... Il programma esegue il ciclo fino a quando la condizione del ciclo è vera... Quella condizione andrebbe negata ;)

coordinate2[k]!=coordinater[k] && k<=grandezzavett

Appena uno dei due diventa falso esce dal ciclo...

[cionci]

Originariamente inviato da /\/\@®¢Ø
Non vorrei sbagliarmi, ma nel formato sparso gli elementi non sono ordinati comunque per colonna e per riga ? :confused:
Sinceramente non lo so... Sicuramente avendoli ordinati per coordinata risulterebbe più semplice farci le operazioni sopra...

[/\/\@®¢Ø]

Originariamente inviato da cionci
Sinceramente non lo so... Sicuramente avendoli ordinati per coordinata risulterebbe più semplice farci le operazioni sopra...
Quelle (poche) volte che che ho lavorato con le matrici sparse io si faceva cosi', tra l'altro avrebbe anche poco senso dal punto di vista delle prestazioni fare diversamente.

[a2000.1]

basta poco che ce vo' :)


Const iMax = 500, kMax = 0.05 * iMax
Type tipoVett
i() As Integer
x() As Double
kk As Integer
End Type

Function f_GeneraVett(kk) As tipoVett
Dim v As tipoVett
ReDim v.i(1 To kk), v.x(1 To kk)
v.kk = kk
i = 0
For k = 1 To kk
i = i + Rnd() * 19 + 1
v.i(k) = i
v.x(k) = Rnd() * 9 + 1
Next k
xx = iMax / (i + Rnd() * 19 + 1)
For k = 1 To kk
v.i(k) = xx * v.i(k)
Next k
f_GeneraVett = v
End Function


Function f_SommaVett(v1 As tipoVett, v2 As tipoVett) As tipoVett
Dim v3 As tipoVett
v3.kk = v1.kk + v2.kk
ReDim v3.i(1 To v3.kk), v3.x(1 To v3.kk)
k1 = 1: k2 = 1
For k3 = 1 To v3.kk
s = Sgn(v2.i(k2) - v1.i(k1))
w1 = (s >= 0) * (k1 < v1.kk)
w2 = (s <= 0) * (k2 < v2.kk)
If w1 + w2 = 0 Then Exit For
v3.i(k3) = w1 * v1.i(k1) + w2 * (w2 - w1) * v2.i(k2)
v3.x(k3) = w1 * v1.x(k1) + w2 * v2.x(k2)
k1 = k1 + w1: k2 = k2 + w2
Next k3
v3.kk = k3 - 1
ReDim Preserve v3.i(1 To v3.kk), v3.x(1 To v3.kk)
f_SommaVett = v3
End Function


e sempre belli ordinati come piacciono a /\/\@®¢Ø
:cool:

[cionci]

a2000...siamo buoni tutti a farlo... Non è che ci sono problemi...ma cerchiamo di far imparare xber-gigi...meno male che non l'hai scritta in C ;)

[xber-gigi]

RAGAZZI VI PREGO AIUTATEMI STO IMPAZZENDO!!!
Ecco quanto ricavato finora! Devo finirlo entro lunedì!!!
Per favore helppp!!!

:cry: :cry: :cry: ammesso che sia fatto bene :(((
Come procedo con la stampa?!?!?!?
Aiuto!!!
:(


#include <stdio.h>
#include <stdlib.h>
void sommavett (int vett1[], int vett2[], int coordinate1[], int coordinate2[], int nonulli, int n_risul);

void stampa (int a[], int n);

/*-------------------------------------------------------------------------------------------------------------------*/
/*PROGRAMMA PRINCIPALE - la variabile n è la grandezza del vettore*/

void main ()
{
int vett1[1000], vett2[1000], coordinate1[1000], coordinate2[1000],risultato[1000], coordinater[1000];
int n,i,x,y,nonulli,n_risul, numero_cas;
printf ("Indicare la grandezza dei vettori: ");
scanf ("%d",&n);

/* CALCOLO DEL 5% DELLA GRANDEZZA DEL VETTORE*/

nonulli = (n * 5) /100;

/*GENERAZIONE DEI VALORI DEL VETTORE*/

for (i=0;i<nonulli;i++)
{
vett1[i]=1+rand()%10;
}

/*GENERAZIONE DELLE COORDINATE PRIMO VETTORE*/

for (i=0;i<nonulli;i++)
{
do
{
numero_cas = rand()%n;
y=-1;
x=0;

do
{
y=y+1;
}
while (coordinate1[y]!=numero_cas || y==nonulli);

if (coordinate1[y] == numero_cas)
{
x=1;
}
}
while (x==1);
coordinate1[i] = numero_cas;
}

/*GENERAZIONE DELLE COORDINATE SECONDO VETTORE*/


for (i=0;i<nonulli;i++)
{
do
{
numero_cas = rand()%n;
y=-1;
x=0;

do
{
y=y+1 ;
}
while (coordinate2[y]!=numero_cas || y==nonulli);

if (coordinate2[y] == numero_cas)
{
x=1;
}
}
while (x==1);
coordinate2[i] = numero_cas;
}

sommavett (vett1, vett2, coordinate1, coordinate2, nonulli, risultato, coordinater, n_risul);

stampa (vett1,n);
stampa (vett2,n);
stampa (risultato,n);




}





/*-------------------------------------------------------------------------------------------------------------------*/
/*PROCEDURA CALCOLO SOMMA VETTORI*/

void sommavett (int vett1[], int vett2[], int coordinate1[], int coordinate2[], int nonulli, int risultato[], int coordinater[], int n_risul)
{

int i,k,y;
for (i=0;i<nonulli;i++)
{
risultato[i]=vett1[i];
coordinate1[i]=coordinater[i];
}
k=-1;
y=1;
for (i=0;i<nonulli;i++)
{
do
{
k=k+1;
}
while (coordinate2[k]==coordinater[k] || k==nonulli);
if (coordinate2[k]==coordinater[k])
{
risultato[k]=risultato[k]+vett2[k];
}
else
{
coordinater[nonulli+y]=coordinate2[k];
risultato[nonulli+y]=vett2[k];
y=y+1;
}
}
n_risul=nonulli+y;
}



/*-------------------------------------------------------------------------------------------------------------------*/
/*PROCEDURA STAMPA ARRAY*/

void stampa (int a[], int n)
{
int i;
for (i=0;i<n;i++)
{
if

[a2000.1]

Originariamente inviato da cionci
a2000...siamo buoni tutti a farlo... Non è che ci sono problemi...ma cerchiamo di far imparare xber-gigi...meno male che non l'hai scritta in C ;)

a fare il copia-incolla da qualche ricettario forse :D

[a2000.1]

poi bisogna vedere in quante righe, quanto corre, quanta memoria vuole che è poi lo spirito dell'esercizio visto che richiede una struttura dati per la minimizzazione delle risorse di memoria.

... solo ghirigori e la sostanza si copia freeware :D

[cionci]

xber-gigi: come sugerito sopra...ordina i due vettori dopo l'inserimento... Ti riesce ?

[a2000.1]

ehhh con l'ordinamento a bolla impazzisce :D :D


xibergigi se proprio vuoi fare uno short-cut fatti due function "preventive"

f_PutValore(v(), i, x)
f_GetValore(v(), i, x)

e ti riporti al caso del vettore standard. ;)

[cionci]

Originariamente inviato da a2000.1
e ti riporti al caso del vettore standard. ;)
Questo è un ottimo suggerimento...

[a2000.1]

bravo, tutto quello che sa di "classe" ( ;) ) ti piace eh :D

[xber-gigi]

Non ci sto capendo più niente !!!:cry:
sto impazzendo sto da questa mattina davanti a questo maledetto programma!!!
Ora mi devo bloccare alla stampa!!! :cry: :cry: :muro: :muro:

[xber-gigi]

Essendo i valori tutti numeri random mi basta ordinare solo l'array delle coordinate ! Quindi basta semplicemente utilizzare un algoritmo di ordinamento per selezione! giusto!?!?
forse ci sto arrivando...

[cionci]

Giusto...qualsiasi algoritmo di ordinamento sulle coordinate va bene...

A questo punto anche la stampa è più semplice (non stampare gli elementi nulli)...

[xber-gigi]

ECCO FINITO!!!
Però mi da un mare di errori!!! :(
Non capisco di cosa si tratta! Potresti vedere tu ?!?!
Dice che cè un errore nelle variabili che ho usato per le procedure
ma non capisco cosa?!??!?
Il programma dovrebbe essere finito, dovrei solo aggiustare questi errori che non capisco cosa siano.
Cmq grazie mille per l'aiuto che mi stai dando!

SIAMO BROTHERS OF METAL!!!
;)


#include <stdio.h>
#include <stdlib.h>
void sommavett (int *vett1[], int *vett2[], int *coordinate1[], int *coordinate2[], int *nonulli, int *n_risul);
void insertion_sort (int *a[],int *b);

/*-------------------------------------------------------------------------------------------------------------------*/
/*PROGRAMMA PRINCIPALE - la variabile n è la grandezza del vettore*/

void main ()
{
int vett1[1000], vett2[1000], coordinate1[1000], coordinate2[1000],risultato[1000], coordinater[1000];
int n,i,x,y,a,b,nonulli,n_risul, numero_cas;
printf ("Indicare la grandezza dei vettori: ");
scanf ("%d",&n);

/* CALCOLO DEL 5% DELLA GRANDEZZA DEL VETTORE*/

nonulli = (n * 5) /100;

/*GENERAZIONE DEI VALORI DEL VETTORE*/

for (i=0;i<nonulli;i++)
{
vett1[i]=1+rand()%10;
}

/*GENERAZIONE DELLE COORDINATE PRIMO VETTORE*/

for (i=0;i<nonulli;i++)
{
do
{
numero_cas = rand()%n;
y=-1;
x=0;

do
{
y=y+1;
}
while (coordinate1[y]!=numero_cas || y==nonulli);

if (coordinate1[y] == numero_cas)
{
x=1;
}
}
while (x==1);
coordinate1[i] = numero_cas;
}

/*GENERAZIONE DELLE COORDINATE SECONDO VETTORE*/


for (i=0;i<nonulli;i++)
{
do
{
numero_cas = rand()%n;
y=-1;
x=0;

do
{
y=y+1 ;
}
while (coordinate2[y]!=numero_cas || y==nonulli);

if (coordinate2[y] == numero_cas)
{
x=1;
}
}
while (x==1);
coordinate2[i] = numero_cas;
}



insertion_sort (&coordinate1, &nonulli);
coordinate1 = a;
insertion_sort (&coordinate2, &nonulli);
coordinate2 = a;
insertion_sort (&coordinater, &n_risul);
coordinater = a;

sommavett (&vett1, &vett2, &coordinate1, &coordinate2, &nonulli, &risultato, &coordinater, &n_risul);

/*STAMPA VETTORE 1*/
for (i=0;i<n;i++)
{
vett1[i];
}

/*STAMPA VETTORE 2*/
for (i=0;i<n;i++)
{
vett2[i];
}

/*STAMPA RISULTATO*/
for (i=0;i<n_risul;i++)
{
risultato[i];
}



}





/*-------------------------------------------------------------------------------------------------------------------*/
/*PROCEDURA CALCOLO SOMMA VETTORI*/

void sommavett (int *vett1[], int *vett2[], int *coordinate1[], int *coordinate2[], int *nonulli, int *n_risul)
{

int i,k,y;
for (i=0;i<nonulli;i++)
{
risultato[i]=vett1[i];
coordinate1[i]=coordinater[i];
}
k=-1;
y=1;
for (i=0;i<nonulli;i++)
{
do
{
k=k+1;
}
while (coordinate2[k]==coordinater[k] || k==nonulli);
if (coordinate2[k]==coordinater[k])
{
risultato[k]=risultato[k]+vett2[k];
}
else
{
coordinater[nonulli+y]=coordinate2[k];
risultato[nonulli+y]=vett2[k];
y=y+1;
}
}
n_risul=nonulli+y;
}


/*-------------------------------------------------------------------------------------------------------------------*/
/*PROCEDURA ORDINAMENTO ARRAY COORDINATE*/

void insertion_sort (int *a[],int *b)
{
int i,j;
int el_da_ins;
for (i=1;i<b;i++)
{
el_da_ins=a[i];
j=i-1;
while (j>=0 && el_da_ins<a[j])
{
a[j+1]=a[j];
j=j-1;
}
a[j+1]=el_da_ins;
}
}

[cionci]

E' sbagliato il modo in cui generi le coordinate...
Il fatto che i vettori siano ordinati ti può permettere di usare un metodo molto più semplice per sommarli...

L'estrazione delle coordinate te la faccio io vai...però cerca di capirla...

Erano sbagliate tutte le dichiarazioni delle funzioni... Non devi passare i vettori per indirizzo... L'unico parametro che devi passare per indirizzo è n_risult...

Inoltre hai capito male come devi realizzare il vettore delle coordinate... Il vetore delle coordinate è un vettore compatto...

Quindi se ci sono 4 valori non nulli il vettore delle coordinate deve contenere solo 4 valori in sequenza...

[cionci]

Prova questo:

popola_vettori(vett1, coordinate1, nonulli, n);
popola_vettori(vett2, coordinate2, nonulli, n);

/*STAMPA VETTORE 1*/
for (i=0;i<nonulli;i++)
{
printf("vett[%d] = %d\n", coordinate1[i], vett1[i]);
}

for (i=0;i<nonulli;i++)
{
printf("vett[%d] = %d\n", coordinate2[i], vett2[i]);
}



void popola_vettori(int vett[], int coord[], int nonnulli, int n)
{
int i, x, j, k, tmp1, tmp2, tmp3, tmp4;
/*INIZIALIZZO LE COORDINATE*/
for(i=0; i<nonnulli; ++i)
coord[i] = -1;

/*GENERAZIONE DELLE COORDINATE E DEI VALORI DEL VETTORE*/

for(i=0; i<nonnulli; ++i)
{
x = rand() % (n-i); /*la popolazione da cui estrarre diminuisce sempre*/
/*equivale ad una estrazione senza reinbussolamento*/
j=0;
while(coord[j] <= x && coord[j] > -1)
{
x++; /*incremento x per evitare coord già estratte*/
++j;
}

/*controllo se la posizione è già occupata*/
/*in tal caso devo spostare a destra gli elementi restanti*/
if(coord[j] != -1)
{
tmp1 = coord[j];
tmp2 = vett[j];
for(k=j+1; k<=i; ++k)
{
tmp3 = coord[k];
tmp4 = vett[k];
coord[k] = tmp1;
vett[k] = tmp2;
tmp1 = tmp3;
tmp2 = tmp4;
}
}
/*ora posso inserire il mio elemento*/
coord[j] = x;
vett[j] = 1 + rand() % 10; /*metto anche il dato nella posizione corrispondente*/
}
}