Найти K-е по счёту простое число

#include <iostream>
 
int main() {
    int n;
 
 
    std::cin >> n; // считываем номер простого числа, которое нужно найти
 
    int size = n; // число элементов для массива чисел для просеивания
    int* primes = new int[n]; // массив простых чисел
    int* numbers = new int[size]; // массив для чисел
 
    for (int i = 0; i < size; i++)
        numbers[i] = i; // заполняем массив (число равно индексу элемента)
 
    primes[0] = 2; // первое простое число - 2
    int i = 0; // индекс текущего простого числа
 
    while (i < n) {
        int p = primes[i++]; // запоминаем текущее простое число
 
        for (int j = p * 2; j < size; j += p)
            numbers[j] = 0; // обнуляем все кратные ему числа в массиве
 
        while (numbers[p + 1] == 0)
            p++; // ищем следующее ненулевое число
 
        if (p + 1 >= size) { // если выйдем за границы, расширяем массив
            int* tmp = new int[size * 2];
 
            for (int k = 0; k < size; k++)
                tmp[k] = numbers[k];
 
            delete[] numbers;
 
            size *= 2;
            numbers = tmp;
 
            for (int j = size / 2; j < size; j++)
                numbers[j] = j; // заполняем новую часть массива числами
 
            i = 0; // возвращаемся к начальной стадии просеивания
        }
        else
            primes[i] = p + 1; // запоминаем новое простое число
    }
 
    std::cout << primes[n - 1] << std::endl;
 
    delete[] numbers;
    delete[] primes;
}

#include <iostream>
#include <vector>
 
using namespace std;
 
bool is_prime(int n) {
    if (n < 2) {
        return false;
    }
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}
 
int main() {
    int k;
    cin >> k;
 
    vector<int> primes;
    primes.push_back(2);
    int n = 3;
    while (primes.size() < k) {
        if (is_prime(n)) {
            primes.push_back(n);
        }
        n += 2;
    }
 
    cout << primes[k-1] << endl;
 
    return 0;
}

#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <stdint.h>
#include <chrono>
 
constexpr int64_t L1_CPU_CACHE = 32768; // 32 KiB = 32768 B
 
std::vector<int64_t> sieveOfEratosthenes(int64_t x)
{
    std::vector<int64_t> r;
    r.push_back(2);
    int64_t w = static_cast<int64_t>(std::sqrt(x));
    int64_t a = std::max(w, L1_CPU_CACHE);
    int64_t i = 3, n = i, s = n;
    std::vector<char> v(a);
    std::vector<char> q(w + 1, true);
    std::vector<int64_t> p;
    std::vector<int64_t> m;
    for (int64_t l = 0; l <= x; l += a)
    {
        std::fill(v.begin(), v.end(), true);
        int64_t h = l + a - 1;
        h = std::min(h, x);
        for (; i * i <= h; i += 2)
            if (q[i])
                for (int64_t j = i * i; j <= w; j += i)
                    q[j] = false;
        for (; s * s <= h; s += 2)
        {
            if (q[s])
            {
                p.push_back(s);
                m.push_back(s * s - l);
            }
        }
        for (std::size_t i = 0; i < p.size(); i++)
        {
            int64_t j = m[i];
            for (int64_t k = p[i] * 2; j < a; j += k)
            v[j] = false;
            m[i] = j - a;
        }
        for (; n <= h; n += 2)
            if (v[n - l])
                r.push_back(n);
    }
    return r;
}
 
int main()
{
    int64_t n, x;
    std::cout << "n = "; std::cin >> n;
    std::cout << "x = "; std::cin >> x;
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<int64_t> s = sieveOfEratosthenes(x);
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "Prime[" << n << "] = " << s[n-1] << '\n';
    std::cout << "PrimePI[" << x << "] = " << s.size() << '\n';
    std::cout << diff.count() << " s\n";
    std::system("pause");
}