题目：

使用 试除法 打印100~200之间的素数。

              

素数（质数）：一个数只能被写成一和本身的积。

如：7只能写成1*7，那就是素数（质数）了。

 =========================================================================

思路一：使用试除法

总体思路：

（一）. 使用外循环：生成 100~200 之间的数。

                     

（二）. 设置内循环：生成 2 ~ i-1 的数。

                  

（三）. 在内循环中设置 if条件判断语句，

                 

判断 i 是否为素数：

用 2 到 i-1 之间的数字去试除 i，如果能整除则 i 不是素数；

2 到 i-1 之间的数字都不能整除 i ，则 i 是素数。

                   

（四）. 判断完后，根据变量flag的值，判断是不是素数，是则打印出来。

                

---

                 

第一步：

（1）. 使用外循环：生成 100~200 之间的素数。

              

（2）. 设置一个 变量flag ，flag 为 1 则 i 是素数，flag 为 0 则 i 不是素数。

                     

实现代码：

#include <stdio.h>
int main()
{
	int i = 0; //循环变量
	for (i = 100; i <= 200; i++) //生成 100~200 之间的素数
	{
		int flag = 1; //设置变量flag

	}


	return 0;
}

实现图片：

                 

---

                 

第二步：

设置内循环：生成 2 ~ i-1 的数。

                     

实现代码：

#include <stdio.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 100; i <= 200; i++) //生成 100~200 之间的素数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= i - 1; j++) //设置内循环：生成 2~i-1 的数
		{

		}
	}


	return 0;
}

实现图片：

                 

---

                 

第三步：

（1）. 在内循环中设置 if条件判断语句。

                   

（2）. 判断 i 是否为素数：

用 2 到 i-1 之间的数字去试除 i，如果能整除则 i 不是素数；

2 到 i-1 之间的数字都不能整除 i ，则 i 是素数。

                     

实现代码：

#include <stdio.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 100; i <= 200; i++) //生成 100~200 之间的素数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= i - 1; j++) //设置内循环：生成 2~i-1 的数
		{

			if (i % j == 0) //在内循环中设置 if条件判断语句，判断i是否为素数
			//用 i 模上一个 j，看 j 能不能整除 i ，有余数则表示不能整除
			{
				flag = 0; //flag == 0,则i不是素数
				break;
				//只要有一个 j 把 i 整除了，说明 i 已经不是素数了，
				//所以不用再继续循环了，使用break跳出循环。
			}

		}


	}


	return 0;
}

实现图片：

                 

---

                 

第四步：

判断完后，根据变量flag的值，判断 i 是不是素数，是则打印出来。

                     

实现代码：

#include <stdio.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 100; i <= 200; i++) //生成 100~200 之间的素数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= i - 1; j++) //设置内循环：生成 2~i-1 的数
		{

			if (i % j == 0) //在内循环中设置 if条件判断语句，判断i是否为素数
			//用 i 模上一个 j，看 j 能不能整除 i ，有余数则表示不能整除
			{
				flag = 0; //flag == 0,则i不是素数
				break;
				//只要有一个 j 把 i 整除了，说明 i 已经不是素数了，
				//所以不用再继续循环了，使用break跳出循环。
			}

		}

		if (flag == 1) //循环判断完后，根据变量的值，判断i是不是素数，是则打印
		{
			printf("%d ", i);
		}
	}


	return 0;
}

实现图片：

思路一：最终代码和实现效果

最终代码：

#include <stdio.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 100; i <= 200; i++) //生成 100~200 之间的素数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= i - 1; j++) //设置内循环：生成 2~i-1 的数
		{

			if (i % j == 0) //在内循环中设置 if条件判断语句，判断i是否为素数
			//用 i 模上一个 j，看 j 能不能整除 i ，有余数则表示不能整除
			{
				flag = 0; //flag == 0,则i不是素数
				break;
				//只要有一个 j 把 i 整除了，说明 i 已经不是素数了，
				//所以不用再继续循环了，使用break跳出循环。
			}

		}

		if (flag == 1) //循环判断完后，根据变量的值，判断i是不是素数，是则打印
		{
			printf("%d ", i);
		}
	}


	return 0;
}

实现效果：

总结：

（1）. 锻炼对外循环和内循环的使用，对内外循环变量的调用。

            

