[Java] sottrazione di ogni elemento dell'array

[oronze]

Ciao, allora, io ho la necessità che, dato un array riempito con 3 valori, mi esegua la differenza del
val[0]-val[1]
val[0]-val[2]
val[1]-val[2]
e che me la salvi in un nuovo vettore

for(int i=0; i<n; i++){
	for(int x=i+1; x<n; x++){
		double sott = Math.abs(punti[i]-punti[x]);
		sottr[puntatore] = sott;
		puntatore++;
}
}

il problema è che mi pare moooooolto macchinoso e che non capisco perchè mi segni errore alla fine del ciclo:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 9 at ax.main(max.java:47)
Chi mi delucida?

[LeleFT]

Mi pare ovvio... il tuo array dovrà avere ( n! / (2*(n-2)!) ) elementi (il perchè non è complesso: si tratta del numero di combinazione senza ripetizioni degli elementi). In quel ciclo for innestato, invece, tu aggiungi 1 alla variabile "puntatore" esattamente N * (N-1) volte... che è più di quanto ci si aspetta (nell'esempio che hai indicato, tu hai un array di 3 elementi (3! / 2*(3-2)!), mentre tu aggiungi 1 alla variabile esattamente 3 * (3-1) = 6 volte...


Ciao.

[oronze]

e quindi come dovrei scrivere il codice?
Ti ringrazio infinitamente

[simo7784]

A me il for sembra ok. Il secondo ciclo parte correttamente da i+1 e quindi esegue esattamente 2+1 iterazioni che e' il numero necessario per cio' che vuoi fare tu. Naturalmente affinche cio' sia vero, le variabili devono essere correttamente settate e cioe' puntatore=0, n=3 e sottr[]= new sottr[3]. Se le variabili sono settate corretamente,il problema sta da un'altra parte. (Per curiosita', qual'e' di preciso la riga 47 segnalata nell'eccezione?)

[R@ve M@ster]

E' ovvio che dia quella eccezione. Quando i raggiunge il suo ultimo valore possibile e poni x=i+1, quando fai punti[x] tenti di accedere ad un valore oltre la dimensione dell'array. devi fermare il primo ciclo a n-1.

[simo7784]

Teoricamente non dovrebbe entrare nel for.
L'ultimo valore possibile e' n-1, x diventa n e non entra nel for interno.

[R@ve M@ster]

giusto...m'ero scordato il secondo for

[LeleFT]

E' il secondo for che va in errore.
Nell'ultimo ciclo esterno i punterà all'ultima posizione utile nell'array (se N vale 3, allora i vale 2 e punti[2] è l'ultima posizione utile). Nel secondo for, la prima cosa che fa è valorizzare x come i + 1 e questo genera l'errore (punti[2] - punti[3], ma punti è un array di 3 elementi e non esiste punti[3]!).

La soluzione del problema consiste semplicemente di aggiungere un -1 nel primo for:

for(int i=0; i<n-1; i++){
	for(int x=i+1; x<n; x++){
		double sott = Math.abs(punti[i]-punti[x]);
		sottr[puntatore] = sott;
		puntatore++;
}
}

Ed è la soluzione corretta: per tutti i valori dell'array tranne l'ultimo, effettua la differenza fra il valore e tutti i suoi successivi (tranne l'ultimo perchè non ha alcun successivo).


Ciao.

[oronze]

che stupido che sono! ho capito la tua spiegazione ed era anche abbastanza ovvia, solo che come me l'hai scritta la prima volta non la capivo

[simo7784]

Ma ora ti va? Perche'

for(int i=0; i<n; i++){
	for(int x=i+1; x<n; x++){
		double sott = Math.abs(punti[i]-punti[x]);
		sottr[puntatore] = sott;
		puntatore++;
        }
}

All'ultimo giro, i=2. Entro nel for interno, x=i+1=2+1=3. Controllo la guardia, 3<3 è falso. Esco dal for interno. Torno all'inizio del for esterno i=i+1=3. Controllo la guardia, 3<3 è falso. Esco dal for esterno e vado avanti con il programma.
Ora, va benissimo mettere n-1 nel ciclo for esterno, in qesto modo risparmi 2 controlli, ma dal punto di vista del risultato finale non cambia niente, perche' la passata di for interno in cui accedi a punti[3] non verra' mai fatta.
Ad esempio la classe sotto fa la stessa cosa(ho fatto copia e incolla del for) ma non solleva nessuna eccezione.

public class ArrayTest {
    public static void main(String args[]) {
        int[] punti = {3,2,1};
        int n = punti.length;
        double[] sottr = new double[3]; //3 = 3!/(2*(3-2))
        int puntatore = 0;
        for(int i=0; i<n; i++){
            for(int x=i+1; x<n; x++){
                double sott = Math.abs(punti[i]-punti[x]);
                sottr[puntatore] = sott;
                puntatore++;
            }
        }
        for(int i=0; i<puntatore; i++) {
            System.out.println(sottr[i]);
        }
    }   
}

Inoltre l'eccezione che hai postato dice:

java.lang.ArrayIndexOutOfBoundsException: 9

cioe' in qualche parte del codice (riga 47) stai cercando di accedere alla posizione 9 dell'array. Ora siccome, se n=3, non arrivi mai alla posizione 9, mi viene il dubbio che l'errore non sia in questo punto.