CareerCup

1,000,000,000,039
...skipped 3612 lines...
1,000,000,099,841
---------------------
3,614,000,181,007,876

It takes 2 minute in my i5 PC.

bool isPrime(int n){
    if(n == 0 || n == 1)
        return false;

    if(n == 2)
        return true;

    if(n%2 == 0)
        return false;
    double squared = sqrt(n);

    int res = floor(squared);

    for(int i = 3; i < res; i++){
        if(n%i == 0)
            return false;
    }
    return true;
}

int main(){

  ulli res = 0;

   for(ulli i = 1000000000000; i < 1000000100000; i++){
      if(isPrime(i)){
        res += i;
      }
   }
   cout<<res;
}

One mistake, It's "for(ulli i = 3; i <= res; i++)"

Answer: 3,614,000,181,007,876

This C++ code will run in few seconds to get the answer (3 seconds on my i7 PC):

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;
//Shortcuts for laziness:
#define     FOR(i,s,e)      for(int (i) = (s); (i) <  (e); ++(i))
#define     REP(i,n)        FOR(i,0,n)
#define     lli              long long int

const int MILLION = 1000010;

bool Sieve[MILLION];
vector<int> Primes; // list of primes less than 1M;
int N;              // number of primes less than 1M;

void sieve(){
    int n = sqrt(MILLION) +1 ;
    REP(i, MILLION) Sieve[i] = true;

    Sieve[0] = Sieve[1] = false;
    FOR(i,2,n) if (Sieve[i])
        for(int j = i*i; j< MILLION; j+=i)
            Sieve[j] = false;

    FOR(i,2,MILLION)
        if (Sieve[i]) Primes.push_back(i);
    N = Primes.size();
    //FOR(i,2, 100) cout <<Primes[i] % 6<< " "; cout<<endl;
    return;
};

bool is_Prime(lli x){
    REP(i, N) if (x % Primes[i] == 0) return false;
    return true;
}

int main()
{
    sieve();

    lli sum = 0;
    lli LO = 1000000000000;
    lli HI = 1000000100000;

    lli k0 = LO/6;

    lli x = 6*k0+1;

    while(x<HI-6){
        if (is_Prime(x)) sum+= x;
        x+=4;
        if (is_Prime(x)) sum+= x;
        x+=2;
    }

    cout <<sum<<endl;

    return 0;
}

It is just a segment prime seive

typedef long long ll;

bool is_prime_aux[1000001];
bool is_prime[100001];

ll segment_seive(ll a, ll b)
{
	for (ll i = 0; i * i <= b; ++i) is_prime_aux[i] = true;
	
	for (int i = 0; i <= b - a; ++i) is_prime[i] = true;

	for (ll i = 2; i * i <= b; ++i)
	{
		if (is_prime_aux[i])
		{
			for (ll j = 2 * i; j * j <= b; j += i) is_prime_aux[j] = false;

			for (ll j = max(2LL, (a + i - 1) / i) * i; j < b; j += i) is_prime[j - a] = false;
		}
	}

	ll sum = 0;

	for (int i = 0; i <= b - a; ++i) sum += is_prime[i] ? a + i : 0;

	return sum;
}

The sum of prime numbers in the original range is given as 6,000,292.
The new range is a thousand (10^3) times larger and its starting point is a million (10^6) times higher.
So the sum of primes in the new range should be approximately 10^9 times the original sum, so about ~ 6 * 10^15.
That took about 5 seconds on my iBrain (faster than i7 ;-)