C++代码札记(二)猴子吃桃问题、输入10个数字,输出其中最大的3个数字。



/*编程  猴子吃桃问题      猴子第一天摘下若干个桃子当机吃了一半还不过瘾又吃了一个  以后每天早上吃前天剩下的一半零一个  第十天早上想吃发现就剩一个 求第一天共摘了几个*/

 

int 桃子(1), 天(10);
do
{
 桃子 += 1;
 桃子 *= 2;
} while (--天 > 1);
std::cout << 桃子 << endl;

int 递归猴子吃桃(int 天数, int 数量)
{
	if (--天数 < 1)return 数量;
	++数量;
	数量 *= 2;
	递归猴子吃桃(天数, 数量);
}

另一题目点这查看

 

分析后设计起来好简单, 错了 ? 如果您发现错误不妨大胆发表评论, 那样我会很高兴感谢您.

 

	int 序(0), 转存[10]{0}, 三大数[3]{0};
	do
	{
		std::cout << "输入10个数字,输出其中最大的3个数字 #" << 序 + 1 << ":";
		std::cin >> 转存[序++];
	} while (序<10);
	do
	{
		if (转存[--序] > 三大数[0])
		{
			三大数[2] = 三大数[1];
			三大数[1] = 三大数[0]; 
			三大数[0] = 转存[序]; 
		}
		if (三大数[0] > 转存[序] && 转存[序] > 三大数[1])
		{
			三大数[2] = 三大数[1];
			三大数[1] = 转存[序];
		}
		if (三大数[1] > 转存[序] && 转存[序] > 三大数[2])
			三大数[2] = 转存[序];
		
	} while (序);
	std::cout << 三大数[0] << ":" << 三大数[1] << ":" << 三大数[2];

 

 

 

 

最后优化代码:

 

	int 序(0), 输入数(0), 三大数[3]{0};
	do
	{
		std::cout << "输入10个数字,输出其中最大的3个数字 #" << 序 + 1 << ":";
		std::cin >> 输入数;
		if (输入数 > 三大数[0])
		{
			三大数[2] = 三大数[1];
			三大数[1] = 三大数[0]; 
			三大数[0] = 输入数;
		}
		if (三大数[0] > 输入数 && 输入数 > 三大数[1])
		{
			三大数[2] = 三大数[1];
			三大数[1] = 输入数;
		}
		if (三大数[1] > 输入数 && 输入数 > 三大数[2])
			三大数[2] = 输入数;
		
	} while (++序 < 10);
	std::cout << 三大数[0] << ":" << 三大数[1] << ":" << 三大数[2];

 

 

 

 

如果觉得之上代码有重复，太初级，那么，还可以用归纳法优化书写语句：

 

	int 序(0), 输入数(0), 三大数[3] = {0};
	do
	{
		std::cout << "输入10个数字,输出其中最大的3个数字 #" << 序 + 1 << ":";
		std::cin >> 输入数;
		int 列 = (输入数 > 三大数[0]) ? 0 : 
			(三大数[0] > 输入数 && 输入数 > 三大数[1]) ? 1 : 
			(三大数[1] > 输入数 && 输入数 > 三大数[2]) ? 2 : -1;
		if(列 >= 0)
		{
			int 排 = 2;
			while(排 - 列)
				三大数[排] = 三大数[排-- - 1];
			三大数[列] = 输入数;
		}
	} while (++序 < 10);
	std::cout << 三大数[0] << ":" << 三大数[1] << ":" << 三大数[2];

 

 

 

演变后的代码看起来是不是更高档和专业

 

