//此算法可以求出剩下的那个人的位置和序号
import java.util.LinkedList;   
import java.util.List;   
//测试类   
public class Cycle {      
    public static int cycle(int total, int k) {  //功能方法   
        List<Integer> dataList = new LinkedList<Integer>();//创建链表对象   
        for (int i = 0; i < total; i++)  //添加数据元素   
            dataList.add(new Integer(i + 1));      
        int index = -1;  //定义下标，模拟已经去掉一个元素，因此从-1开始  
    while (dataList.size() > 1) { //一直循环去除数据，直到只剩下一个元素   
            index = (index + k) % dataList.size();//得到应该出局的下标   
            dataList.remove(index--);  //去除元素   
        }      
        return ((Integer) dataList.get(0)).intValue();//返回它的值   
    }      
  //主方法   
    public static void main(String[] args) {      
        System.out.println("该数字原来的位置是："+cycle(50, 3));     
    }      
}  

#include <stdio.h>
int main()
{
        int k=0,j=0;
        int name[50];
        for (int m=0;m<50;m++)             //给数组编号，1~50 此时m=50
        {
                name[m]=m+1;
        }
        for (int i=m;i>1;)                                //i 表示人数,此时m=50
        {
                if (name[j]!=0)
                {
                        k++;
                }
                if (k==3)                                  //k为报数值，       
                {
                        name[j]=0;                  //此时将此人的值赋值为0,表示此人已经排除
                        k=0;                                 //重新赋值给k
                        i--;                                 //人数减1
                }
                j++;
                if(j==m)
                {
                        j=0;              //由于是围成一圈,当j的值等于15时，将其设置为0
                }
        }
        for (int n= 0; n< m; n++)
        {
       if (name[n] > 0)               //最后一个不为0的数字编号即为叛徒的编号
                {
            printf("出卖耶稣的叛徒的原来序号是%d\n",name[n]);
        }
    }
        return 0;
}

不是很懂，但是个人感觉猴子那个更好点，毕竟没有写死，可以套用

菜鸟路过，学习下。

ganjx 发表于 2014-10-22 23:31
此题主要还是考查我辈的基本功了，我就直接贴代码，最后打印出11，43； ...

N，厉害，赞一个！！！

原创;P 就用了1个for2个if 还算比较简便 思路也不难 咱新手就图个思路 并不是为解题而解题 希望对楼主有帮助

1. class Test
   
2. {
   
3.         /*
   
4.         *50长度元素值全1的数组1个
   
5.         *count不断循环数组并累加所有元素值;
   
6.         *count逢3时,元素值改为0(为了下次count访问并累加该元素时不计数,count的存在就是为了逐步把每个元素值都改为0);
   
7.         *这时update++(因为count遇到3的倍数了,update记录);
   
8.         *当update为50的时候说明找到最后一个元素,返回角标+1;
   
9.         **/
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 int[] arr = new int[50];
    
13.                 for(int i = 0;i<50;i++)
    
14.                         arr[i] = 1;//定义一个长度50,元素值都为1的数组;
    
15.                 for(int i =0,count = 0,update = 0;;i++)//上面说的很清楚了
    
16.                 {
    
17.                         i = i==50?0:i;//从角标0开始不断循环访问数组所有元素(i=50就重置为0);
    
18.                         //如果上次count值不能被3整除,并且本次count能被3整除,说明该位置是1(0代表);
    
19.                         if(count%3!=0&(count+=arr[i])%3==0)
    
20.                         {
    
21.                                 arr[i]=0;//元素值改为0,让count无视它
    
22.                                 update++;//记录本次被3整除时事件
    
23.                         }
    
24.                         if(update==50)//当遇到50次被3整除后,说明最后一次访问的就是数组最后一个值为1的元素
    
25.                         {
    
26.                                 System.out.println(i+1);//放回角标+1(位置)
    
27.                                 break;
    
28.                         }
    
29.                 }
    
30.         }
    
31. }

复制代码

学习了   膜拜大神     感觉自己好菜呀

这是纯粹的数学问题，11和43

ArrayList  在迭代时，判断，使用递归比较方便

顶一个:)

此问题可用循环链表模拟，节点的num存储信徒的序号,用一个变量暂存所报的序号，如果是3则将这个节点从链表中下链。
#include <stdio.h>
#include <malloc.h>
#define MAX 50 //人数

typedef struct student {
    int num;
    struct student *next;
}s_list;
/* 创建循环链表 */
s_list *creat_list()
{

    s_list *head = NULL;
        s_list *p = NULL;
        s_list *q = NULL;
    int i = 0;
        /* 申请头节点的存储空间 */
    head = p = (s_list *)malloc(sizeof(s_list));
        if (NULL == head)
        {
                printf ("malloc error!");
                return;
        }
    p->num = 1;// 序号
        /* 初始化第二到最后面的序号*/
    for (i = 2;i <= MAX; i++)
        {
        q = (s_list *) malloc(sizeof(s_list));
                if (NULL == q)
                {
                        printf ("malloc error!");
                        return;        
                }
        q->num = i;
        p->next = q;
                p = q;
    }
        /* 由于循环链表 将最后一个节点的next指向头*/
    p->next = head;

    return(head);
}
/* 执行报数的流程 */
s_list *del_people(s_list* head)
{

    s_list *p1 = head;
        s_list *p2 = head;
        s_list *del_node = NULL;
    int k = 1; //用于记录当前所报的数

    while(p1->next != p1) //只有一个人
        {
        if(k == 3) /* 报到三则下链 */
                {   
            del_node = p1; //标记要删除的节点
                        /* 下链并释放 */
            p1 = p1->next;
            p2->next = p1;
            free(del_node);
            del_node = NULL;
            k = 0;
        }
                else
                {
            p2 = p1;
            p1 = p1->next;
        }
        k++;
    }
    p1->next = NULL;
    return(p1);
}
/* 打印最后的叛徒序号 */
void print_alive_pelple(s_list *head)
{
        s_list *p = NULL;
        if (NULL == head )
        {
                return;
        }
    printf("alive num is %d\n",head->num);

}
/* 主函数 */
int main()
{
    s_list *head = NULL;
        s_list *alive_node = NULL;
    /* 创建并初始化一个循环链表 */
    head  = creat_list();
        /* 报号并退出出的执行 */
    alive_node = del_people(head);
        /* 输出最后的叛徒 */
    print_alive_pelple(alive_node);
        /* 释放链表 防止内存泄漏 */
    free(alive_node);
        alive_node =  NULL;
    return 0;
}