Given an array of limits. For every limit, find the prime number which can be written as the sum of the most consecutive primes smaller than or equal to limit.

The maximum possible value of a limit is 10^4.

**Example: **

Input : arr[] = {10, 30} Output : 5, 17 Explanation : There are two limit values 10 and 30. Below limit 10, 5 is sum of two consecutive primes, 2 and 3. 5 is the prime number which is sum of largest chain of consecutive below limit 10. Below limit 30, 17 is sum of four consecutive primes. 2 + 3 + 5 + 7 = 17

Below are steps.

- Find all prime numbers below a maximum limit (10^6) using Sieve of Sundaram and store them in primes[].
- Construct a prefix sum array
**prime_sum[]**for all prime numbers in primes[]

prime_sum[i+1] = prime_sum[i] + primes[i].

Difference between two values in prime_sum[i] and prime_sum[j] represents sum of consecutive primes from index i to index j. - Traverse two loops , outer loop from i (0 to limit) and inner loop from j (0 to i)
- For every i, inner loop traverse (0 to i), we check if current sum of consecutive primes (
**consSum**= prime_sum[i] – prime_sum[j]) is prime number or not (we search consSum in prime[] using Binary search). - If consSum is prime number then we update the result if the current length is more than length of current result.

Below is implementation of above steps.

## C++

`// C++ program to find Longest Sum of consecutive` `// primes` `#include<bits/stdc++.h>` `using` `namespace` `std;` `const` `int` `MAX = 10000;` `// utility function for sieve of sundaram` `void` `sieveSundaram(vector <` `int` `> &primes)` `{` ` ` `// In general Sieve of Sundaram, produces primes smaller` ` ` `// than (2*x + 2) for a number given number x. Since` ` ` `// we want primes smaller than MAX, we reduce MAX to half` ` ` `// This array is used to separate numbers of the form` ` ` `// i+j+2ij from others where 1 <= i <= j` ` ` `bool` `marked[MAX/2 + 1] = {0};` ` ` `// Main logic of Sundaram. Mark all numbers which` ` ` `// do not generate prime number by doing 2*i+1` ` ` `for` `(` `int` `i=1; i<=(` `sqrt` `(MAX)-1)/2; i++)` ` ` `for` `(` `int` `j=(i*(i+1))<<1; j<=MAX/2; j=j+2*i+1)` ` ` `marked[j] = ` `true` `;` ` ` `// Since 2 is a prime number` ` ` `primes.push_back(2);` ` ` `// Print other primes. Remaining primes are of the` ` ` `// form 2*i + 1 such that marked[i] is false.` ` ` `for` `(` `int` `i=1; i<=MAX/2; i++)` ` ` `if` `(marked[i] == ` `false` `)` ` ` `primes.push_back(2*i + 1);` `}` `// function find the prime number which can be written` `// as the sum of the most consecutive primes` `int` `LSCPUtil(` `int` `limit, vector<` `int` `> &prime, ` `long` `long` `int` `sum_prime[])` `{` ` ` `// To store maximum length of consecutive primes that can` ` ` `// sum to a limit` ` ` `int` `max_length = -1;` ` ` `// The prime number (or result) that can be reprsented as` ` ` `// sum of maximum number of primes.` ` ` `int` `prime_number = -1;` ` ` `// Conisder all lengths of consecutive primes below limit.` ` ` `for` `(` `int` `i=0; prime[i]<=limit; i++)` ` ` `{` ` ` `for` `(` `int` `j=0; j<i; j++)` ` ` `{` ` ` `// if we cross the limit, then break the loop` ` ` `if` `(sum_prime[i] - sum_prime[j] > limit)` ` ` `break` `;` ` ` `// sum_prime[i]-sum_prime[j] is prime number or not` ` ` `long` `long` `int` `consSum = sum_prime[i] - sum_prime[j];` ` ` `// Check if sum of current length of consecutives is` ` ` `// prime or not.` ` ` `if` `(binary_search(prime.begin(), prime.end(), consSum))` ` ` `{` ` ` `// update the length and prime number` ` ` `if` `(max_length < i-j+1)` ` ` `{` ` ` `max_length = i-j+1;` ` ` `prime_number = consSum;` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `return` `prime_number;` `}` `// Returns the prime number that can written as sum` `// of longest chain of consecutive primes.` `void` `LSCP(` `int` `arr[], ` `int` `n)` `{` ` ` `// Store prime number in vector` ` ` `vector<` `int` `> primes;` ` ` `sieveSundaram(primes);` ` ` `long` `long` `int` `sum_prime[primes.size() + 1];` ` ` `// Calculate sum of prime numbers and store them` ` ` `// in sum_prime array. sum_prime[i] stores sum of` ` ` `// prime numbers from primes[0] to primes[i-1]` ` ` `sum_prime[0] = 0;` ` ` `for` `(` `int` `i = 1 ; i <= primes.size(); i++)` ` ` `sum_prime[i] = primes[i-1] + sum_prime[i-1];` ` ` `// Process all queries one by one` ` ` `for` `(` `int` `i=0; i<n; i++)` ` ` `cout << LSCPUtil(arr[i], primes, sum_prime) << ` `" "` `;` `}` `// Driver program` `int` `main()` `{` ` ` `int` `arr[] = {10, 30, 40, 50, 1000};` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` `LSCP(arr, n);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## C#

