[JAVA] Problema stampa matrice con numeri pseudo-casuali

[DarkAlexander]

Innanzitutto, salve a tutti.
Mi chiamo Alessandro, e questo è il mio primo post sul forum. Ho iniziato a studiare programmazione da neanche 12 ore (di cui gran parte sono state di sonno, avendo iniziato ieri sera verso mezzanotte...) ed ho già molti problemi. Sono chiaramente un tremendo pippone, e chiedo in anticipo perdono per questo! Premetto che mi sto esercitando poiché a breve inizierò una specialistica in campo informatico (Intelligent System) pur essendo laureato in psicologia cognitiva. Per cercare di non trovarmi eccessivamente indietro rispetto ai miei compagni di corso (quasi tutti laureati in Computer Science) ho deciso di iniziare a studiare un pochino per conto mio. Siccome il primo esame che dovrò fare è proprio su/con Java, mi sembrava doveroso iniziare a studiare proprio questo linguaggio. Ma bando alle ciance!

Allora, l'idea sarebbe quella di creare (e stampare) una matrice 9x9 formata da numeri casuali che però si dispongano secondo un preciso pattern:

 
8 7 6 5 4 5 6 7 8
7 6 5 4 3 4 5 6 7
6 5 4 3 2 3 4 5 6
5 4 3 2 1 2 3 4 5
4 3 2 1 0 1 2 3 4
5 4 3 2 1 2 3 4 5
6 5 4 3 2 3 4 5 6
7 6 5 4 3 4 5 6 7
8 7 6 5 4 5 6 7 8

Per generare numeri casuali interi da 0 a 9 ho utilizzato il comando (spero che "comando" sia la parola corretta...) (int)Math.random() * 10. Il codice per intero è questo qua:

public class matrix {
	
	public static void main(String argv[]) {
		
		//Definiamo matrix e random
		int[][] matrix = new int[9][9];
		int[] random = {(int)Math.random() * 10, (int)Math.random() * 10, (int)Math.random() * 10, (int)Math.random() * 10, (int)Math.random() * 10, (int)Math.random() * 10, (int)Math.random() * 10, (int)Math.random() * 10, (int)Math.random() * 10};
		
		//Riempiamo la matrix
		int r = 0;
		int c = 0;
		int x = 8;
		int cont = 0;
		
		while (c<9) {
			while (r<9) {
				matrix[r][c] = random[x];
				r = r++;
				cont = cont++;
				if (cont<5) {
					x = x--;
				}
				else {
					x = x++;
				}
			}
			c = c++;
			r = 0;
		}
		//Stampiamo la matrix
		r = 0;
		c = 0;
		
		while (c<9) {
			while (r<9) {
				System.out.print(matrix[r][c]);
				System.out.print("\t");
				r = r++;
			}
			c = c++;
			r = 0;
			System.out.println();
		}
	}

}

Il problema a questo punto è molto semplice: non succede niente. Niente, nada, nisba. Normalmente per controllare di aver scritto tutto bene chiedo ad Eclipse di far girare il programma (senza utilizzare ogni volta il Prompt di comandi per compilare e far girare) e così ho fatto anche questa volta ma... Niente. Finestra bianca. Allora ho pensato che forse era il caso di provare con il metodo tradizionale. Ho fatto compilare il tutto con i comandi del Prompt (javac matrix.java) e poi ho fatto lanciare il programma (java matrix) ma anche questa volta... Niente. Niente scritte, niente errori... Semplicemente niente. Come è possibile? Cosa ho sbagliato?

Grazie a tutti in anticipo e scusate la mia ignoranza!

Con affetto,
Alessandro

[satifal]

Sostituisci tutte le righe di codice del tipo:

variabile = variabile++;

con:

variabile++;

[DarkAlexander]

Oh, I am such an idiot!
Grazie mille, Satifal!

Solamente che adesso mi dà un errore (che è comunque meglio di aver avviato un loop infinito) sulla linea 18:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 9
	at matrix.main(matrix.java:18)

Sarebbe questo comando:

matrix[r][c] = random[x];

