一个地主有37个奴隶，一天，他要将37个奴隶杀掉36个，只剩下一个。他让所有的奴隶站在一起，分别编号为1至37，然后让他们从第1开始数，数到第5个时，将其杀死。然后从下一个开始又从1开始数，数到第5个时，将其杀死。直到只剩下一个奴隶时才结束。请用C语言编写程序，将唯一存活的奴隶编号打印出来。

分析：总共有37个奴隶，如下：
第一轮开始时（分别从1、6、11、16、21、26、31、36开始数）奴隶编号：
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37

第一轮杀死后（分别从4、11、17、23、29、36开始数）剩余奴隶：
1 2 3 4 6 7 8 9
11 12 13 14 16 17 18 19
21 22 23 24 26 27 28 29
31 32 33 34 36 37

第二轮杀死后（分别从6、13、21、29、37开始数）剩余奴隶：
1 2 4 6 7 8
11 12 13 14 17 18 19
21 23 24 26 27 29
31 32 33 36 37

第三轮杀死后（分别从8、18、29开始数）剩余奴隶：
1 2 6 7 8
11 13 14 17 18
21 23 24 26 29
31 32 33 37

第四轮杀死后（分别从1、13、24开始数）剩余奴隶：
1 2 6 8
11 13 14 18
21 23 24 29
31 32 33

第五轮杀死后（分别从1、14、31开始数）剩余奴隶：
1 2 6 8
13 14 18
21 24 29
31 32

第六轮杀死后（分别从8、31开始数）剩余奴隶：
1 2 6 8
14 18
21 24
31 32

第七轮杀死后（从14开始数）剩余奴隶：
1 2 8
14 18
21
31 32

第八轮杀死后（分别从1、31开始数）剩余奴隶：
1 2
14 18
21
31

第九轮杀死后（从31开始数）剩余奴隶：
1 2
14 18

31

第十轮杀死后剩余奴隶：
1 2
14

31

第十一轮没有杀死奴隶

第十二轮杀死后（从1开始数）剩余奴隶：
1 2
14


第十三轮没有杀死奴隶

第十四轮杀死后（从14开始数）剩余奴隶：
1
14

最后一轮杀死后剩余奴隶：
1

怎样排除已经被杀死的奴隶编号？？？

请大家帮帮忙解决一下，急！！！！！！！谢谢！！！

用循环链表实现比较简单

具体怎么做啊？我是初学者，什么都不懂。请高手指教一下。谢谢！

[CODE]/* Slave.c -- 找出唯一存活的奴隶
* Author： Space
* Date: 2007/07/04
* Version: 1.0
*/
#include<stdio.h>
#include<stdlib.h>

struct slave
{
int num;
slave *next;
};

int main(void)
{
int i = 0;
int cnt = 1;
slave *tmp = NULL;
slave *prev = NULL;
slave *head = (slave *)malloc(sizeof(slave));

if (! head)
{
printf("Malloc failed!\n");
exit(-1);
}
head->num = 1;
head->next = head;
prev = head;

for (i = 1; i < 37; ++i)
{
tmp = (slave *)malloc(sizeof(slave));
if (! tmp)
{
printf("Malloc failed!\n");
exit(-1);
}
tmp->num = i + 1;
tmp->next = head;
prev->next = tmp;
prev = tmp;
}

prev = head;
while(prev->next != prev)
{
++cnt;
if (cnt % 5 == 0)
{
cnt = 1;
tmp = prev->next;
prev->next = tmp->next;
free(tmp);
}
prev = prev->next;
}

printf("活下来的奴隶编号为：%d\n", prev->num);
free(prev);

return 0;
}[/CODE]

程序是对的，只是如果能够在每句后面加上注释，方便初学者看懂程序就更好了

谢谢！！！
可是有很多地方看不懂啊？？？
先研究下，再说。谢谢啊！！！

用数学的算法不是更好吗？

[CODE]/* Slave.c -- 找出唯一存活的奴隶
* Author： Space
* Date: 2007/07/04
* Version: 1.1
*/
#include<stdio.h>
#include<stdlib.h>
struct slave // 定义结构体，num用来储存奴隶编号，next为尾指针，指向下一个节点
{
int num;
struct slave *next;
};
int main(void)
{
int i = 0; // 循环下标
int cnt = 1; // 用于找出下一个要kill的奴隶计数
struct slave *tmp = NULL; // 临时指针
struct slave *prev = NULL; // 指针，用于建立链表和后面的处理
struct slave *head = (struct slave *)malloc(sizeof(struct slave)); // 头指针
if (! head) // 确保申请到内存空间
{
printf("Malloc failed!\n");
exit(-1);
}
head->num = 1; // 头节点储存的奴隶编号为1
head->next = head; // 头节点的尾指针指向自己，建立循环链表
prev = head; // prev指向链表的尾节点，此时尾节点为头节点
for (i = 1; i < 37; ++i) // 建立初始链表，依次在链表尾插入节点
{
tmp = (struct slave *)malloc(sizeof(struct slave)); // 申请节点空间
if (! tmp) // 确保申请到内存空间
{
printf("Malloc failed!\n");
exit(-1);
}
tmp->num = i + 1; // 取得节点奴隶编号，从2开始到37
tmp->next = head; // 待插入节点的尾指针指向头节点
prev->next = tmp; // 插入节点
prev = tmp; // 现在tmp指向的节点为尾节点，将prev指向tmp指向的节点
}
prev = head; // prev指向头节点，准备进行删除处理
while(prev->next != prev) // 节点的的下一个节点为自身，说明链表只剩一个节点，循环结束
{
++cnt; // 开始递增
if (cnt % 5 == 0) // 现在prev指向第4个节点，现在删除它的下一个节点，也就是报数为5的节点
{
cnt = 1; // 重新开始计算，准备删除下一个节点
tmp = prev->next; // tmp指向待删除节点
prev->next = tmp->next; // prev的尾指针指向prev的下下个节点，即第4个节点尾指针指向第6个节点
free(tmp); // 释放要的删除节点，即第5个节点
tmp = NULL; // add by Space 2007/07/04
}
prev = prev->next; // prev指向它的下一个节点，循环继续
}
// 打印结果
printf("活下来的奴隶编号为：%d\n", prev->num);
free(prev); // 释放最后剩下的一个节点
return 0;
}[/CODE]

谢谢！
可是有没有什么简便一点的方法啊？我们现在还没有学指针。看不懂代码啊
望大家赐教……

[此贴子已经被作者于2007-7-4 23:59:41编辑过]

数组也能实现，你先自己想想怎么写吧