（2）. 试除法：利用 % ，看余数情况，灵活运用。

 =========================================================================

思路二：

总体思路：

因为偶数除了 2 都不是素数，且题目范围中没有 2 ，

所以可以只生成 100~200 之间的奇数，可以排除一半的数字，

效率提升一倍。

                      

---

                     

第一步：

只需要在思路一的基础上，

改变外循环的 初始化部分 和 调整部分 即可，

使外循环只生成 100~200 之间的奇数。

                     

实现代码：

#include <stdio.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 101; i <= 200; i+=2) //生成 100~200 之间的奇数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= i - 1; j++) //设置内循环：生成 2~i-1 的数
		{

			if (i % j == 0) //在内循环中设置 if条件判断语句，判断i是否为素数
				//用 i 模上一个 j，看 j 能不能整除 i ，有余数则表示不能整除
			{
				flag = 0; //flag == 0,则i不是素数
				break;
				//只要有一个 j 把 i 整除了，说明 i 已经不是素数了，
				//所以不用再继续循环了，使用break跳出循环。
			}

		}

		if (flag == 1) //循环判断完后，根据变量的值，判断i是不是素数，是则打印
		{
			printf("%d ", i);
		}
	}


	return 0;
}

实现图片：

思路二：最终代码和实现效果

最终代码：

#include <stdio.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 101; i <= 200; i+=2) //生成 100~200 之间的奇数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= i - 1; j++) //设置内循环：生成 2~i-1 的数
		{

			if (i % j == 0) //在内循环中设置 if条件判断语句，判断i是否为素数
				//用 i 模上一个 j，看 j 能不能整除 i ，有余数则表示不能整除
			{
				flag = 0; //flag == 0,则i不是素数
				break;
				//只要有一个 j 把 i 整除了，说明 i 已经不是素数了，
				//所以不用再继续循环了，使用break跳出循环。
			}

		}

		if (flag == 1) //循环判断完后，根据变量的值，判断i是不是素数，是则打印
		{
			printf("%d ", i);
		}
	}


	return 0;
}

实现效果：

 =========================================================================

思路三：

总体思路：

一个数：k ，

如果有 k = m * n ，

那么一定有 m 或 n 小于 根号k ，

那么可以把之前的 2 ~ i-1

换成 sqrt(i) ，即根号 i，

进一步提高效率。

                   

---

                     

第一步：

只需要在思路二的基础上，

改变内循环的 判断条件部分 即可，

使内循环执行次数减少。

                     

实现代码：

#include <stdio.h>
#include <math.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 101; i <= 200; i += 2) //生成 100~200 之间的奇数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= sqrt(i); j++) //设置内循环：生成 2~i-1 的数
		{

			if (i % j == 0) //在内循环中设置 if条件判断语句，判断i是否为素数
				//用 i 模上一个 j，看 j 能不能整除 i ，有余数则表示不能整除
			{
				flag = 0; //flag == 0,则i不是素数
				break;
				//只要有一个 j 把 i 整除了，说明 i 已经不是素数了，
				//所以不用再继续循环了，使用break跳出循环。
			}

		}

		if (flag == 1) //循环判断完后，根据变量的值，判断i是不是素数，是则打印
		{
			printf("%d ", i);
		}
	}


	return 0;
}

实现图片：

思路三：最终代码和实现效果

最终代码：

#include <stdio.h>
#include <math.h>
int main()
{
	int i = 0; //外循环变量
	for (i = 101; i <= 200; i += 2) //生成 100~200 之间的奇数
	{
		int flag = 1; //设置变量flag

		int j = 0; //内循环变量
		for (j = 2; j <= sqrt(i); j++) //设置内循环：生成 2~i-1 的数
		{

			if (i % j == 0) //在内循环中设置 if条件判断语句，判断i是否为素数
				//用 i 模上一个 j，看 j 能不能整除 i ，有余数则表示不能整除
			{
				flag = 0; //flag == 0,则i不是素数
				break;
				//只要有一个 j 把 i 整除了，说明 i 已经不是素数了，
				//所以不用再继续循环了，使用break跳出循环。
			}

		}

		if (flag == 1) //循环判断完后，根据变量的值，判断i是不是素数，是则打印
		{
			printf("%d ", i);
		}
	}


	return 0;
}

实现效果：