Java metodo EliminaDoppi

[Lo_Straniero2003i]

Salve gente. Ho questo piccolo problemino..dico piccolo perchè di sicuro lo è. Come faccio a eliminare i numeri che si presentano in un array più di una volta?

public static int[] eliminaDoppi(int [] v) {
int [] nuovo;
nuovo = new int[v.length];
int cont = 0;
for(int i= 0; i<v.length; i++)
for(int j=0; j<v.length; j++)
if(v[i]!=v[j])
nuovo[cont] = v[i];

\\ a questo punto non appena trovo la prima diversità, copio l'elemento; solo che devo terminare il secondo for...come faccio?

Grazie Gente!!!

[franksisca]

ecco a te, dovrebbe funzionare

                public static int[] eliminaDoppi(int [] v) {
               boolean flag=true;
                         int [] nuovo;
                           nuovo = new int[v.length];
                             int cont = 0;
                        for(int i= 0; i<v.length; i++) 
                           for(int j=0; j<v.length && flag; j++)
                                 if(v[i]!=v[j]){
                                    nuovo[cont] = v[i];
                                    flag=false;
                             }

[sottovento]

Ciao,
non vorrei prendere fischi per fiaschi, ma mi sembra che entrambi i codici riportati facciano qualcos'altro.
Beh, innanzitutto la variabile cont non viene mai incrementata, poi mi sarei aspettato di ottenere un array in uscita di dimensioni <= di quello in ingresso.

Forse non ho capito bene il problema, guardando il codice sembra che l'elemento attuale nel vettore di input sia copiato nel vettore di output se nel vettore di input c'e' almeno un elemento diverso da quello in oggetto.

High Flying
Sottovento

[franksisca]

Originariamente inviato da sottovento

Ciao,
non vorrei prendere fischi per fiaschi, ma mi sembra che entrambi i codici riportati facciano qualcos'altro.
Beh, innanzitutto la variabile cont non viene mai incrementata, poi mi sarei aspettato di ottenere un array in uscita di dimensioni <= di quello in ingresso.

Forse non ho capito bene il problema, guardando il codice sembra che l'elemento attuale nel vettore di input sia copiato nel vettore di output se nel vettore di input c'e' almeno un elemento diverso da quello in oggetto.

High Flying
Sottovento

pensa che io ho messo solo la flag per far uscire dal secondo for, nemmeno mi ero accorto che cont non si aumente

[Lo_Straniero2003i]

Buona idea...grazie!!!

[sottovento]

Originariamente inviato da Lo_Straniero2003i

Buona idea...grazie!!!

Mi permetto di darti un consiglio: definisci prima una funzione
int contaElementi(vect, elem)
che ti ritorna il numero di valori elem trovati nel vettore.

Poi, nel tuo ciclo principale, la richiami e salvi l'elemento se contaElementi() non e' maggiore di uno. Fai un passaggio in piu' ma mi sembra piu' chiaro

High Flying
Sottovento

[Lo_Straniero2003i]

Salve gente. Dopo un pò di pausa sono ritornato su questo problema che sinceramente non riesco a risolvere. Il metodo eliminaDoppi da me citato mi riesce più difficile di quanto previsto. Non risco a coordinare bene quello che devo fare. Sbatto sempre sul codice sopra senza arrivare mai ad una soluzione. Potreste dirmi come fare per favore?

Grazie.

Alessandro Gioffreda

[Vash1986]

import java.util.HashSet;
import java.util.Set;
import java.util.Iterator;

public class EliminaDoppi
{

	public static void main(String[] args)
	{
		int prova[] = { 1, 4, 5, 2, 4, 5, 2, 2, 1, 6, 8 };
		int prova2[] = eliminaDoppi(prova);
		
		for ( int i = 0; i < prova2.length; i++ )
			System.out.print( prova2[i] + " ");
		
		System.out.println();
		System.exit(0);
	}
	
	public static int[] eliminaDoppi( int vett[] )
	{		
		if ( vett.length < 2 )
			return vett;
		
		Set< Integer > lista = new HashSet();
		for ( int i = 0; i < vett.length; i++ )
			lista.add( new Integer(vett[i]) );
		Iterator< Integer > i = lista.iterator();
		
		/* Il primo hasNext è per forza true per via del controllo fatto a inizio
		 * metodo su vett.length.
		 */
		int res[] = new int[lista.size()];
		for ( int j = 0; i.hasNext(); j++ )
			res[j] = (int)i.next();
		
		return res;
	}
}

Un altro modo è ordinare il vettore interessato in modo da avere gli elementi doppi uno accanto all'altro e poter costruire dunque facilmente un secondo vettore.
Solo che non mi faceva usare il metodo .sort() del vettore, e piuttosto che farmi un algoritmo di ordinamento alle 0:55 di notte ho usato i Set.

Gli hashset sono strutture dati della libreria standard in cui puoi mettere qualsiasi oggetto, ma non duplicato.

[Vash1986]

Trovato il sort

import java.util.Arrays;

public class EliminaDoppi
{

	public static void main(String[] args)
	{
		int prova[] = { 1, 4, 5, 2, 4, 5, 2, 2, 1, 6, 8 };
		int prova2[] = eliminaDoppi(prova);
		
		for ( int i = 0; i < prova2.length; i++ )
			System.out.print( prova2[i] + " ");
		
		System.out.println();
		System.exit(0);
	}
	
	public static int[] eliminaDoppi( int vett[] )
	{		
		if ( vett.length < 2 )
			return vett;
		
		int res[] = new int[vett.length];
		Arrays.sort( vett );
		
		int doppi = 0;
		res[0] = vett[0];
		int j = 1;
		for ( int i = 1; i < vett.length; i++ )
		{
			if ( vett[i] != vett[i-1] )
			{
				res[j] = vett[i];
				++j;
			}
			else
				++doppi;
		}
		
		if ( doppi == 0 )
			return res;
		
		doppi = res.length - doppi;
		
		int res2[] = new int[ doppi ];
		for (int i = 0; i < doppi; i++ )
			res2[i] = res[i];
		
		return res2;
	}
}

[Lo_Straniero2003i]

Perfetto Grazie, il programma funziona. Vorrei però chiederti una cosa (scusa se ti do del tu). Non ho mai incontrato questa struttura:

Arrays.sort( vett );

Sono uno studente universitario che sta al primo anno. Ho visto che togliendolo se inserisco una sequenza di numeri, per esempio:

1,2,1,2,1,2,1,2 e così via mi ristituisce tale sequenza. Quindi questo metodo di libreria toglie le ripetizioni? E posso ommettere "Arrays.sort( vett );" e inserire al suo posto un'altro frammento codice che faccia la stessa cosa vero? Grazie mille.

[Vash1986]

Originariamente inviato da Lo_Straniero2003i

E posso ommettere "Arrays.sort( vett );" e inserire al suo posto un'altro frammento codice che faccia la stessa cosa vero? Grazie mille.

Come ho già detto, è un metodo che ordina il contenuto degli array. Funziona coi tipi primitivi e con gli oggetti che implementano l'interfaccia Comparable.

Così hai tutti i duplicati uno accanto all'altro, ed è facile riconoscerli a quel punto, basta fare un controllo sugli indici adiacenti nell'array.

Al suo posto puoi chiamare un metodo che faccia un bubble sort o un quick sort.