int main() {
unsigned char* comp = primesieve(P);
unsigned long long p, n, k, m, count = 0;
// By generating such primes under 100 by brute force, a pattern becomes
// apparent:
// n^3 + n^2 * p = m^3
// n = k^3 for k = {1, 2, 3, ...}
// m = k^3 + k^2 = n + k^2
// p = (m^3 - n^3) / n^2 --> reduces down to p = 3(k^2 + k) + 1
// From here, it is sufficient to iterate over positive integers k,
// deriving n, m, and p, and checking p for primeness.
// If p is prime, relationship holds, otherwise skip this k/n.
for (k = 1, p = 3 * (k*k + k) + 1; p < P; ++k, p = 3 * (k*k + k) + 1) {
if (! comp[p]) {
n = k*k*k;
m = k*k + n;
printf("%llu^3 + %llu^2 * %llu = %llu^3\n", n, n, p, m);
++count;
}
}
printf("%llu primes < %llu have this property.\n", count, P);
free(comp);
return 0;
}
int main () {
const ulong limit = 100000000; ulong c = 0;
std::vector<bool> primesieve (limit, 0), sieve (limit, 1);
primesieve[2], primesieve[3] = 1;
for (ulong x = 1; x < sqrt (limit); x++) {
for (ulong y = 1; y < sqrt (limit); y++) {
ulong n = 4*x*x+y*y;
if (n <= limit && (n % 12 == 1 || n % 12 == 5)) {
primesieve[n] = !primesieve[n];
}
n = 3*x*x+y*y;
if (n <= limit && n % 12 == 7) {
primesieve[n] = !primesieve[n];
}
n = 3*x*x-y*y;
if (x > y && n <= limit && n % 12 == 11) {
primesieve[n] = !primesieve[n];
}
}
}
for (ulong n = 5; n < sqrt (limit); n++) {
if (primesieve[n]) {
ulong nn = n*n;
for (ulong i = nn; i < limit; i += nn) {
primesieve[i] = 0;
}
}
}
for (ulong i = 2; i <= limit; ++i) {
ulong ii = i;
while (ii < limit) {
if (!primesieve[i+ii/i]) {
sieve[ii] = 0;
}
ii += i;
}
}
for (ulong i = 1; i < limit; ++i) {
if (sieve[i]) { c += i; }
}
std::cout << c << std::endl;
return 0;
}
int main() {
// It appears that the solution to the problem is given by the sum of all
// totients of d:
// # elements = SUM(phi(d)) for d in {2..1000000}
// Prime sieve for use in totient calculation prime factorization.
unsigned char* comp = primesieve(D+1);
unsigned long long int d, p, f, phi, sum = 0;
for (d = 2; d <= D; ++d) {
// Totient of a prime number d = d - 1.
if (! comp[d]) {
sum += d - 1;
// printf("phi(%llu) = %llu\n", d, d-1);
}
else {
// Produce prime factorization of d.
phi = p = d;
if (d % 2 == 0) {
phi /= 2;
p /= 2;
}
for (f = 3; f <= p; f += 2)
if (! comp[f])
if (d % f == 0) {
phi = phi * (f - 1) / f;
p /= f;
}
sum += phi;
// if (d % 10000 == 0)
// printf("phi(%llu) = %llu\n", d, phi);
}
}
printf("%llu reduced proper fractions for d <= %llu.\n", sum, D);
free(comp);
return 0;
}
int main() {
unsigned char* comp = primesieve(I);
unsigned char* found = (unsigned char*) calloc(M, sizeof(unsigned char));
unsigned long long count = 0;
int i, j, k;
for (i = 2; i < I; ++i)
if (! comp[i])
for (j = 2; j < J; ++j)
if (! comp[j])
for (k = 2; i*i + j*j*j + k*k*k*k < M; ++k)
if (! comp[k]) {
if (! found[i*i + j*j*j + k*k*k*k])
++count;
++found[i*i + j*j*j + k*k*k*k];
}
printf("Numbers expressible as the sum of a prime square, prime cube,\n"
"and prime fourth power below %llu: %llu\n", M, count);
free(comp);
return 0;
}
