[Java] Ripetizione numeri in un array

[Crodreamer]

Ciao a tutti, questo è il mio primo messaggio e ovviamente scrivo perchè ho qualche problemuccio, ovviamente semplicissimo per chi programma in java da piu' tempo di me (ho iniziato da 3 settimane, quindi perdonate la banalita' della mia richiesta)

Il mio problema è questo:

devo creare un metodo che mi controlli se all'interno di un array bidimensionale di interi ci sono interi ripetuti, e che restituisca un booleano di conseguenza.
Ci sto lavorando da un po', ma non ne ricavo nulla

Qualcuno puo' essere cosi' gentile da postarmi il codice di questo metodo?

[VincenzoTheBest]

Posta quello che hai fatto fin'ora...

[Crodreamer]

Eheh, come ho già scritto sono mooolto alle prime armi, e sono completamente bloccato nello sviluppo di un programma a questo punto.

Speravo che qualcuno potesse realizzare quel semplice metodo partendo da quei dati. Io non so nemmeno da dove iniziare , quindi non ho ancora fatto nulla di minimamente valutabile, solo tentativi inconcludenti, che non vale la pena nemmeno postare.

Anche qualche suggerimento mi può tornare utile

[VincenzoTheBest]

Suggerimenti:

1) Dichiara una variabile booleana RISULTATO ed impostala su 'false' (il valore di questa variabile verrà restituito dal metodo);
2) Dichiara una seconda variabile booleana FLAG ed impostala su 'false' (serve per fissare la condizione di terminazione del ciclo di scansione dell'array, nel caso vengano trovati elementi uguali);
3) Dichiara la variabile i inizializzata a 0 (indicizza le righe dell'array) e dichiara la variabile j inizializzata a 0 (indicizza le colonne dell'array);
3) fissa come condizione del ciclo di scansione l'OR logico che verifichi le dimensioni dell'indice di scansione e lo stato della variabile booleana FLAG.
4) Nel ciclo ogni elemento viene confrontato con tutti gli altri (questo ciclo è annidato nel primo).
5) Se nel ciclo l'elemento considerato risulta essere uguale ad un altro elemento, termina il ciclo impostando FLAG su 'true' ed imposta anche RISULTATO su 'true'

[Crodreamer]

Grazie mille per l'aiuto!!

Ho capito quello che dovrei fare, ma mi rimane ancora un problema: come è fatto il ciclo in cui ogni elemento viene confrontato con tutti gli altri?

P.S. Grazie per la pazienza

[VincenzoTheBest]

