# Prime Number Program in C using for Loop

In this article, we will know about the procedure of checking whether a natural number inputted by the user is a prime number or non-prime number.

### Definition of the prime number

A prime number is that positive integer or a natural number which can be divided only by 1 and by the number entered itself.

**Example of Prime Number:**

2, 3, 7, 11, 13, 17, 19, 23, 29 and so on.

### The syntax that can be used for the For loop in C programming language is given below:

```
for (initialization statement; termination condition; increment or decrement statement (used for modifying value for further evaluation))
{
/* main body of the “for” loop */
}
```

### Here we will let you know about the working of “for” loop in C:

In for loop, the initialization command is implemented only once. After that, it checks the test expression of the loop and finds whether the test expression is false or true. And, for loop is dismissed if the test expression is false.

If the test expression of the 'For loop becomes true, then the program line provided in the For loop’s body is executed, and the update expression is changed accordingly.

Again, the entire process of evaluation is to be done. The loop executes its body until and unless the value of the test expression in for loop becomes false. The loop automatically terminates as soon as the test expression result becomes false.

### Here is the following program whose code checks the given random natural number is prime or non-prime number:

```
#include <stdio.h>
int main()
{
int n, a, flag= 0; // declaring variables and initiating the value of flag as 0
printf("Enter any natural number: \n"); // taking input from the user
scanf("%d", &n); // assigning the value entered by the user to variable “n”
// note down, 0 and 1 are not considered as prime numbers
// that’s why providing value 1 for non-prime number flags (as flag=1)
if (n == 0 || n == 1) // using “or” operator and comparison operators
flag = 1; // assigning value to non-prime flags
for (a = 2; a <= n / 2; ++a) // (initialization statement; termination condition; increment or decrement statement)
{
// here we are declaring the fact that if the value of “n” is divisible by the value of “a”, in that case, “n” cannot be considered as a prime number
// for non-prime numbers we are going to set the value of flag as 1
if (n % a == 0) // n % a here means the remainder, when you divide the value of “n” by “a”
{
flag =1;
break; // break statement for ending the loop execution here
}
}
if (flag == 0)
printf("%d can be considered as a prime number.", n); // printing output for first situation
else
printf("%d cannot be considered as a prime number.", n); // printing output for first situation
return 0;
}
```

**Output:****Not prime number case:**

```
Enter any natural number:
14
14 cannot be considered as a prime number.
```

**Prime number case:**

```
Enter any natural number:
19
19 can be considered as a prime number.
```

**Explanation:**

In each iteration, there is a following IF condition which checks that n is perfectly divisible by a:

```
if (n % a == 0)
{
flag = 1;
break;
}
```

## If else:

If we talk about the “if” statement in c it is generally used for executing a conditional statement or a set of conditional statements.

The provided condition either be true or false. When the condition is true, then the execution of IF statements takes place. And, when the condition is false, then the execution of ELSE statements takes place.

### Syntax of IF ELSE:

```
if (condition)
statement(s);
else
statement(s);
```

We have to write a condition in the brackets with the IF keyword.

### Break statement:

If the “n” is perfectly divisible by value provided by the user, then “n” cannot be considered as a prime number.

In the loop, the value of flag is declared to be 1, and for terminating the loop we used the “break” statement.

The thing to be noticed is that the value of flag was initialized as 0 at the time of the commencement of the program.

So, if n is a prime number then the value of flag will always be 0 after the execution of entire for loop. Although, if the value of “n” is considered as a non-prime number, value of flag will be 1.