Генерация целых чисел в порядке возрастания с использованием набора простых чисел

удаление номера и вставляю все его кратные (по простым числам в наборе) в очередь приоритетов -неправильно (в смысле, вопрос) - т. е. он производит правильную последовательность а неэффективно так.

это неэффективно двумя способами - Во-первых, это перепроизводит последовательность; во-вторых, каждая операция PriorityQueue несет дополнительные расходы (операции remove_top и insert обычно не так O (1), конечно,не в любой реализации PriorityQueue на основе списка или дерева).

эффективное O (n) алгоритм поддерживает указатели обратно в саму последовательность по мере ее создания, чтобы найти и добавить следующее число в O (1). В псевдокоде:

  return array h where
    h[0]=1; n=0; ps=[2,3,5, ... ]; // base primes
    is=[0 for each p in ps];       // indices back into h
    xs=[p for each p in ps]        // next multiples: xs[k]==ps[k]*h[is[k]]
    repeat:
      h[++n] := minimum xs
      for each (i,x,p) in (is,xs,ps):
        if( x==h[n] )
          { x := p*h[++i]; }       // advance the minimal multiple/pointer

для каждого минимального кратного он продвигает свой указатель, в то же время вычисляя его следующее кратное значение. Это слишком эффективно реализует PriorityQueue, но с решающими различиями-это до конечная точка, а не после; он не создает никакого дополнительного хранилища, кроме самой последовательности; и его размер постоянен (просто k для k базовые простые числа), тогда как размер past-the-end PriorityQueue растет по мере продвижения по последовательности (в случае последовательности Хэмминга, основанной на множестве 3 простые числа, as n^2/3, для n чисел последовательности).

классический последовательность Хэмминга в Haskell по сути тот же алгоритм:

h = 1 : map (2*) h `union` map (3*) h `union` map (5*) h

union a@(x:xs) b@(y:ys) = case compare x y of LT -> x : union  xs  b
                                              EQ -> x : union  xs  ys
                                              GT -> y : union  a   ys

мы можем создать ровные цифры на произвольные базовые простые числа с помощью (2016-08-18: основное ускорение из-за использования Int вместо Integer где это возможно, даже на 32-бит; дополнительные 20% благодаря настройке, предложенной @GordonBGood, в результате чего сложность размера полосы до O (n^1/3)).

это обсуждается еще в ответ где мы также находим его полную атрибуцию:

slice hi w = (c, sortBy (compare `on` fst) b) where  -- hi is a top log2 value
  lb5=logBase 2 5 ; lb3=logBase 2 3                  -- w<1 (NB!) is (log2 width)
  (Sum c, b) = fold                                  -- total count, the band
      [ ( Sum (i+1),                                 -- total triples w/this j,k
          [ (r,(i,j,k)) | frac < w ] )               -- store it, if inside the band
        | k <- [ 0 .. floor ( hi   /lb5) ],  let p = fromIntegral k*lb5,
          j <- [ 0 .. floor ((hi-p)/lb3) ],  let q = fromIntegral j*lb3 + p,
          let (i,frac) = pr  (hi-q)      ;       r = hi - frac    -- r = i + q
      ]    -- (sum . map fst &&& concat . map snd)
  pr = properFraction 

это можно обобщить для k база простых чисел, а также, вероятно, работает в O (n^(k-1)/k) времени.

посмотреть это так запись для важного последующего развития. кроме того, ответ это интересно. и еще ... --104-->обзоры ответа.

этот 2-мерный алгоритм исследования не является точным, но работает для первых 25 целых чисел, а затем смешивает 625 и 512.

n = 0
exp_before_5 = 2
while true
  i = 0
  do
    output 2^(n-exp_before_5*i) * 5^Max(0, n-exp_before_5*(i+1))
    i <- i + 1
  loop while n-exp_before_5*(i+1) >= 0
  n <- n + 1
end while

основываясь на ответе user448810, вот решение, которое использует кучи и векторы из STL.
Теперь кучи обычно выводят наибольшее значение, поэтому мы храним отрицательные числа в качестве обходного пути (так как a>b <==> -a<-b).

#include <vector>
#include <iostream>
#include <algorithm>

int main()
{
    std::vector<int> primes;
    primes.push_back(2);
    primes.push_back(5);//Our prime numbers that we get to use

    std::vector<int> heap;//the heap that is going to store our possible values
    heap.push_back(-1);
    std::vector<int> outputs;
    outputs.push_back(1);
    while(outputs.size() < 10)
    {
        std::pop_heap(heap.begin(), heap.end());
        int nValue = -*heap.rbegin();//Get current smallest number
        heap.pop_back();
        if(nValue != *outputs.rbegin())//Is it a repeat?
        {
            outputs.push_back(nValue);
        }
        for(unsigned int i = 0; i < primes.size(); i++)
        {
            heap.push_back(-nValue * primes[i]);//add new values
            std::push_heap(heap.begin(), heap.end());
        }
    }
    //output our answer
    for(unsigned int i = 0; i < outputs.size(); i++)
    {
        std::cout << outputs[i] << " ";
    }
    std::cout << std::endl;
}

выход:

1 2 4 5 8 10 16 20 25 32