五位运动员参加比赛，进行结果预测：

A说：B第一，我第三
B说：我第二，E第四
C说：我第一，D第三
D说：C最后，我第三
E说：我第四，A第一

比赛结束，每位选手只说对了一半，编程确定比赛名次。

拿到这道题，我首先想到的是，ABCDE五人有5！个排列次序，对于每个次序都验证题目要求，满足即可break各个循环。于是代码如下：

#include 

int main()
{
	int i,sum=0;
	int a,b,c,d,e;
	int flag=0;

	for(a=1;a<\6;a++)
	{
		for(b=1;b<\6;b++)
		{
			for(c=1;c<\6;c++)
			{
				for(d=1;d<\6;d++)
				{
					for(e=1;e<\6;e++)
					{

						sum=0;
						sum=(b==1||a==3)+(b==2||e==4)+(c==1||d==2)+(c==5||d==3)+(e==4||a==1);
						if(sum==5)
						{
							flag=1;
							printf("e=%d ",e);
							break;
						}
					}

					if(flag)
					{
						printf("d=%d ",d);
						break;
					}
				}
				if(flag)
				{
					printf("c=%d ",c);
					break;
				}
			}
			if(flag)
			{
				printf("b=%d ",b);
				break;
			}
		}
		if(flag)
		{
			printf("a=%d ",a);
			break;
		}
	}
	printf("\n");
	return 0;
}

编译运行。结果错误：11134。原因是这样的：满足上述条件的序列很多，但是遇到第一个满足条件的序列（此时a，b，c都是1，可见没跑几下就break了）时，因为多个break的原因就跳出了所有循环。看来还得加一个筛选条件。既然名字是1～5的任意排序，那么五位选手名次之和肯定是固定的，因此加入此条件即可筛选处最终名次。如下：

						sum=0;
						sum=(b==1||a==3)+(b==2||e==4)+(c==1||d==2)+(c==5||d==3)+(e==4||a==1);
						if(sum==5)
						{
							if((a+b+c+d+e)==15)
							{
							flag=1;
							printf("e=%d ",e);
							break;
							}
						}

这样就OK了。看来除了得到题目表面的信息后，还得学会抓住隐含条件。其实第一个条件也可以有下面的几种表达方式：

                                                //方法1
						sum=0;
						sum+=(b==1&&a!=3)||(b!=1&&a==3);
						sum+=(b==2&&e!=4)||(b!=2&&e==4);
						sum+=(c==1&&d!=2)||(c!=1&&d==2);
						sum+=(c==5&&d!=3)||(c!=5&&d==3);
						sum+=(e==4&&a!=1)||(e!=4&&a==1);
						//方法2
						sum=0;
						sum=(a==3||a==1)+(b==1||b==2)+(c==1||c==5)+(d==2||d==3)+(e==4);

这里还有一个更简单的方法。在我作完后，我觉得这个题目用5重循环是否太多余，就想看看牛人是如何完成的，所以就咨询牛涛，它发过来一个链接，果然很简便。虽然意思是一样的但是时间复杂度只有N平方而已。我这个N的5次方 。

Update：8/10

今天一位同学留言说，判断条件应该再加一条判断a，b，c，d，e互不相等。这个条件在我做这个题的时候就想过，可当时总觉的两个判断条件即可。但是，为什么上面的代码也可以显示处正确的答案？那是因为我加入了break。恰好第一组名词就互不相等。如果把每个break都删除了，就会发现有两组结果，其中一个结果就有重复的名次。

其实这个题目属于一个穷举类的题目，应该在程序中让它列出所有的可能（尽管本题中的答案只有一个），而不是找到一个就立刻停止。

今天在看结构体和共用体部分的时候，遇到了一个新名词“内存对齐”。先引入问题吧。如下：

struct student
{
	char name[20];
	int age;
	char sex;
	char phone[15];
};
struct student p1;

sizeof(p1)=？
这个很简单得出答案，即20+4+1+15=40Byte。如果将phone[15]改为phone[16]，结果是44。难道不是41吗？

这里便要引入内存对齐的概念。内存为了提高访问效率，便规定以结构体中最大的基本单位长度为对齐标准。即实际分配的内存大小是对齐标准的整数倍（必要条件）。在上面的结构体中，最大的基本类型是int。因此以4Byte为对其标准。所以实际内存大小应该为4的整数倍，即为44Byte.

也许你有疑惑：name[20]不是要20Byte吗，为什么以4Byte为对齐标准？请注意这里的基本类型。name[20]是一个字符串数组，数组属于复合的数据类型。复合的数据类型还有结构体，共用体。基本的数据类型是整型，字符型，浮点型。如果你还有不解，那么看下题：

struct score
{
	float english;
	float math;
	float computer；
};
struct student
{
	char name[10];
	int age;
	char sex;
	struct score st_score;
};

在student结构体中含有数据类型为struct score这样的变量。struct score的大小为12Byte，也是struct student结构体中最大的数据类型，但是我们的对齐标准是4Byte，就如我们刚说的那样，内存的对齐标准是取结构体中最大的基本数据类型，这里我们取sizeof(int)。

再看下面的问题：

union data1
{
	int i;
	char c;
	char str[9];
};
struct data2
{
	int i;
	char c;
	char str[9];
};

sizeof(struct data1)=? sizeof(struct data2)=?
对于前者，由于共用体的存储大小由最大的成员来决定，因此上题中共用体的存储大小为9Byte，考虑到内存对齐，它以sizeof(int)=4Byte来对齐，因此实际内存分配大小是12Byte。对于后者，存储大小是4+1+9=14Byte，这个结构体以4对齐，因此实际分配大小为16Byte。

现在你应该对于共用体和结构体的内存对齐有所了解了。那么再接着往下看：

struct data
{
	char c;
	double d;
	char ch;
}

sizeof(struct data)=?
有了上面的理解，10肯定不会是答案，那么会是16吧。也错。正确答案是24。你可能会感到莫名其妙：按照上面所说的方法，以8为对齐标准，那么10不是8的倍数，那就是16呀。为什么呢？请你耐心看下面。

首先我们知道结构体变量是分配的连续内存空间。d毫无疑问是分配8Byte，对于d“前面”的c，按照对齐标准我们应该分配8Byte,而d后面的ch，按照对齐标准也应该分配8Byte。因此结果是24。

如果这样：

struct data
{
	double d;
	char c;
	char ch;
}

sizeof(struct data)=16。

因为内存没必要分别为c和ch分配8Byte来进行对齐，将它们放在一个8byte里就可以实现内存对齐。上面在引入内存对齐概念的时候，我用括号特别注释必要条件便是说明此处内容。