Come mai? Inizialmente x è 8, e durante i vari giri di while diventa 7, 6, 5, 4, 3, 2, 1, 0. Ora, se non ho capito male, quando scrivo random[8] dovrei chiamare il nono numero dell'array random, dico bene? O non ho capito niente?

[satifal]

x all'inizio vale 8 però puoi ne modifichi il valore tramite l'istruzione:

...
if (cont<5) {
					x = x--;
				}
				else {
					x = x++;
				}
...

per cui x all'inizio viene decrementato, ma poi, quando cont >= 5 esso viene incrementato ed evidentemente ad un certo punto del cilo assume valore 9 il che va oltre la dimensione dell'array che va da 0 a 8.

[DarkAlexander]

Of course, it is!
Ho dimenticato di reimpostare x = 0 dopo nove cicli!
Grazie davvero mille. Sei davvero un segugio, Satifal!
Spero anche io di diventare così bravo con lo studio e la pratica.

In ogni caso, non è ancora finito il mio travagliare.
Infatti finalmente il programma mi restituisce una matrice 9x9 ma...
Composta da soli 0! Ora, statisticamente parlando è anche possibile che abbia generato casualmente una serie di nove 0 di fila... Ma per la legge dei grandi numeri tendo a scartare questa ipotesi. Cosa ho sbagliato questa volta?

[satifal]

Il problema è nel cast ad int che effettui in fase di popolamento dell'array random.
Tu fai:

(int)Math.random() * 10

per ogni valore inserito, ma così facendo effettui prima il cast ad int del valore restituito dal metodo random() che è compreso tra 0.1 ed 1.0. Quindi, tranne nel caso in cui esso è 1.0 il cast ad int ti restituirà sempre 0 per cui sarà inutile effettuare la moltiplicazione per 10
Il codice corretto è:

(int)(Math.random() * 10)

In questo modo PRIMA effettui la moltiplicazione per 10 e poi casti il risultato ad int.

[DarkAlexander]

I totally understand it!
Grazie mille! Risolto anche questo problema.

E adesso la cosa più bella è che comunque non esce il pattern che stavo cercando di far uscire! Ma almeno ho capito molte cose provandoci. Devo aver fatto qualche grande errore perché esce una serie di numeri molto diversa da quella che stavo cercando.

Credo di aver fatto un casino.
Ho come l'impressione di dover ricominciare tutto da caso.

[DarkAlexander]

Perfetto, ho riscritto il codice ripartendo da zero.
Ho indubbiamente compiuto un nuovo passo verso la realizzazione del mio programma ma ho ancora qualche problema. Adesso riesco a stampare la matrice 9x9 e riusco a stampare correttamente tutta la prima colonna. Le altre colonne, invece, risultato tutte composte da 0. Probabilmente il programma non legge il mio comando "colonna++;" ma non riesco a capire il perché. Ho il timore di aver fatto qualche casino quando ho inserito due cicli while uno dentro l'altro (ma potrebbe anche essere qualche altra cosa).

Il codice, by the way, è il seguente:

public class matrix2 {

	public static void main(String argv[]) {

		//Definiamo matrice e numeri casuali
		int[][] matrix = new int[9][9];
		int[] random = {0,1,2,3,4,5,6,7,8};

		//Riempiamo la matrice con i numeri casuali
		int colonna = -1;
		int riga = 0;
		int x = 8;
		int contatore = 0;
		
		//Rimpiamo le prime cinque colonne
		while (colonna<5) {
			while (riga<9) {
				matrix[colonna][riga] = random[x];
				riga++;
				contatore++;
				if (contatore<5) {
					x--;
				}
				else {
					x++;
				}
				}
			colonna++;
			x--;
			}
		
		//Riempiamo le ultume quattro
		while (colonna<5) {
			while (riga<9) {
			matrix[riga][colonna] = random[x];
			riga++;
			if (contatore<5) {
				x--;
			}
			else {
				x++;
			}
		}
			colonna++;
			x--;
			}
		
		//Stampiamo la matrix
		colonna = 0;
		riga = 0;
		
		while (colonna<9) {
		while (riga<9) {
		System.out.print(matrix[riga][colonna]);
		System.out.print(" ");
		riga++;
		}
		colonna++;
		riga = 0;
		System.out.println();
		}
	}
}