Ti posto un esempio che ho fatto nel main (NON E' UNA FUNZIONE)!
Puntualizzo che la mia soluzione usa un array monodimensionale di appoggio per verificare gli elementi dell'array bidimensionale

/**
 * @(#)MatriceBid.java
 *
 *
 * @author VincenzoTheBest
 * @version 1.00 2008/2/17
 */

import java.util.*;

public class MatriceBid 
{
	public static void main(String[] args)
	{
		int righe = 2;
		int colonne = 2;		
		int[][] array = new int[righe][colonne];
		
		int[] arrayAppoggio = new int[righe+colonne];
		
		Scanner input = new Scanner(System.in);
		int valore;
		
		for(int i=0; i<righe; i++)
		{
			for(int j=0; j<colonne; j++)
			{
				System.out.print("Posizione "+i+"."+j+": ");
				valore = input.nextInt();
				array[i][j] = valore;
			}
		}
		
		System.out.println();
		
		
		// Stampa
		int c = 0;
		System.out.println("ELEMENTI DELL'ARRAY BIDIMENSIONALE\n");
			
		for(int i=0; i<righe; i++)
		{
			for(int j=0; j<colonne; j++)
			{
				System.out.print(array[i][j]+" "); // Visualizza elementi
				
				arrayAppoggio[c] = array[i][j]; // Copio gli elementi nell'array di appoggio
				c++;
			}
			
			System.out.println("\n");
		}
		
		// Verifica elementi uguali
		int elemento, altro;
		boolean flag = false;
		int j = 0;
		int i = 0;
		c = 0;
		int k = 0;
		
		while(i<righe)
		{
			while(j<colonne)
			{
				elemento = array[i][j];
				c = i+j;
				
				while(k<c)
				{
					if(elemento==arrayAppoggio[k])
					{
						flag = true;
					}
					
					k++;
				}
				
				j++;
				k = 0;
			}
			
			i++;
			j=0;
		}
		
		
		if(flag==true)
			System.out.print("Ci sono elementi uguali");
		else
			System.out.print("NON Ci sono elementi uguali");
		
		
	}    
}

[Crodreamer]

Ti posto quello che ho ricavato da cio' che hai fatto tu ( è un metodo che poi richiamo nel main, per semplicita' ho considerato solo matrici quadrate)

    public static boolean numeriRipetuti (int [][] m, int lato)
    {
    	boolean ripetuti = false;
    	int elemento;
	boolean flag = false;
	int c = 0;
	int k = 0;
	int[] arrayAppoggio = new int[lato*lato];
	for(int i = 0; i < lato; i++)
		{
			for(int j=0; j<lato; j++)
			{
				arrayAppoggio[c] = m[i][j];
				c++;
			}
		}
		
	int i = 0;
	int j = 0;
	c = 0;
		
	while(i < lato)
		{
			while(j < lato)
			{
				elemento = m[i][j];
				c = i+j;
				
				while(k < c)
				{
					if(elemento==arrayAppoggio[k])
					{
						flag = true;
					}
					
					k++;
				}
				
				j++;
				k = 0;
			}
			
			i++;
			j=0;
		}
		
		
		if(flag == true)
			ripetuti = true;
		else
			ripetuti = false;
		
		return ripetuti;
		
		
	}

Il problema è che questo trova numeri ripetuti solo nel caso in cui sia il primo elemento della matrice ad essere ripetuto, negli altri casi no.

ad esempio una matrice con inseriti i valori 1 2 2 3

risulta non avere numeri ripetuti utilizzando il codice che mi hai proposto.

mentre la matrice 1 3 5 1
viene correttamente rilevata la ripetizione del numero


in che modo si puo' risolvere il problema ??

[VincenzoTheBest]

Poichè Java è un linguaggio fortemente OBJECT ORIENTED vuole il seguente approccio:

// Devi creare il COSTRUTTORE, altrimenti il metodo non lo puoi applicare
// La classe la chiami arrayB

// Campi d'esemplare
int righe, colonne;
int array[][];

//Costruttore
public arrayB(int n, int m)
{
    righe = n;
    colonne = m;
    array[][] = new int[righe][colonne];
}

//Metodo (prende in input l'oggetto)
public boolean checkNumUguali(arrayB newArrayB)
{
   // prendo i parametri dell'oggetto
   int r = newArrayB.righe;
   int c = newArrayB.colonne;
   boolean flag = false;
   int arrayAppoggio[] = new int[r*c];

   ECC........
   .............
   .............
   
   return flag;
}

//Metodo per inserire i numeri nell'array
public void setArray()
{
   PRIMO CICLO del programma che ti ho postato in precedenza
}

Poi nel programma che ti ho mostrato in precedenza mi sono accorto di un errore banale...
Devi fare la seguente correzione:

