DOMANDA [java] Passaggio Parametri E Algoritmo

[Kingar]

Ho da poco iniziato col java e c'è qualcosa che non mi torna nel passaggio dei parametri.
Nella classe principale chiamo questo

Selezione o2 = new Selezione();
griglia [i] [j] = o2.clic(i, j, griglia [i] [j], nBolle);

i, j, nBolle sono interi; griglia una matrice
di seguito la classe Selezione

     package C.JAVA.BB;
     import java.util.*;
   
     public class Selezione
     {
         public int clic (int i, int j,  int nBolle, int [ ][ ] griglia)
         {
             if (i >= 0 && i < 5 && j >= 0 && j < 6)
             {
                 if ((griglia[i][j] != 0) && (++griglia[i][j] > 3))
                 {
                     nBolle--;
                     griglia[i][j] = 0;
                     clic (i - 1, j, griglia, nBolle);
                     clic (i + 1, j, griglia, nBolle);
                     clic (i, j - 1, griglia, nBolle);
                     clic (i, j + 1, griglia, nBolle);
                 }
                 if ((griglia [i] [j] > 0) && (griglia [i] [j] < 3))
                 {
                     ++griglia [i] [j];
                 }
                 System.out.print(griglia [i] [j] + "\t");
             }
         }
         return (griglia [ ] [ ]);
     }

 

[bigbox168]

qual'è la domanda?

 

[Kingar]

Volevo capire se i parametri passati sono passati nella maniera corretta, soprattutto l'array multidimensionale, in quanto mi dà degli errori che credo siano riconducibili ad essi.

Nelle prime due righe l'errore che mi dà è questo:
incompatible types: int cannot be converted to int[][]
griglia [ ] [j] = o2.clic(i, j, griglia [ ] [j], nBolle); /*il forum mi cancella la i fra parentesi quadre affianco a griglia*/

Nella classe Selezione invece:
C:\JAVA\BB\Selezione.java:26: error: illegal start of type
return (griglia [ ] [ ]);
^
C:\JAVA\BB\Selezione.java:26: error: <identifier> expected
return (griglia [ ] [ ]);
^

 

[Mursey]

il forum mi cancella la i fra parentesi quadre affianco a griglia

Perche' dovete usare il tag CODE !!!

 

[BAT]

Questa istruzione
return (griglia [ ] [ ]);
è sbagliata, il metodo clic deve ritornare un intero

 

[javaprogrammer]

Volevo capire se i parametri passati sono passati nella maniera corretta, soprattutto l'array multidimensionale, in quanto mi dà degli errori che credo siano riconducibili ad essi.

Nelle prime due righe l'errore che mi dà è questo:
incompatible types: int cannot be converted to int[][]
griglia [ ] [j] = o2.clic(i, j, griglia [ ] [j], nBolle); /*il forum mi cancella la i fra parentesi quadre affianco a griglia*/

Nella classe Selezione invece:
C:\JAVA\BB\Selezione.java:26: error: illegal start of type
return (griglia [ ] [ ]);
^
C:\JAVA\BB\Selezione.java:26: error: <identifier> expected
return (griglia [ ] [ ]);
^

No, i parametri non vengono passati nella maniera corretta. O, più precisamente, non vengono passati nell'ORDINE corretto. Infatti il tuo metodo clic come terzo parametro vuole un intero, mentre tu gli hai distrattamente passato una matrice. Il compilatore di conseguenza ti restituisce quell'errore di conversione, che non sarebbe altro che un "ué, non puoi mica spacciarmi una matrice per un intero, sai?".
Poi c'è anche un secondo errore, che ti è già stato correttamente segnalato: il metodo vuole un intero come tipo di ritorno (public int), mentre tu, dopo la parola return, hai messo una matrice. Questo è chiaramente un errore imperdonabile. È come se tu chiedi al barista un cappuccino e quello ti dà una vodka.

 

[Kingar]

Altri quesiti:
ho una matrice popolata randomicamente di spazi vuoti, bolle sgonfie, semigonfie e che stanno per esplodere; selezionandole si gonfiano di un livello; quella che sta per esplodere, selezionandola, esplode e propaga l'esplosione in direzione n-s-o-e (non diagonalmente); la propagazione fa passare di un livello.

Dovrei trovare un algoritmo che trova, per ogni matrice generata a random, il minor numero di mosse per far scomparire tutte le bolle, avevo pensato di far selezionare al pc le bolle in ordine randomico così:

int rnd = new Random().nextInt (griglia.length);

Però ho tre problemi:
1- è possibile conoscere gli indici di riga e colonna dell'elemento selezionato?
2- è possibile che il pc giocandolo più e più volte ripeta le stesse mosse, facendo in pratica due tentativi uguali; è possibile ovviare a questo problema?
3- il numero di tentativi: nel caso peggiore, che credo sia quello in cui tutte le bolle sono sgonfie, ho 30^3 di scegliere la prima bolla, 29^3 la seconda e così via...

 

[Giacky91]

1- come viene selezionato l'elemento selezionato?( scusa il gioco di parole)
2- se le mosse svolte dal pc sono random, usando la funzione Random, allora è possibile che vengano fatti due tentativi uguali.

 

[DispatchCode]

A giudicare dai controlli che fai sugli indici, deduco che la matrice sia di dimensione fissa, 5x6. In questo caso puoi ricavarti gli indici abbastanza semplicemente.

Per quanto riguarda il riempimento l'estrazione dei numeri... puoi anche risparmiarti random, volendo. La soluzione più semplice è creare un ArrayList di 30 elementi (0-29), ed utilizzare il metodo shuffle() che li mischia (ed estrarre sempre l'indice 0 sino a che non sarà vuoto). Un'alternativa è sempre l'ArrayList popolato con gli elementi da 0 a 29, e l'utilizzo di Random per generare un int compreso tra 0 e la lunghezza dell'array list; in pratica, ogni volta che preleverai un elemento dalla posizione, lo rimuoverai dall'array.

Di certo pescare randomicamente ti darà una soluzione completa ma non ottima. Intendo dire che terminerà sicuramente, ma non dandoti le mosse migliori. Dovrai pensare ad un algoritmo più "sofisticato".
All'1.25 di notte la prima cosa che mi viene in mente - e per questo potrebbe anche essere da scartare - è di creare un albero delle possibili mosse, così da prendere sempre quelle che danno un risultato migliore. La profondità dell'albero sarebbe tuttavia un fattore da prendere in considerazione; ad ogni modo, visto il meccanismo dell'esplosione delle bolle, ci saranno meno mosse da testare (dato che la simulazione avverrà su tutte le bolle che produrranno l'esplosione più grande).

Una possibile alternativa, potrebbe essere l'analisi della matrice, e l'esplosione "mirata" di quella bolla che provocherà più esplosioni attorno a sè (mi sembra anche più semplice).