E mi stampa la seguente matrice:

8 0 0 0 0 0 0 0 0 
7 0 0 0 0 0 0 0 0 
6 0 0 0 0 0 0 0 0 
5 0 0 0 0 0 0 0 0 
4 0 0 0 0 0 0 0 0 
5 0 0 0 0 0 0 0 0 
6 0 0 0 0 0 0 0 0 
7 0 0 0 0 0 0 0 0

Post Scriptum
Rispetto a prima ho eliminato per adesso la componente casuale che inserirò non appena riuscirò a stampare la matrice correttamente (dovrebbe bastare cambiare l'array definito random).

Grazie a tutti in anticipo.
Alessandro
8 0 0 0 0 0 0 0 0

[Andrea1979]

Ciao e benvenuto nel mondo della programmazione e nello specifico in quello di java!

Una cosa di cui ti accorgerai piuttosto presto è che la maggior parte degli esercizi assegnati in un corso universitario sono puramente didattici (come è giusto che sia) e nella stragrande maggioranza dei casi quello che viene davvero richiesto è di trovare un sistema, algoritmo, pattern, chiamalo come vuoi per risolvere "brillantemente" la problematica proposta.
Ora nel tuo caso, quella matrice proposta ha davvero molto poco di casuale... se osservi, i numeri che compaiono sono interpretabili come la distanza (se potessi muoverti solo per righe e colonne) di ciascun elemento dal centro della matrice stessa (che infatti vale 0).
Forte di quest'osservazione, hai già la metrica in questo tuo spazio discreto e quindi l'algoritmo da applicare per popolare correttamente la matrice...

for (int i = -4; i <= 4; i++) {
            for (int j = -4; j <= 4; j++) {
                mat[i+4][j+4] = Math.abs(i)+Math.abs(j);
            }            
}

Math.abs ritorna il valore assoluto (o modulo) dell'argomento (e fatalità rispetta esattamente l'interpretazione comune del concetto di distanza, ovvero di un qualcosa di positivo).

Buona continuaizione

[DarkAlexander]

Ma... Sei un ca**o di genio!
La tua soluzione è così elegante!
(Sono sempre più convinto che la
programmazione sia una forma artistica!)
Non ci sarei MAI arrivato da solo!

In realtà, come avevo scritto nell'ultimo post, adesso stavo lavorando con un array di numeri definito semplicemente per semplicità, il mio obiettivo era quello di generare numeri casuali che fossero disposti come nel pattern che ho mostrato sopra. Però stamattina mi ci sono messo e dopo un paio (una ventina...) di fallimenti sono riuscito a modificare il tuo codice per adattarlo al mio obiettivo:

//Definiamo matrice e numeri casuali
				int[][] matrix = new int[9][9];
				int[] random = {(int)(Math.random() * 10), (int)(Math.random() * 10), (int)(Math.random() * 10), (int)(Math.random() * 10), (int)(Math.random() * 10), (int)(Math.random() * 10), (int)(Math.random() * 10), (int)(Math.random() * 10), (int)(Math.random() * 10)};

				//Riempiamo la matrice con i numeri casuali
				for (int i = -4; i <= 4; i++) {
		            for (int j = -4; j <= 4; j++) {
		                matrix[i+4][j+4] = random[Math.abs(i)+Math.abs(j)];
		            }            
		}

Faccio girare il programma e...

7 6 2 1 4 1 2 6 7 
6 2 1 4 1 4 1 2 6 
2 1 4 1 4 1 4 1 2 
1 4 1 4 0 4 1 4 1 
4 1 4 0 5 0 4 1 4 
1 4 1 4 0 4 1 4 1 
2 1 4 1 4 1 4 1 2 
6 2 1 4 1 4 1 2 6 
7 6 2 1 4 1 2 6 7

...Et voilà!
Che soddisfazione!

Veramente... Grazie a tutti!
E' bello trovare gente che si sbatte per uno sconosciuto per il solo amore per la materia. Grazie davvero!
Anche se penso di risentiremo presto... Molto presto!