`// C# program to find longest sum ` `// of consecutive primes` `using` `System;` `using` `System.Collections;` `class` `GFG{` ` ` `static` `int` `MAX = 10000;` `// Store prime number in vector` `static` `ArrayList primes = ` `new` `ArrayList();` `// Utility function for sieve of sundaram` `static` `void` `sieveSundaram()` `{` ` ` ` ` `// In general Sieve of Sundaram,` ` ` `// produces primes smaller than` ` ` `// (2*x + 2) for a number given ` ` ` `// number x. Since we want primes ` ` ` `// smaller than MAX, we reduce MAX` ` ` `// to half. This array is used to ` ` ` `// separate numbers of the form` ` ` `// i+j+2ij from others where 1 <= i <= j` ` ` `bool` `[]marked = ` `new` `bool` `[MAX / 2 + 1];` ` ` `Array.Fill(marked, ` `false` `);` ` ` ` ` `// Main logic of Sundaram. Mark ` ` ` `// all numbers which do not ` ` ` `// generate prime number by ` ` ` `// doing 2*i+1` ` ` `for` `(` `int` `i = 1;` ` ` `i <= (Math.Sqrt(MAX) - 1) / 2; i++)` ` ` `for` `(` `int` `j = (i * (i + 1)) << 1; ` ` ` `j <= MAX / 2;` ` ` `j = j + 2 * i + 1)` ` ` `marked[j] = ` `true` `;` ` ` ` ` `// Since 2 is a prime number` ` ` `primes.Add(2);` ` ` ` ` `// Print other primes. Remaining ` ` ` `// primes are of the form ` ` ` `// 2*i + 1 such that marked[i] is false.` ` ` `for` `(` `int` `i = 1; i <= MAX / 2; i++)` ` ` `if` `(marked[i] == ` `false` `)` ` ` `primes.Add(2 * i + 1);` `}` ` ` `// Function find the prime number` `// which can be written as the ` `// sum of the most consecutive primes` `static` `int` `LSCPUtil(` `int` `limit, ` `long` `[]sum_prime)` `{` ` ` ` ` `// To store maximum length of` ` ` `// consecutive primes that can` ` ` `// sum to a limit` ` ` `int` `max_length = -1;` ` ` ` ` `// The prime number (or result) ` ` ` `// that can be reprsented as` ` ` `// sum of maximum number of primes.` ` ` `int` `prime_number = -1;` ` ` ` ` `// Conisder all lengths of ` ` ` `// consecutive primes below limit.` ` ` `for` `(` `int` `i = 0; (` `int` `)primes[i] <= limit; i++)` ` ` `{` ` ` `for` `(` `int` `j = 0; j < i; j++)` ` ` `{` ` ` ` ` `// If we cross the limit, then` ` ` `// break the loop` ` ` `if` `(sum_prime[i] - sum_prime[j] > ` ` ` `limit)` ` ` `break` `;` ` ` ` ` `// sum_prime[i]-sum_prime[j] is` ` ` `// prime number or not` ` ` `long` `consSum = sum_prime[i] - ` ` ` `sum_prime[j];` ` ` ` ` `int` `[] prime = (` `int` `[])primes.ToArray(` `typeof` `(` `int` `));` ` ` ` ` `// Check if sum of current length ` ` ` `// of consecutives is prime or not.` ` ` `if` `(Array.BinarySearch(prime, ` ` ` `(` `int` `)consSum) >= 0)` ` ` `{` ` ` ` ` `// Update the length and prime number` ` ` `if` `(max_length < i - j + 1)` ` ` `{` ` ` `max_length = i - j + 1;` ` ` `prime_number = (` `int` `)consSum;` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` `return` `prime_number;` `}` ` ` `// Returns the prime number that ` `// can written as sum of longest` `// chain of consecutive primes.` `static` `void` `LSCP(` `int` `[]arr, ` `int` `n)` `{` ` ` `sieveSundaram();` ` ` ` ` `long` `[]sum_prime = ` `new` `long` `[primes.Count + 1];` ` ` ` ` `// Calculate sum of prime numbers` ` ` `// and store them in sum_prime ` ` ` `// array. sum_prime[i] stores sum ` ` ` `// of prime numbers from ` ` ` `// primes[0] to primes[i-1]` ` ` `sum_prime[0] = 0;` ` ` `for` `(` `int` `i = 1; i <= primes.Count; i++)` ` ` `sum_prime[i] = (` `int` `)primes[i - 1] + ` ` ` `sum_prime[i - 1];` ` ` ` ` `// Process all queries one by one` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `Console.Write(LSCPUtil(` ` ` `arr[i], sum_prime) + ` `" "` `);` `}` `// Driver code` `public` `static` `void` `Main(` `string` `[]arg)` `{` ` ` `int` `[]arr = { 10, 30, 40, 50, 1000 };` ` ` `int` `n = arr.Length;` ` ` ` ` `LSCP(arr, n);` `}` `}` `// This code is contributed by rutvik_56` |

