Newsgroup: it.comp.java
Titolo: Aiutate un disperato..

Ho un esercizio da fare, l'ho fatto e l'ho sbagliato. Spero che qualcuno di
buona volontà possa darmi una mano perchè mi sto sbattendo da ore e non
risolvo niente :(
L'esercizio consiste in due classi: la classe PermDriver che testa la classe
PermutationGenerator.
Lo scopo dell'esercizio è costruire la classe PermutationGenerator data la
classe PermDriver. Ho cercato di commentarlo il più possibile.
Questo è il testo dell'esercizio:
Il file contiene la definizione completa del driver che consente di testare
la classe PermutationGenerator.
Implementate la classe PermutationGenerator in maniera tale che il metodo
nextPermutation riempia l'array creato in inizializzazione con i numeri
naturali da 1 a n (dove n è la dimensione dell'array) disposti in maniera
casuale senza ripetizioni.
Per implementare il metodo nextPermutation seguite la seguente strategia:
  a.. Create un array della medesima dimensione e inseritivi, nell'ordine, i
numeri da 1 a n;
  b.. Sceglieteli poi a caso, uno per uno, e copiateli nell'array risultato.
////////////////////////////////////////////////////////////////////
///////////////CLASSE PERMDRIVER////////////
///////////////////////////////////////////////////////////////////
import java.util.Random;
public class PermDriver
{
 public static void main(String[] args)
 {
  final int DIM = 14;
  PermutationGenerator pg = new PermutationGenerator(DIM);
  int[] perm;
  for (int i=0 ; i<10 ; i++)
  {
   perm = pg.nextPermutation();
   for (int j=0 ; j<DIM-1 ; j++)
   {
    System.out.print(perm[j] + " ");
   }
  System.out.println(perm[DIM-1]);
  }
 }
}
////////////////////////////////////////////////////////////////////////////
//////////////////
///////////////CLASSE PERMUTATIONGENERATOR////////////
////////////////////////////////////////////////////////////////////////////
/////////////////
import java.util.Random;
class PermutationGenerator
{
 ///////////////////////////////////////////////////////////////////////////
////////////////////
 //Definizione delle variabili che definiscono lo stato della classe //
////////////////////////////////////////////////////////////////////////////
///////////////////
////////////////////////////////////////////////////////////////////////////
//////////////////
 Random generator = new Random();
 int dim;
 private int k,indice,i;
 private int flag=0;
 private int[] b;
 private int[] a;
////////////////////////////////////////////////////////////////////////////
///////////////////
 // Costruttore della classe, il parametro definisce quanti sono gli //
 // elementi dell'array di cui si deve calcolare la permutazione     //
////////////////////////////////////////////////////////////////////////////
//////////////////
 PermutationGenerator (int dim)
 {
     int[] a = new int[dim];     /////////////////////////////////////
     for(i=0;i<dim;i++)   //Creazione e inizializzazione del //
         a[i]=0;      //vettore a di dimensioni dim      //
     this.dim = dim;    /////////////////////////////////////
 }
////////////////////////////////////////////////////////////////////////////
///////////////////////////
 // Il metodo che restituisce una combinazione casuale degli elementi//
////////////////////////////////////////////////////////////////////////////
//////////////////////////
////////////////////////////////////////////////////////////////////////////
//////////////////////////
 public int[] nextPermutation()
 {
     int[] b = new int[dim];          //creazione e inizializzazione del
//
     for(i=0;i<dim;i++)              //vettore b di dimensione dim che //
         b[i]=i+1;                            // contiene i numeri da 1 a 10
//
////////////////////////////////////////////////////
                                   // Algoritmo che riempie il vettore   //
    for(i=0;i<dim;i++)       // a (inizialmente con tutti 0) con      //
    {                                // gli elementi del vettore b presi
//
      flag=0;                     // a caso senza ripetizione Esempio: //
      while(flag!=1)          // vettore B:{1,2,3,4,5,6,7,8,9,10}  //
     {                              // vettore A:{2,5,1,10,7,4,3,8,9,6}  //
     k=0;
///////////////////////////////////////////////////////
        do{
          indice=Math.abs(generator.nextInt())%10;
         if(a[indice]==0)
          {
          a[indice]=b[i];
          k=1;
          }
         else k=0;
           }
        while(k==0);
        flag=occorrenze(a,a[indice],dim);
        };
    }
     return a;
 }
////////////////////////////////////////////////////////////////////////////
/
 // Conta le occorrenze del numero n nel vettore  ////
////////////////////////////////////////////////////////////////////////////
/
////////////////////////////////////////////////////////////////////////////
/
 private static int occorrenze (int[] vettore,int n,int dim)
 {
      int i,flag=0,k=0;
      for(i=0;i<dim;i++)
      if(vettore[i]==n) flag++;
      return flag;
 }
}
///////////////////////////////////////
ERRORI PRODOTTI:
///////////////////////////////////////
Exception in thread "main" java.lang.NullPointerException
        at
PermutationGenerator.nextPermutation(PermutationGenerator.java:46)
        at PermDriver.main(PermDriver.java:14)
Press any key to continue...
Sperando in un aiuto, vi porgo i miei saluti.

 wrote in message
news:MR2tb.20003$9_.7...@news1.tin.it...


 wrote in message
news:bT2tb.20009$9_.7...@news1.tin.it...



[...]
Ciao
Ivan

 tuo array private dichiarato sopra non verrà mai inzializzato