或许有人认为即使优化到这里看整个程序也不怎么地，我也这样认为，它还可以继续优化，甚至扩展得更好，可发明出一种新的排序法来，那么，就让我来实现它，完美它。

	const int 输出个数(4), 数组长度(10);
	int 序(0), 输出数(0), 输入数(0), 三大数[输出个数] = { INT_MIN };
	do
	{
		std::cout << "输入" << 数组长度 <<"个数字,输出其中最大的" << 输出个数 <<"个数字 #" << 序 + 1 << ":";
		std::cin >> 输入数;
		int 列 = 0, 排序 = 输出个数 - 1; bool 控制(false);
		do
		{
			if (输入数 > 三大数[列])
			{ 
				控制 = true;
				break;
			}
		} while (列++ < 排序);
		if (控制)
		{
			while (排序 - 列)
				三大数[排序] = 三大数[排序-- - 1];
			三大数[列] = 输入数;
		}
	} while (++序 < 数组长度);
	do
	{
		std::cout << 三大数[输出数];
		if (输出数++ < 输出个数 - 1) std::cout << ":";
	} while (输出数 < 输出个数);

我已经完美地扩展它的功能，它已经不仅仅是能排序，还能控制输出个数的排序，是其他排序所没有的功能。

可以随意更改常量变量[个数]的值达到整个数组排序输出，可以写成一个函数，我设计到这里就完成了，写成函数就不写了，留给后生一点空间吧，至于后人如何使用，留给将来人了。

关于效率可以推测比冒泡要好，也是动态的，就不做测试了，都留给将来人去评论吧，设计出来了我很高兴。

至于它有何作用就不多说了，至少可以看到程序是如何演化的一个过程。

突发奇思给我这个控制排序起名：龙云排序。

如果把上面程序中的语句做更改就可以达成输出最小值的排序了：三大数[输出个数] = { INT_MAX  };if (输入数 < 三大数[列])；其他语句都不改动，一个道理，一个理念：无论设计一段程序或一个工程，从最简单容易的、最基础下手，不断地扩展，不断地演化，直到达成目标，直到令她完美。

下面就让我们来见证演化：

 

	const int 输出个数(4), 数组长度(10);
	int 序(0), 输出数(0), 输入数(0), 三大数[输出个数] = { /*INT_MAX*/ INT_MIN };
	do
	{
		std::cout << "输入" << 数组长度 <<"个数字,输出其中最大的" << 输出个数 <<"个数字 #" << 序 + 1 << ":";
		std::cin >> 输入数;
		int 列 = 0, 排序 = 输出个数 - 1;
		do
		{
			if (输入数 > 三大数[列])
			/*if (输入数 < 三大数[列])*/
			{ 
				while (排序 - 列)
					三大数[排序] = 三大数[排序-- - 1];
				三大数[列] = 输入数;
			}
		} while (列++ < 排序);
	} while (++序 < 数组长度);
	do
	{
		std::cout << 三大数[输出数];
		if (输出数++ < 输出个数 - 1) std::cout << ":";
	} while (输出数 < 输出个数);

 

 

 

 

我们来再次见证演化奇迹：

 

	int 选择(0);
	std::cout << "选择输出最大(1)或最小(0):";
	std::cin >> 选择;
	const int 输出个数(4), 数组长度(10);	//const int 初始化 = 选择 ? INT_MIN : INT_MAX;
	int 序(0), 输出数(0), 输入数(0), 三大数[输出个数] = { 选择 ? INT_MIN : INT_MAX };
	do
	{
		std::cout << "输入" << 数组长度 <<"个数字,输出其中选择的" << 输出个数 <<"个数字 #" << 序 + 1 << ":";
		std::cin >> 输入数;
		int 列 = 0, 排序 = 输出个数 - 1;
		do
		{
			if(选择 ? (输入数 > 三大数[列]) : (输入数 < 三大数[列]))
			{ 
				while (排序 - 列)
					三大数[排序] = 三大数[排序-- - 1];
				三大数[列] = 输入数;
			}
		} while (列++ < 排序);
	} while (++序 < 数组长度);
	do
	{
		std::cout << 三大数[输出数];
		if (输出数++ < 输出个数 - 1) std::cout << ":";
	} while (输出数 < 输出个数);