while(j<colonne)
{
       elemento = array[i][j];
       if(i<0)
         c = i+j;
       else
         c = colonne+j;
				
	while(k<c)
	{

                   ECC...

[Crodreamer]

Il costruttore è presente, ed il programma funziona correttamente, a parte questa funzione che devo aggiungere.
Ora ho modificato il codice come mi hai suggerito :

    public static boolean numeriRipetuti (int [][] m, int lato)
    {
    	boolean flag = false;
    	int elemento;
		int c = 0;
		int k = 0;
		int[] arrayAppoggio = new int[lato*lato];
		
		for(int i = 0; i < lato; i++)
		{
			for(int j = 0; j < lato; j++)
			{
				arrayAppoggio[c] = m[i][j];
				c++;
			}
		}
		
		int i = 0;
		int j = 0;
		c = 0;
		
		while(i < lato)
		{
			while(j < lato)
			{
				elemento = m[i][j];
				   if(i < 0)
				         c = i + j;
				   else
				         c = lato + j;
				
				while (k < c)
				{
					if(elemento == arrayAppoggio[k])
					{
						flag = true;
					}
					k++;
				}
				j++;
				k = 0;
			}
			i++;
			j = 0;
		}
		
		return flag;
	}

e nel metodo main è presente anche la seguente istruzione:

if (Matrice.numeriRipetuti (matrice.getNumeri (), matrice.getLato())== true)
			{System.out.println ("ci sono numeri ripetuti");}
		else
		{System.out.println ("non ci sono numeri ripetuti");}

getNumeri e getLato sono metodi da me definiti che restituiscono l'array di int inserito dall'utente e il "lato", ovvero numero di righe o colonne (uguali dato che sto lavorando su matrici quadrate)

Il risultato è che qualsiasi numeri io inserisca, il programma mi stampa a video

ci sono numeri ripetuti

anche se nessun numero è ripetuto all'interno della matrice.

Evidentemente ho sbagliato a scrivere qualcosa nel metodo per la ricerca degli elementi uguali.
Qualcuno è cosi' gentile da controllare e dirmi se c'e' qualcosa che non va ?

EDIT: il dubbio che mi sorge riguarda questa riga

elemento == arrayAppoggio[k]

secondo me questo risultera' sempre vero, poiche' ci sara' sempre almeno un elemento dell'array originale uguale ad un elemento dell'arrayAppoggio, vale a dire se stesso.
Spero che qualcuno possa risolvere il mio problema

[VincenzoTheBest]

Sicuramente c'è qualcosa che non va nel metodo GETNUMERI(), perchè il codice che ti ho fornito, da cui hai preso spunto, è giusto!

Verifica tu stesso...prova a compilare ed eseguire il mio programma (ovviamente è senza metodi, è solo una dimostrazione di come dovrebbe funzionare il tutto)

/**
 * @(#)MatriceBid.java
 *
 *
 * @author VincenzoTheBest
 * @version 1.00 2008/2/17
 */

import java.util.*;

public class MatriceBid 
{
	public static void main(String[] args)
	{
		
		Scanner input = new Scanner(System.in);
		int righe, colonne;
		
		System.out.print("-N Righe: ");
		righe = input.nextInt();
		System.out.print("-M Colonne: ");
		colonne = input.nextInt();
		System.out.println("\n");
				
		int[][] array = new int[righe][colonne];
		
		int[] arrayAppoggio = new int[righe*colonne];
		
		int valore;
		
		for(int i=0; i<righe; i++)
		{
			for(int j=0; j<colonne; j++)
			{
				System.out.print("Posizione "+i+"."+j+": ");
				valore = input.nextInt();
				array[i][j] = valore;
			}
		}
		
		System.out.println();
		
		
		// Stampa
		int c = 0;
		System.out.println("ELEMENTI DELL'ARRAY BIDIMENSIONALE\n");
			
		for(int i=0; i<righe; i++)
		{
			System.out.print("|");
			
			for(int j=0; j<colonne; j++)
			{
				System.out.print(" "+array[i][j]+" "); // Visualizza elementi
				
				arrayAppoggio[c] = array[i][j]; // Copio gli elementi nell'array di appoggio
				c++;
			}
			
			System.out.print("|");
			System.out.println();
		}
		
		// Verifica elementi uguali
		int elemento, uguali=0;
		boolean flag = false;
		int j = 0;
		int i = 0;
		c = 0;
		int k = 0;
		
		while(i<righe)
		{
			while(j<colonne)
			{
				elemento = array[i][j];
				
				if(i<1)
					c = i+j;
				else
					c = j+colonne;
				
				while(k<c)
				{
					if(elemento==arrayAppoggio[k])
					{
						flag = true;
						uguali+=1;
					}
					
					k++;
				}
				
				j++;
				k=0;
			}
			
			i++;
			j=0;
		}
		
		
		if(flag==true)
			System.out.println("\nCi sono elementi uguali: "+uguali);
		else
			System.out.println("\nNON Ci sono elementi uguali");
		
		
	}    
}