sieve_of_eratosthenes | python function for finding prime numbers

This is a question about Python internals. The following code is taken from this video about laziness in python:

Im currently trying to implement a version of the sieve of eratosthenes for a Kattis problem, however, I am running into some memory constraints that my implementation wont pass.

Here is a link to the problem statement. In short the problem wants me to first return the amount of primes less or equal to n and then solve for a certain number of queries if a number i is a prime or not. There is a constraint of 50 MB memory usage as well as only using the standard libraries of python (no numpy etc). The memory constraint is where I am stuck.

Here is my code so far:

I have a function that It has to be in size_t* type. When all size_t types are declared as integers, all it works perfect. When I change the decleration to size_t it doesn't run with this fail Aborted (core dumped). If i change all size_t* to int no problem happens.

That's the function:

I'm trying to write a program in prolog that finds all prime numbers up to a limit N, I'm trying to achieve this by using the Sieve of Eratosthenes. I'm very new to prolog so I haven't really mastered the art of thinking recursively (you can probably see that in my code).

Nonetheless, I (more or less) tried implementing the algorithm in prolog, but didn't get very far as you'll see here:

I wanted to code a prime number generator in python - I've only done this in C and Java. I did the following. I used an integer bitmap as an array. Performance of the algorithm should increase nlog(log(n)) but I am seeing exponential increase in cost/time as the problem size n increases. Is this something obvious I am not seeing or don't know about python as integers grow larger than practical? I am using python-3.8.3.

I'm playing around with the multiprocessing module in python and trying to parallelize an algorithm that loops through an list with a different increment value each time (modification of the Sieve of Eratosthenes algorithm). Therefore, I want to have a shared list between all of the processes so that all the processes are modifying the same list. I've tried with the multiprocessing.Array function, but when I reach the end of the program the array is still unmodified and still contains all 0's (the value that I initialized it to).

I am creating a sieve of Eratosthenes in order to sum more efficiently the prime numbers between 1 and a large number n. What I want to do is to create a list from 2 to n, and then remove the multiples of 2, then the multiples of 3, then the multiples of the next number in the list, and so on. The code I have created I think it has very slow performance in time, it is almost like creating a list by checking if each entry is a prime number. I guess the number of operations that I have is of order: square root of n (the first while loop) times (a bit less than) square root of n (for the second while loop). So I am not sure if the remove method or maybe other thing is slowing it down.

My code is this one:

I wrote two prime finder functions and the sieve only performs about 10% better. I'm using two optimizations for the simple version.

• Don't check even numbers
• Only check up to the square root or j * j <= i. ( equivalent )

and one optimization for the sieve version

• Only check up to the square root or i * i <= n. ( equivalent )

What optimizations can I add to the sieve?

My sieve is pretty slow. I don't want to do a bitwise implementation yet, I want to understand if this implementation offers any benefits.

Or if I missed an implementation point.

The inner for loop in the pseudocode here looks interesting / odd

https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

I don't know how to interpret it. (update: the OP seems to indicate in the comments that it was an issue with incorrect formatting after copy-pasting the pseudocode from Wikipedia, and with the corrected formatting it is clear now)

Here it is:

algorithm Sieve of Eratosthenes is:

...