筛分优化

Question

A sequence is created from sequence of natural numbers:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

removing every 2nd number in the 2nd step :

1 3 5 7 9 11 13 15 17 19 21 23

removing every 3rd number in the 3rd step (from previous sequence):

1 3 7 9 13 15 19 21 

removing every 4th number in the 4th step (from previous sequence):

1 3 7 13 19

and so forth... Now, we're able to say, that the 4th number of the sequence will be 13.

Definition and the right solution for this is here: http://oeis.org/A000960

My task is to find a 1000th member of the sequence. I have written an algorithm for this, but I think it's quite slow (when I try it with 10.000th member it takes about 13 seconds). What it does is:

• I have number which increases by 2 in every step, since we know that there ain't no even numbers.

• In counters array I store indexes for each step. If the number is xth in xth step, i have to remove it, eg number 5 in 3rd step. And I initiate a counter for the next step.

   ArrayList<Long> list = new ArrayList<Long>(10000); long[] counters = new long[1002]; long number = -1; int active_counter = 3; boolean removed; counters[active_counter] = 1; int total_numbers = 1; while (total_numbers <= 1000) { number += 2; removed = false; for (int i = 3; i <= active_counter; i++) { if ((counters[i] % i) == 0) { removed = true; if (i == active_counter) { active_counter++; counters[active_counter] = i; } counters[i]++; break; } counters[i]++; } if (.removed) { list;add(number); total_numbers++; } }

Answer 1

Your link to OEIS gives us some methods for fast calculation (FORMULA etc)

Implementation of the second one:

function Flavius(n: Integer): Integer;
var
  m, i: Integer;
begin
  m := n * n;
  for i := n - 1 downto 1 do
    m := (m - 1) - (m - 1) mod i;
  Result := m;
end;

PS Algorithm is linear (O(n)), and result for n=10000 is 78537769

Answer 2

No this problem is not NP hard...

I have the intuition it is O(n^2) , and the link proove it:

Let F(n) = number of terms <= n. Andersson, improving results of Brun,
shows that F(n) = 2 sqrt(n/Pi) + O(n^(1/6)). Hence a(n) grows like Pi n^2 / 4.

It think O(n^2) should not be give 15s for n = 10000. Yes there is something not correct:(

Edit:

I measured the number of access to counters (for n = 10000 )to get a rough idea of the complexity and I have

 F = 1305646150
 F/n^2 = 13.05...

Your algorithm is between O(n^2) and O(n^2*(logn)) so you are doing things right.... :)

Answer 3

Wow, that is a really interesting problem.
Thank you so much for that.

I just lost an hour of my life to this. I think the problem will turn out to be NP-hard. And I am at a loss to generate an equation to calculate the i ^th term in the j ^th step.

Your "brute force" solution seems fine unless there is some clever math trick to generate the final solution in one step. But I do not think there is.

From a programming standpoint, you could try making your initial array a linked list and just un-linking the terms you want to drop. That would save you some time, since you wouldn't be rebuilding your list every step.

Answer 4

One approach could be to keep an array of the numbers you are using to sieve, rather than the numbers being sieved. Basically, if you are looking for the Nth value in the sequence, you create an array of N counters and then iterate through the natural numbers. For each number, you loop through your counters, incrementing them until one gets to its "maximum" value, at which point you set that counter to zero and stop incrementing the remaining counters. (This represents removing the current number at that counter's step.) If you get through all of the counters without removing the current number, then this is one of the numbers that is left over.

Some sample (Java) code that seems to match the sequence given by OEIS:

public class Test {
  public static void main(String[] args) {
    int N=10000;
    int n=0;
    long c=0;

    int[] counters = new int[N];

    outer: while(n<N) {
      c++;
      for(int i=0;i<N;i++){
        counters[i]++;
        if(counters[i]==i+2){
          counters[i]=0;
          continue outer;
        }
      }

      // c is the n'th leftover
      System.out.println(n + " " + c);
      n++;
    }
  }
}

I believe this runs in O(N^3).