How do you write a java program to find a prime number?

Answer 1

#include<stdio.h>

bool is_prime (unsigned n) {

if (n<2) return false;

if (!(n%2)) return n==2;

unsigned max_factor = (unsigned) sqrt (n) + 1;

unsigned factor;

for (factor=3; factor<max_factor; ++factor) {

if (!(n%factor)) return false;

}

return true;

}

unsigned next_prime (unsigned n) {

while (!is_prime (++n));

return n;

}

int main() {

/* print the first 100 prime numbers */

unsigned i, n=0;

for (i=0; i<100; ++i) {

n = next_prime (n);

printf ("%d\n", n);

}

return 0;

}

Answer 2

#include<stdio.h>

#include<conio.h>

void main()

{

int no, i;

clrscr();

printf("\nEnter a number : \n");

scanf("%d", &no);

for(i=2;i<no;i++)

if(no%i==0)

break;

if(i==no)

printf("\nEntered Number %d is Prime", no);

else

printf("\nEntered Number %d is not a Prime number", no);

getch();

}

Answer 3

Use the following functions to test if a value is prime or not (to test negative values, use the absolute value):

// helper functions (test the state of LSB to determine if value is odd or even)

bool is_even (const unsigned value) {return (value&0x1)==0x0; }

bool is_odd (const unsigned value) {return (value&0x1)==0x1; }

bool is_prime (const unsigned value)

{

if (value<2) return false; // 0 and 1 are non-prime

if (is_even(value)) return value==2; // 2 is the only even prime

// Test all odd numbers from 3 to the square root of value, see if any are factors

unsigned number;

const unsigned max;

max=sqrt (value);

for (number=3; number<=max; number+=2)

{

if ((value%number)==0) return false; // number is a factor, value is non-prime

}

return true; // value is prime -- it has only 2 factors, 1 and itself

};

Answer 4

Any number that has one or more prime factors is a composite number. All others are prime numbers. Prime factors are themselves prime numbers, but rather than test every potential factor to determine if it is prime, it is much quicker to simply test every odd factor in the range 3 to the square root of the number. The only exception is even numbers which are all composite except 2.

Thus we use the following algorithm (for all positive integers):

1) If the number is less than 2 then the number is composite.

2) If the number is even then it is prime if it is 2 otherwise it is composite.

3) If the number is odd and is evenly divisible by any odd integer in the range 3 to the square root of the number (inclusive) then the number is composite.

4) All other numbers are prime.

To express this algorithm as a function in C++, we would use the following:

bool is_prime (unsigned value)

{

// algorithm part 1)

if (value<2)

return false;

// algorithm part 2)

if (!(value%2))

return value==2;

// algorithm part 3)

unsigned max_factor = (unsigned) sqrt (value) + 1;

for (unsigned factor=3; factor<max_factor; ++factor)

{

if (!(value%factor))

return false;

}

// algorithm part 4)

return true;

}

Answer 5

Basically, you have a number of which you want to figure out whether it is a prime number or not. If you are not given such a number, try out whether different numbers are prime numbers, until you find one that is a prime number.

A simple method is to divide your number by all possible factors, starting at 2, and up to the number itself. If the smallest factor is the number itself, then it is a prime number. If a smaller factor is found, then it is not. Here is one way you can do that:

boolean isPrime(int number) {

int factor;

for (factor = 2; number % factor != 0; factor++)

;

return number == factor;

}

Note that the "for" loop will continue running until a factor is found.

Also note that this is not the most efficient method; just one that is fairly easy to program.

Answer 6

You will need two functions for this, one to determine if a given number is prime or not, and another to find the next prime from a given number.

bool is_prime (const unsigned int num) {

if (num<2) return false;

if (!(num%2)) return num==2;

const unsigned int max_factor = sqrt (num) + 1;

for (unsigned int factor=3; factor<max_factor; factor+=2)

if (!(num%factor)) return false;

return true;

}

unsigned int next_prime (unsigned int num) {

while (!is_prime(++num));

return num;

}

int main (void) {

unsigned int num = 2;

do {

printf ("%d\n", num);

num = next_prime (num);

} while (num<=100);

return 0;

}

Answer 7

You should use modulus division, which gives you the remainder. In C++ modulus division uses the % sign.

For example:

5 % 2 = 1

4 % 2 = 0