Finding sum of consecutive primes

Question

I am working on improving my C# skills, and in the process I am trying to solve some of the problems on Project Euler, in this case problem 50. The problem states:

The prime 41, can be written as the sum of six consecutive primes:

41 = 2 + 3 + 5 + 7 + 11 + 13 This is the longest sum of consecutive primes that adds to a prime below one- hundred.

The longest sum of consecutive primes below one-thousand that adds to a prime, contains 21 terms, and is equal to 953.

Which prime, below one-million, can be written as the sum of the most consecutive primes?

Seems simple enough. I wrote a method to tell if something is prime, made a list of the primes below 1 million (which is easily more than I need, but I don't know how many I actually need), and iterated through that list to find the sums of the primes. Here is my code:

public static void Main()
    {
        IEnumerable<int> primes = Enumerable.Range(0, 1000000)
            .Where(i => isPrime(i));

        int sum = 0;
        List<int> history = new List<int>();
        foreach (int bar in primes)
        {
            if (sum + bar < 1000000)
            {
                sum += bar;
                Console.WriteLine(sum);
                history.Add(bar);



            }

        }
        while (!isPrime(sum))
        {
            sum -= history[history.Count - 1];
            history.Remove(history[history.Count - 1]);
        }
        Console.WriteLine(sum);
        Console.ReadLine();
    }



    public static bool isPrime(int num)
    {
        if (num <= 1)
        {
            return false;
        }
        else if (num == 2)
        {
            return true;
        }
        else if (num % 2 == 0)
        {
            return false;
        }
        else
        {
            var boundary = (int)Math.Floor(Math.Sqrt(num));

            for (int i = boundary; i > 1; i--)
            {
                if (num % i == 0)
                {
                    return false;
                }
            }
            return true;
        }

    }

If I am correct, this should find the sum of my primes up to a million, then subtract primes until the sum is a prime number itself. When I run this, the code sums up to 997661, but that is not prime. I subtract the recently added primes until I get a result of 958577, which is prime, but this is not the correct answer. I am fairly certain my method to find primes is correct, but I cannot figure out what is causing my answer to be wrong. What's worse, I don't know the correct answer, so I can't work backwards to see what is causing the issue.

I suspect something may be broken inside of my while loop, like maybe I am removing the wrong values from the list. If anyone can offer some insight into why my program is not working, I would very much appreciate it.

Answer 1

class Example {
    public static void main(String[] args) {
        int count = 0;
        int sum = 0;
        for (int j = 2; j < 1000; j++) {
            count = 0;
            for (int i = 1; i <= j; i++) {
                if (j % i == 0) {
                    count++;
                }
            }
            if (count == 2) {
                sum += j;
                if (sum >= 1000) {
                    sum -= j;
                    break;
                }
            }

        }
        System.out.println("longest sum of consecutive primes that adds to a prime below 1000: " + sum);
    }
}

Answer 2

well i am improving my python skills and solved the question using python.I think the question might be wrong and i did the calculation manually.well here is my answer

The prime 41, can be written as the sum of six consecutive primes: 41 = 2 + 3 + 5 + 7 + 11 + 13

This is the longest sum of consecutive primes that adds to a prime below one-hundred. The longest sum of

The longest sum of consecutive primes below one-thousand that adds to a prime, contains 21 terms, and is equal to 953.

Which prime, below one-million, can be written as the sum of the most consecutive primes?

solution:- i tried to solve it in step by step process and here is my justification towards my assumption.

import sympy
sum=0
lst1=[]

for num in range(1,100):
    #isprime(n):return True when the num is prime and false when the num is composite
    if sympy.isprime(num) is True:
        sum+=num
        lst1.append(sum)

print("The sum list 1 is: ",lst1)

lst2=[]
for sum in lst1:
    if sum<100:
        if sympy.isprime(sum)==True:
            lst2.append(sum)
print("The list 2 is: ",lst2)
print("The required answer is :",max(lst2))

the longest sum of consecutive primes that adds to a prime below one-hundred is 41 enter image description here so similarly i changed the limits from 100 to 1000 as below..

    import sympy
sum=0
lst1=[]

for num in range(1,1000):
    #isprime(n):return True when the num is prime and false when the num is composite
    if sympy.isprime(num) is True:
        sum+=num
        lst1.append(sum)

print("The sum list 1 is: ",lst1)

lst2=[]
for sum in lst1:
    if sum<1000:
        if sympy.isprime(sum)==True:
            lst2.append(sum)
print("The list 2 is: ",lst2)
print("The required answer is :",max(lst2))

enter image description here here the answer is different which gave me 281 is the highest whereas in the question it was mentioned 953 to be actual answer. just by changing your upper limits from 1000 to 1000000 we get answer as 958577 enter image description here

EXPLANATION:when you add up manually u will get 963 instead of 953 which makes 963 a composite number.Therefore,i think there is a mistake in this question and maybe the developer gave a wrong answer or so.

Answer 3

1. Find the longest list of primes with a sum less than 1000000. That's the list that starts at 2 and goes as high as possible. Let the length of this list be L.

2. Now, iterate through all lists with sums less than 1000000, starting with the list of length L, then all lists of length L-1, then L-2, etc.

3. Stop when you get a prime sum.

About 1 in every 15 integers near 1000000 is prime, so you wont have to check very many lists, and of course you should make subsequent lists by adding and removing primes from the ends instead of recalculating the whole sum.