Aprendiendo a depurar en Java

Question

Estoy aprendiendo a usar JPDA en Netbeans y resolviendo el problema. Generador principal problema del Juez Online de Esfera.

He estado leyendo este tutorial en netbeans.org sobre el JPDA, pero no lo he encontrado de mucha ayuda.

Este código, que se basa en una implementación del Tamiz de Eratóstenes proporcionada por starblue aquí, se ejecuta así:

2
1 10
//here the primes between 1 and 10 should print 
3 5
//here the primes between 3 and 5 should print 




package sphere;

/**
 *
 * @author Administrator
 */
//import java.util.ArrayList;
import java.util.BitSet;
import java.lang.Math.*;
import java.util.ArrayList;

public class Main
{

  public static int ApproximateNthPrime(int nn)
{
    double n = (double)nn;
    double p;
    if (nn >= 7022)
    {
        p = n * Math.log(n) + n * (Math.log(Math.log(n)) - 0.9385);
    }
    else if (nn >= 6)
    {
        p = n * Math.log(n) + n * Math.log(Math.log(n));
    }
    else if (nn > 0)
    {
        p = new int[] { 2, 3, 5, 7, 11 }[nn - 1];
    }
    else
    {
        p = 0;
    }
    return (int)p;
}

// Find all primes up to and including the limit
public static BitSet SieveOfEratosthenes(int limit)
{
    final BitSet primes = new BitSet();
    primes.set(0,false); 
    primes.set(1,false); 
    primes.set(2,limit,true); 

    for (int i =0; i*i<limit;i++)
    {
        if (primes.get(i))
        {
            for (int j=i*1; j<limit;j+=1)
            {
                primes.clear(j);// hace que el indice j sea false (no primo)
            }

        }

    }
    return primes;
}

public static ArrayList<Integer> GeneratePrimesSieveOfEratosthenes(int n)
{
    int limit = ApproximateNthPrime(n);
    BitSet bits = SieveOfEratosthenes(limit);
    ArrayList <Integer> primes = new ArrayList<Integer>();
    for (int i = 0, found = 0; i < limit && found < n; i++)
    {
        if (bits.get(i))
        {
            primes.add(i);
            found++;
        }
    }
    return primes;
}





  public static void main (String[] args) throws java.lang.Exception
  {
     java.io.BufferedReader r = new java.io.BufferedReader (new java.io.InputStreamReader (System.in));
     String s;

     s= r.readLine();

     int test_cases = Integer.parseInt(s);


     int case_counter =0;

     while (case_counter<test_cases) {

        // System.out.println(s);
         s = r.readLine();

         String [] splitted = s.split(" ");

         int lower_bound = Integer.parseInt(splitted[0]);
         int upper_bound = Integer.parseInt(splitted[1]);



        ArrayList <Integer> primesList=  GeneratePrimesSieveOfEratosthenes(upper_bound);



         for (int i =0; i<primesList.size();i++){
            if (primesList.get(i)<=lower_bound)System.out.println(primesList.get(i));
         }


         case_counter++;

         System.out.println(" "); // space that separates test cases

     }
  }
}

Sé que ArrayList primesList no se está inicializando y sospecho de este fragmento de código porque, sinceramente, no lo entiendo del todo:

if (primes.get(i))
        {
            for (int j=i*1; j<limit;j+=1)
            {
                primes.clear(j);
            }

        }

Se me ocurrió utilizar un punto de interrupción condicional aquí con la condición de:

primes.get(j)==false

Pero no estoy seguro de poder obtener información significativa de esta manera.Estas son las pantallas que me salen:

texto alternativo http://img525.imageshack.us/img525/6238/breakpoints.jpg

texto alternativo http://img98.imageshack.us/img98/5262/watchesz.jpg

No sé cómo sacar información útil de esto.

Mis preguntas son:

a) Quiero observar los números primos BitSet mientras pasa por este bucle.

¿Cómo puedo hacer eso?

b) ¿Qué hay exactamente mal con este código? ¿Cómo lo detectaste usando el depurador?

Por favor, mencione el proceso paso a paso.

Answer 1

Entonces, extraje el siguiente método:

    private static void printPrimes(int lower_bound, int upper_bound) {
    ArrayList<Integer> primesList = GeneratePrimesSieveOfEratosthenes(upper_bound);

    for (int i = 0; i < primesList.size(); i++) {
        if (primesList.get(i) <= lower_bound)
            System.out.println(primesList.get(i));
    }
}

y cambió el main() método para simplemente llamar a eso con un par de argumentos arbitrarios (10 y 100), porque no quería perder el tiempo con la consola y el depurador al mismo tiempo.Luego (estoy usando Eclipse) coloco puntos de interrupción ordinarios al principio y al final de las líneas de ApproximateNthPrime(), SieveOfEratosthenes() y GeneratePrimesSieveOfEratosthenes() para asegurarse de que los estaban llamando.(Por cierto, la convención de Java, a diferencia de C#, es que los nombres de los métodos comiencen con una letra minúscula).

Todo eso fue sin molestarse en entender el código.:) Sin embargo, después del primer repaso, quedó bastante claro que el problema es que el BitSet producido por SieveOfEratosthenes() siempre está vacío (o mejor dicho, siempre completamente false).No he usado el depurador de NetBeans, pero sospecho que la pestaña "Variables locales" es tu amiga aquí.

No voy a hacer tu tarea por ti.:) Pero la idea del Tamiz de Eratóstenes es omitir los números primos y solo eliminar los no primos.examina tu SieveOfEratosthenes() método y pregúntese:¿Cuándo se saltará un número?