【编程思想】自顶向下 逐步求精

本文采用自顶向下逐步求精的方法,详细介绍了如何通过Java编程实现哥德巴赫猜想的验证过程。从整体思路出发,逐步细化到具体实现细节,包括如何拆分整数及判断质数。

【编程思想】自顶向下 逐步求精


面向过程化编程思想:自顶向下 逐步求精

从程序执行的过程入手,将完整的过程细化成多个子过程,再将子过程细化,直到完成代码。



我们来看一个程序需求:

验证哥德巴赫猜想任何一个大于 6 的偶数,都能分解成两个质数的和。质数,指的 是除了 1 和本身之外,没有别的因子的数。

要求:输入一个整数,输出这个数能被分解成哪两个质数的和。

例如 : 输入 14

14=3+11

14=7+7

这是一个比较复杂的程序。拿到这个程序的需求之后,首先应该先设计出程序的大体思路。

基本思路如下:

1、读入一个整数 n

2、把这个整数拆成两个数 a、b 的和

3、判断 a 是否是质数

4、判断 b 是否是质数 

5、如果 3、4 两个判断都为真,则输出 a 和 b 

6、如果这个整数还能拆分,则回到第 2 步。否则程序退出

很显然,2~6 步是一个循环,调整一下结构

如下: 读取整数 n 循环(把整数 n 拆成两个整数 a 和 b){

  判断 a 是否是质数

判断 b 是否是质数

如果 a、b 都是质数,则输出 a 和 b

}

在上面的基本思路中,我们可以看到,“判断 a 是否是质数”和“判断 b 是否是质数”这两步操作基本一样。因此,很显然,这里我们应该写出一个函数,这个函数能够判断一个整数是否是质数。

import java.util.Scanner;
public class TestGoldBach{
	public static void main(String args[]){
		//读入整数
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		循环{
			int a = 第一个整数
			int b = 第二个整数
		if (isPrime(a) && isPrime(b)){
		System.out.println(n + "=" + a + "+" + b);
				}
			}
	}
		//判断一个整数是否是质数
		public static boolean isPrime(int a){
	}
}

继续细化。现在我们关注的重点是两个:

1、如何把一个整数 n 拆成两个整数 a 和 b;

2、如何判断一个整数是质数。

  首先,我们来看拆数的逻辑。如果能够确定一个整数 a,则另外一个整数 b 也就确定 了,可以通过 b = n – a 这个式子计算出 b 的值。那么如果给出一个整数,如何确定 a 的值呢?我们可以先看一个例子。假设 n 为 14,则所有拆数的拆法是:

1 + 13

2 + 12

3 + 11

4 + 10

5 + 9

6 + 8

7 + 7

在往下就是重复的拆法了。这样,我们把第一个数当做 a,则 a 从 1 变化到 7,也就是 变化到 14/2。于是,我们拆数的循环就能够分析出来了:

for(int i = 1; i<=n/2; i++){
			int a = i;
			int b = n-i;
		if (isPrime(a) && isPrime(b)){
		System.out.println(n + "=" + a + "+" + b);
		}
	}

至此,主函数全部完成。接下来,完成 isPrime 方法。对于如何判断一个整数是否是质数,我们依然使用自顶向下,逐步求精的方式。由于质数,指的是除了 1 和本身之外,没 有其他的因子,因此判断一个整数 a 是否是质数,只要看 2~a-1 的范围内有没有 a 的因子就可以了。

因此,主要思路如下:

循环 i : 2~a-1{

如果 i是 a 的因子,则说明 a 不是质数 } 循环结束

则说明 2~a-1 都不是 a 的因子,因此 a 是质数

完整代码如下:

package p5;
import java.util.Scanner;
public class TestGoldBach2{
	public static void main(String args[]){
		//读入整数
		System.out.println("请输入一个整数");
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for(int i = 1; i<=n/2; i++){
			int a = i;
			int b = n-i;
			if (isPrime(a) && isPrime(b)){
				System.out.println(n + "=" + a + "+" + b);
				}
			}
	}
		//判断一个整数是否是质数
	public static boolean isPrime(int a){
		for(int i=2; i<= a-1; i++){
			if (a % i == 0) return false;
			}
				return true;
	}
}

运行结果如下:

### 回答问题 自顶向下逐步求精的模块化程序设计是一种结构化编程方法,广泛应用于C++程序开发中。这种方法的核心思想是从整体到局部、从抽象到具体地解决问题。以下是详细的解释和实现步骤: --- #### 1. **自顶向下的设计思想** - 自顶向下是指从高层次的抽象开始,逐步细化到具体的实现细节。 - 在程序设计中,首先定义程序的整体目标和功能,然后将其分解为多个子任务或模块,每个模块负责完成一部分功能。 #### 2. **逐步求精的过程** - 逐步求精是将复杂问题分解为更小、更简单的子问题的过程。 - 每一步都专注于解决当前层次的问题,同时忽略下层细节,直到达到可以直接实现的具体步骤。 #### 3. **模块化的意义** - 模块化是指将程序划分为多个独立的模块,每个模块完成特定的功能。 - 这种方法有助于提高代码的可读性、可维护性和复用性。 --- ### 示例代码 以下是一个使用自顶向下逐步求精方法设计的简单C++程序示例,该程序计算并输出一个整数数组的最大值。 ```cpp #include <iostream> #include <vector> using namespace std; // 函数声明 int findMax(const vector<int>& nums); void printResult(int maxVal); // 主函数 int main() { // 定义输入数组 vector<int> numbers = {3, 5, 7, 2, 8, -1, 4, 10, 12}; // 调用函数找到最大值 int maxValue = findMax(numbers); // 输出结果 printResult(maxValue); return 0; } // 找到数组中的最大值 int findMax(const vector<int>& nums) { if (nums.empty()) return INT32_MIN; // 如果数组为空,返回最小整数值 int maxVal = nums[0]; for (int num : nums) { if (num > maxVal) { maxVal = num; } } return maxVal; } // 输出最大值 void printResult(int maxVal) { cout << "The maximum value is: " << maxVal << endl; } ``` --- ### 解释 1. **自顶向下的设计过程**: - 首先定义程序的整体目标:计算并输出一个整数数组的最大值。 - 将问题分解为两个子任务: 1. 找到数组中的最大值(由 `findMax` 函数完成)。 2. 输出最大值(由 `printResult` 函数完成)。 2. **逐步求精的过程**: - 在主函数中,我们定义了一个数组,并调用 `findMax` 函数来找到最大值。 - `findMax` 函数通过遍历数组,逐步比较每个元素,找到最大值。 - 最后,`printResult` 函数负责格式化输出结果。 3. **模块化的优点**: - 程序被划分为三个独立的部分:主函数、`findMax` 和 `printResult`。 - 每个部分的功能明确且独立,便于测试和维护。 --- ### 相关问题
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值