*chevron_right*

*filter_none*

**Output: **

5 17 17 41 953

This article is contributed by **Nishant_singh (pintu)**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Count primes that can be expressed as sum of two consecutive primes and 1
- Count of primes below N which can be expressed as the sum of two primes
- Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
- Count prime numbers that can be expressed as sum of consecutive prime numbers
- Check if a number can be written as a sum of 'k' prime numbers
- Check if a number can be written as sum of three consecutive integers
- Count numbers which can be represented as sum of same parity primes
- Length of largest sub-array having primes strictly greater than non-primes
- Nth Term of a Fibonacci Series of Primes formed by concatenating pairs of Primes in a given range
- Find if n can be written as product of k numbers
- Generate a Binary String without any consecutive 0's and at most K consecutive 1's
- Check if a prime number can be expressed as sum of two Prime Numbers
- K-Primes (Numbers with k prime factors) in a range
- Check if the sum of primes is divisible by any prime from the array
- Check if an integer can be expressed as a sum of two semi-primes
- Check if all nodes of the Binary Tree can be represented as sum of two primes
- Count of primes in a given range that can be expressed as sum of perfect squares
- Absolute Difference between the Sum of Non-Prime numbers and Prime numbers of an Array
- Elements of Array which can be expressed as power of prime numbers
- Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible