[JAVA] Aiuto per newbie

[Manugal]

Chi gentilmente potrebbe scrivermi questi tre metodi (con dei commenti vicino)? Mi servono per l'Università grazie mille



1. Scrivere un metodo statico

static int[] rimuoviDuplicati (int[] A)

che restituisce un nuovo array ottenuto dall’array A rimuovendo tutti i duplicati.

2. Scrivere un metodo statico

static boolean arrayUguali(int[] A,int[] B)

che restituisce true se gli array A e B sono uguali (cioè hanno tutti gli elementi corrispondenti uguali), e false altrimenti.

3. Scrivere un metodo

static boolean stessiElementi(int[] A, int[] B)

che restituisce true se gli array A e B contengono gli stessi elementi e false altrimenti.

[misterx]

di primo acchito non mi sembrano difficili neanche per te

butta giù due righe di codice che poi le correggiamo insieme

[Manugal]

Il problema è che non so molto bene come operare sugli array. Per esempio in questi casi semplici.

Ad esempio provo a fare il secondo

public static boolean arrayUguali (int[] a, int[] b){
for (int i=0; i<a.length; i++){
if (a[i]==b[i]){
......
ecco per esempio qua non saprei dove mettere il return. Perché se lo metto subito dopo la condizione, quando vado a compilare naturalmente mi dice che manca appunto il return.

[anx721]

Attento che cosi facendo non realzzi correttamente il metodo, perchè se controlli l'uguaglianza devi comunque scorrere tutto l'array e non ritornare appena trovi due elementi uguali.

Alternativamente puoi controllare la disuguaglianza tra due elementi e quindi ritornare false appena trovi una coppia di elementi diversi.

Inoltre tieni presente che

o1 == o2 è true se o1 e o2 sono lo stesso oggetto

o1.equals(o2) è true se o1 e o2 sono uguali, cioè hanno lo stesso valore, ma possono anche essere oggetti diversi.

[gabriele81]

Non ho capito bene la differenza tra il secondo ed il terzo metodo...nel secondo gli elementi devono essere gli stessi nelle stesse posizioni, mentre nel terzo devono essere gli stessi elementi ma possono essere in posizioni diverse, è così?

Se ho capito bene per il secondo metodo puoi fare

public static boolean arrayUguali (int[] a, int[] b){ 
    if (a.length != b.length) return false;
    boolean b = true;
    for (int i=0; i<a.length; i++){
        if (a[i]!=b[i]){
            b = false;
            break;
        }
    }
    return b;
}

In pratica prima confronta la lunghezza degli array, se sono diverse ritorna subito false perchè non possono essere uguali, altrimenti comincia a scorrerli e appena trova un elemento diverso si ferma il ciclo e ritorna false, se invece non ne trova diversi torna true.

Quello che ha detto anx721 sull'equals e sull'operatore == è vero, però se devi lavorare su array di interi non ci devi fare caso perchè gli int non sono oggetti ma tipi primitivi su cui vale solo l'uguaglianza di valore (==).

[anx721]

attenzione ai nomi delle variabili locali...

[gabriele81]

Originariamente inviato da anx721
attenzione ai nomi delle variabili locali...

oooooops non me ne ero accorto.....

la variabile booleana va chiamata in un altro modo perchè già un array si chiama b.

[cn73]

Originariamente inviato da Manugal
Il problema è che non so molto bene come operare sugli array. Per esempio in questi casi semplici.

Ad esempio provo a fare il secondo

public static boolean arrayUguali (int[] a, int[] b){
for (int i=0; i<a.length; i++){
if (a[i]==b[i]){
......
ecco per esempio qua non saprei dove mettere il return. Perché se lo metto subito dopo la condizione, quando vado a compilare naturalmente mi dice che manca appunto il return.

Quando vedo post come il tuo non resisto...mi devi scusare, ma che cavolo di risposta è?? Fatemi questi 3 metodi grazie 1000 io non sono capace... Sei un Universitario no? Vorrai guadagnare 5000 euro al mese fra qualche anno no?? Ti metti e studi... a questo serve l'Università. Ad imparare.

Puoi provare a stendere del codice, anche stupido e sbagliato, poi possiamo intervenire e aiutarti.

Nell'esempio da te citato ti dice che manca il ritorno di un valore, perchè tu dichiari un metodo Boolean e il compilatore pretnde che alla fine del metodo tu gli restituisca un boolean

public static boolean arrayUguali (int[] a, int[] b){
     if (a.length != b.length)
       return false; //che senso ha un controllo di uguaglianza su 2 array di lunghezza diversa?
     for (int i=0; i<a.length; i++){
           if (a[i]!=b[i])
                return false;
    }
 return true;
}

[Manugal]

Quando vedo post come il tuo non resisto...mi devi scusare, ma che cavolo di risposta è?? Fatemi questi 3 metodi grazie 1000 io non sono capace... Sei un Universitario no? Vorrai guadagnare 5000 euro al mese fra qualche anno no?? Ti metti e studi... a questo serve l'Università. Ad imparare.

Lo so hai perfettamente ragione. Però il mio problema è che non ancora non sono bene entrato nella logica. Senza contare che questo è il mio primo linguaggio di programmazione che faccio.

Cmq grazie a tutti per l'aiuto.

[cn73]

Tu chiedi in un certo modo e qui troverai tutto l'aiuto possibile

[anx721]

Originariamente inviato da cn73
Tu chiedi in un certo modo e qui troverai tutto l'aiuto possibile

Concordo in tutto con cn73, se vedi questi tre metodi già risolti forse li capirai, ma non avrai capito perchè sono fatti in un certo modo, se fai delle prove e sbagli e chiedi poi perchè non funzionano qlcosa capisci.

[PGI]

Originariamente inviato da Manugal
1. Scrivere un metodo statico

static int[] rimuoviDuplicati (int[] A)

che restituisce un nuovo array ottenuto dall’array A rimuovendo tutti i duplicati.

2. Scrivere un metodo statico

static boolean arrayUguali(int[] A,int[] B)

che restituisce true se gli array A e B sono uguali (cioè hanno tutti gli elementi corrispondenti uguali), e false altrimenti.

3. Scrivere un metodo

static boolean stessiElementi(int[] A, int[] B)

che restituisce true se gli array A e B contengono gli stessi elementi e false altrimenti.

1 Sono certo che esista un algoritmo più elegante, più efficiente, più...più insomma.
I miei neuroni (stanchi) hanno prodotto quel che segue:

	static int[] rimuoviDuplicati(int[] arrayA) {
		int[] indiciDuplicati = new int[arrayA.length];
		int limiteIndiciDuplicati = 0;
		
		for(int i = 0; i < arrayA.length - 1; i++) {
			int elemento = arrayA[i];
			
			for(int j = (i + 1); j < arrayA.length; j++) {
				if(arrayA[j] == elemento) {
					//duplicato
					indiciDuplicati[limiteIndiciDuplicati] = j;
					limiteIndiciDuplicati++;
				}
			}
		}
		
		int[] nuovoArray = new int[arrayA.length - limiteIndiciDuplicati];
		
		int indiceNuovoArray = 0;
		for(int i = 0; i < arrayA.length; i++) {
			
			boolean add = true;
			
			for(int j = 0; j < limiteIndiciDuplicati; j++) {
				if(i == indiciDuplicati[j]) {
					add = false;
				}
			}
			
			if(add) {
				nuovoArray[indiceNuovoArray] = arrayA[i];
				indiceNuovoArray++;
			}
		}
		
		return nuovoArray;
	}

L'ho testato con un solo array, ma la teoria non dovrebbe essere bizzarra.

2 Qui non dovrebbe essere nulla di trascendentale.

	static boolean arrayUguali(int[] arrayA, int[] arrayB) {
		boolean answer = (arrayA.length == arrayB.length);
		int index = 0;
		while(answer && index < arrayA.length) {
			answer = arrayA[index] == arrayB[index];
			index++;
		}
		return answer;
	}

Per il 3° credo ci sia bisogno di un chiarimento.

Bisogna capire cosa significhi "stessi elementi".

Due array che contengono gli stessi numeri in posizioni diverse hanno gli stessi elementi.

Ma un array che contenga una certa quantità di duplicati ha gli stessi elementi di un array che contenga gli stessi numeri senza duplicati?

Ad esempio:

1 2 3 4 5 6 6 6 6

ha gli stessi "elementi" di

6 5 4 3 2 1

?

[cn73]

PGI hai notato che se gli passiamo 2 array vuoti i metodi da noi proposti restituiscono true? E' corretto?

[anx721]

Originariamente inviato da cn73
PGI hai notato che se gli passiamo 2 array vuoti i metodi da noi proposti restituiscono true? E' corretto?

Certo che è corretto.

[PGI]

Originariamente inviato da cn73
PGI hai notato che se gli passiamo 2 array vuoti i metodi da noi proposti restituiscono true? E' corretto?

In tutta sincerità, non avevo pensato al caso "array vuoti".

Mi sembra comunque corretto quanto dice anx721, in fondo due array vuoti sono pur sempre "uguali" dal punto di vista del contenuto.

[misterx]

ho fatto anch'io un esperimento come ripasso

ulteriori controlli mettili tu

    static int[] Duplicati(int[] ArrayDup) {
        
        ArrayList lista = new ArrayList();       
        
            for (int i = 0; i < ArrayDup.length; i++){
                
                Integer t = new Integer(ArrayDup[i]);
                
                if( !lista.contains(t) )
                    lista.add(t);
            }    
        
        int i = 0;

        int[] array = new int[lista.size()];

        Iterator iter = lista.iterator();

         while (iter.hasNext())
            array[i++] = Integer.parseInt(iter.next().toString());
        
        
        return array;  
    }