Primes | Prime Number Projects in C # /C++/Python

The problem states that the answer should be in MOD 10^9+7 but you have mistakenly defined MOD as 10^8+7.

According to that error message, my_data->thread_id does not seem to have a value between 0 and NUM_THREADS - 1. It seems to have the value 1103437824. This is probably because my_data has become a dangling pointer, due to a race conditon.

my_data points into the t_d array in the main thread. However, the lifetime of that object ends as soon as the main thread calls pthread_exit. Therefore, after that happens, the other threads' my_data pointer becomes dangling, which means it no longer points to a valid object. Dereferencing such a pointer causes undefined behavior.

The best solution would probably be that the main thread calls pthread_join on all worker threads, before it returns from the function main or calls pthread_exit. That way, it is guaranteed that the lifetime of the main thread's t_d array exceeds the lifetime of the worker threads' my_data pointers, so that these pointers never become dangling.

I download and install OpenSSL 1.1.1 for Linux and it works without any issue

Yes, there is. Your algorithm searches for all primes in the interval. Let's consider the range between 1 and 1 000 000. That means that you will check for 1 000 000 numbers whether they are prime. That uses up a lot of storage resources, you unnecessarily store the primes between 1 and 1 000 000. It also wastes a lot of computational resources, since you unnecessarily compute this 1 000 000 times.

Instead, a much more efficient way to do this both in terms of storage and computation efficiency is to:

• find the first prime in the range via a loop starting from 2 (because 1 is not a prime, no need for check whether it's prime) and which stops when the first prime is found
• find the last prime in the range via a loop starting from total backwards (total, total - 1, ...) until you find the last prime and then the loop stops
• with the two very efficient loops above, you will know the first and the last prime if they exist
• if there is a first and a last prime, then compute their difference, otherwise return a default value, like 0

Excuse me for not writing code for you, but I'm not fluent in R.

There's many errors in your code including an empty array, use of pow (which is a floating-point function) and numerous logic errors that deviate from the wikipedia example code.

Here's a corrected, working version that follows the logic of the wikipedia version, with a loop afterwards to print out all the primes less than n:

You can't return "is not" until you've tried all of the combinations.

In your second for loop, you start with:

What you need is this :

Rust does not allow that in its model. You want AtomicBool with relaxed ordering.

This is a somewhat common edge case in most concurrency models - if you have two non-atomic writes of the same value to one location, is that well-defined? In Rust (and C++) it is not, and you need to explicitly use atomic.

On any platform you care about, the atomic bool store with relaxed ordering will have no impact.

For a reason why this matters, consider: