用c++编写一个程序，内容为求1到100内素数的个数

在C++中，你可以使用循环和条件判断来编写一个简单的程序，用于找出1到100之间的所有素数。素数是指只有1和它本身两个正因数的自然数。以下是代码示例：

#include <iostream>

bool isPrime(int num) {
    if (num <= 1) return false;
    for (int i = 2; i * i <= num; i++) {
        if (num % i == 0) return false;
    }
    return true;
}

int countPrimes(int limit) {
    int count = 0;
    for (int i = 2; i <= limit; i++) {
        if (isPrime(i)) count++;
    }
    return count;
}

int main() {
    int primesInRange = countPrimes(100);
    std::cout << "1到100内的素数个数为：" << primesInRange << std::endl;
    return 0;
}

这个程序首先定义了一个辅助函数`isPrime`，用于检查给定的数字是否为素数。然后，在`countPrimes`函数中，我们遍历从2到指定限制（这里是100），对每个数调用`isPrime`函数，并累加计数器。

运行此程序后，你将看到1到100之间有多少个素数。

相关问题

用c++编写一个程序，求1-n的素数个数。给出两种解法，计算两种写法的求解时间

在C++中编写一个程序来求解1到n之间素数的个数，我们可以使用两种常见的算法：暴力法和埃拉托斯特尼筛法（Sieve of Eratosthenes）。下面是这两种方法的实现代码和性能评估方法。

1. 暴力法（Brute Force）：
暴力法是检查每个数是否为素数的方法。对于每个数，我们需要检查它是否能被更小的数整除。以下是代码实现：

#include <iostream>
#include <cmath>

bool isPrime(int num) {
    if (num <= 1) return false;
    for (int i = 2; i <= sqrt(num); ++i) {
        if (num % i == 0) return false;
    }
    return true;
}

int countPrimes(int n) {
    int count = 0;
    for (int i = 1; i <= n; ++i) {
        if (isPrime(i)) {
            ++count;
        }
    }
    return count;
}

int main() {
    int n;
    std::cin >> n;
    std::cout << "Prime count from 1 to " << n << " is: " << countPrimes(n) << std::endl;
    return 0;
}

2. 埃拉托斯特尼筛法（Sieve of Eratosthenes）：
这是一种更加高效的算法，其基本思想是从最小的素数开始，找到所有的素数，并将这些素数的倍数标记为非素数。以下是代码实现：

#include <iostream>
#include <vector>

int countPrimes(int n) {
    std::vector<bool> prime(n+1, true);
    prime[0] = prime[1] = false;
    for (int i = 2; i * i <= n; ++i) {
        if (prime[i]) {
            for (int j = i * i; j <= n; j += i) {
                prime[j] = false;
            }
        }
    }
    int count = 0;
    for (int i = 2; i <= n; ++i) {
        if (prime[i]) {
            ++count;
        }
    }
    return count;
}

int main() {
    int n;
    std::cin >> n;
    std::cout << "Prime count from 1 to " << n << " is: " << countPrimes(n) << std::endl;
    return 0;
}

为了比较这两种算法的时间效率，我们可以记录它们的运行时间。在C++中，可以使用`<chrono>`库来测量时间。以下是测试代码的示例：

#include <chrono>
#include <iostream>

// ...（前面的函数实现）

int main() {
    int n;
    std::cin >> n;
    auto start = std::chrono::high_resolution_clock::now();
    std::cout << "Prime count from 1 to " << n << " is: " << countPrimes(n) << std::endl;
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = end - start;
    std::cout << "Time elapsed: " << elapsed.count() << " seconds" << std::endl;
    return 0;
}

请用c++代码编写如下问题的程序，如果一个素数是完美素数，当且仅当它的每一位数字只和也是一个素数，求〔1，n〕范围内完美素数的个数

以下是求解完美素数个数的 C++ 代码，使用了筛素数和判断数字各位数之和是否为素数的方法：

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

// 判断素数
bool is_prime(int n) {
    if (n <= 1) return false;
    int sqrtn = sqrt(n);
    for (int i = 2; i <= sqrtn; i++) {
        if (n % i == 0) return false;
    }
    return true;
}

// 判断各位数字之和是否为素数
bool is_sum_of_digits_prime(int n) {
    int sum = 0;
    while (n > 0) {
        sum += n % 10;
        n /= 10;
    }
    return is_prime(sum);
}

int main() {
    int n;
    cin >> n;

    // 筛素数
    vector<bool> isPrime(n+1, true);
    for (int i = 2; i <= sqrt(n); i++) {
        if (isPrime[i]) {
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }

    // 统计完美素数的个数
    int count = 0;
    for (int i = 2; i <= n; i++) {
        if (isPrime[i] && is_sum_of_digits_prime(i)) {
            count++;
        }
    }

    cout << count << endl;

    return 0;
}

其中，`is_prime` 函数用于判断一个数是否为素数，`is_sum_of_digits_prime` 函数用于判断一个数的各位数字之和是否为素数。在 `main` 函数中，首先读入输入的整数 `n`，然后使用筛素数的方法求出 `[1, n]` 范围内的所有素数，最后统计出完美素数的个数并输出。