final step: adding all the primes that the reverse are also primes - c

Question

like 17, is a prime, when reversed, 71 is also a prime.
We manage to arrive at this code but we cant finish it.
#include <stdio.h>
main()
{
int i = 10, j, c, sum, b, x, d, e, z, f, g;
printf("\nPrime numbers from 10 to 99 are the follwing:\n");
while (i <= 99)
{
c=0;
for (j = 1; j <= i; j++)
{
if (i % j == 0) c++;
}
if (c == 2)
{
b = i;
d = b / 10;
e = b - (10 * d);
x = (e * 10) + d;
{
z = 0;
f = x;
for (j = 1; j <= f; j++)
{
if (f % j == 0) z++;
}
if (z == 2)
{
printf("%d %d\n", i, f);
}
}
}
i++;
}
getch();
}
my problem is how to add all the fs..
the answer should be 429.
how can i add all the f?

Answer 1

Why don't you break up the code into some functions:
bool isPrime(int number) that checks if a number is prime.
int reverse(int number) that reverses the number.
Then the algorithm would be:
sum = 0;
for (i = 2; i <= 99; ++i)
if (isPrime(i) && isPrime(reverse(i)))
sum += i;

Answer 2

At the beginning initialize sum = 0;. Then, next to your printf count the prime: sum += i;. you can then print it at the end.

Answer 3

If this is a basic programming class and you are just interested in the result then this will get you there, however if it is an algorithms class then you may want to look at the Sieve of Eratosthenes.
You may also want to think about what makes a 2 digit number the reverse of another 2 digit number and how you would express that.

Answer 4

There are many problems in your code. None of them will prevent compilation and none of them will cause problems in getting the output. I'll first tell you how to get the result you want and then highlight the problems.
Here is your code, modified to sum fs. You just need to add f to sum every time you print a prime satisfying the condition. Finally, you should print the sum of all fs.
#include <stdio.h>
//Use int as the return type explicitly!
int main()
{
int i=10,j,c,sum,b,x,d,e,z,f,g;
printf("\nPrime numbers from 10 to 99 are the follwing:\n");
//Set the sum of all primes whose reverse are also primes to zero
sum = 0;
while(i<=99)
{
//c is tyhe number of factors.
c=0;
for(j=1;j<=i;j++)
{
if(i%j==0)
c++;
}
//If there are only two factors.
//Two factors (1 and itself) => Prime
if(c==2)
{
//Reverse i and store it in x
b=i;
d=b/10;
e=b-(10*d);
x=(e*10)+d;
//Curly braces unnecessary
{
//Check if the reverse i.e. x is prime
//z is the number of factors
z=0;
//f is the number being tested for primality.
f=x;
for(j=1;j<=f;j++)
{
if(f%j==0)
z++;
}
//If f i.e. x i.e. the reverse has only two factors
//Two factors (1 and itself) => Prime
if(z==2)
{
//print the prime number.
printf("%d %d \n",i,f);
//Add f to the sum
sum += f;
}//if(z==2)
}//Unnecessary braces
}//if(c==2)
i++;
}//end while
//print the number of reversed primes!!
//That is sum of the reversed values of numbers satisfying the
//condition!
printf("\nThe sum is:%d\n", sum);
//getch() is non standard and needs conio.h
//Use getchar() instead.
//Better solution needed!!
getchar();
//Return 0 - Success
return 0;
}
Output
...#...-desktop:~$ gcc -o temp temp.c
...#...-desktop:~$ ./temp
Prime numbers from 10 to 99 are the follwing:
11 11
13 31
17 71
31 13
37 73
71 17
73 37
79 97
97 79
The sum is:429
...#...desktop:~$
Do take note of all the comments made in the code (above). In addition, consider doing the following:
Removing the unnecessary braces.
Using one variable for one thing. (x could have been used instead of f).
Using better variable names like number and numberOfFactors.
Breaking up your code into functions as Mehrdad Afshari has suggested.
Consider testing primality by checking if there is a divisor of the number (num) being tested up to sqrt(num) (Square root of the number).
Consider this:
For numbers upto 99, the reversed numbers are also 2 digit numbers.
If the number is in the set of primes already found, you can verify easily.
This will reduce the number of checks for primality. (which are expensive)
To do the above, maintain a list of primes that have been identified (primeList)
as well as a list of reversed primes (revList). Any item in revList that is also
in primeList satisfies your condition. You can then easily obtain the sum (429)
that you need.
Look at sweet61's answer, the use of the Sieve of Eratosthenes with my method will definitely be much more efficient. You can reverse primes at the end of the sieve and populate the revList (at the end).
On a personal level, I try to find the best solution. I hope you will also attempt to do the same. I have tried to help you out without giving it all away.
I hope this helps.
Note
I had suggested checking for divisors up to num/2. I fixed it to sqrt(num) on vartec's suggestion.