50个人围成一圈数到三和三的倍数时出圈，问剩下的人是谁？在原来的位置是多少？

package com.ming.test.test9999;

import java.util.ArrayList;
import java.util.List;

public class Test1 {
        static int num;
        //B  记录每个人叫到的数字
        static List<Integer> a;
        //记录第一圈   初始1-50的数字  
        static List<Integer> b;
        //记录每一圈的数字为3的倍数的  下角标
        static List<Integer> c;

        public static void main(String[] args) {
                init();
                int i = 0;
                print(a, "a");
                print(b, "b");
                print(c, "c");
                while (a.size() != 1) {
                        System.out.println(i);

                        find();
                        print(c, "c");
                        delete();
                        resetA();

                        print(a, "a");
                        print(b, "b");
                       
                        i++;
                }
        }
        //重置A的数字
        public static void resetA() {
                for (int i = 0; i < b.size(); i++) {
                        a.add(++num);
                }
        }
        //找到A中数字为3的倍数
        public static void find() {
                for (int i = 0; i < a.size(); i++) {
                        if (a.get(i) % 3 == 0) {
                                //添加记录到C中
                                c.add(i);
                        }
                }
        }
        //初始化
        public static void init() {
                a = new ArrayList<Integer>();
                b = new ArrayList<Integer>();
                c = new ArrayList<Integer>();
                for (int i = 0; i < 50; i++) {
                        a.add(i + 1);
                        b.add(i + 1);
                }
                num = 50;
        }
        //删除  B中的数字。清空A和C
        public static void delete() {
                //从B的最后的值开始删除。否则B的长度会发生变化，导致后面的值删除的位置会发生错误
                for (int i = c.size() - 1; i > -1; i--) {
                        int ii = c.get(i);
                       
                        /////////////////////
                        /*
                         * 其中的方法在这里耽误的时间比较多
                         * 因为，remove(5)；
                         * 之前没有解决好，会把B中的5删除，而不是删除下角标为5的元素
                         */
                        b.remove(ii);
                        /////////////////////
                }
                a.clear();
                c.clear();
        }
        //打印
        public static void print(List<Integer> i, String str) {
                System.out.println(str);
                for (int j = 0; j < i.size(); j++) {
                        System.out.print(i.get(j) + " ");
                }
                System.out.println();
        }
}





还望共同讨论更好的方法。楼主5个黑马币给我吧

菜鸟撸过看看

1. package com.testthree;
   
2. public class TestThree {
   
3. 
   
4.         public static void main(String[] args) {
   
5.                 // TODO Auto-generated method stub
   
6.                 TestThree tt =new TestThree();
   
7.                 tt.Test();
   
8.         }
   
9.         //数数的方法
   
10.         public void Test()
    
11.         {
    
12.                 //创建1-50的数组
    
13.                 int[]three = new int[50];
    
14.                 for(int i =1;i<51;i++)
    
15.                 {                       
    
16.                         three[i-1]=i;
    
17.                 }
    
18.                 //
    
19.                 int flag =50;//初始总共有50个数
    
20.                 int number =0;
    
21.                 //只要数量大于3就要一直数下去
    
22.                 while(flag>=3)
    
23.                 {
    
24.                         for(int i =1;i<51;i++)
    
25.                         {
    
26.                                 if(three[i-1]!=0)//将数过3或3的倍数的跳过
    
27.                                 {
    
28.                                         number++;
    
29.                                         if(number%3==0)//数过3或3的倍数时将基标为0
    
30.                                         {
    
31.                                                 flag-=1;//每数一次，总数少一个
    
32.                                                 three[i-1]=0;
    
33.                                         }
    
34.                                        
    
35.                                 }
    
36.                                
    
37.                         }
    
38.                        
    
39.                 }
    
40.                 for(int i =1;i<51;i++)
    
41.                 {
    
42.                         if(three[i-1]!=0)
    
43.                         {
    
44.                                 System.out.println(i);
    
45.                         }
    
46.                        
    
47.                 }
    
48.                
    
49.         }       
    
50. 
    
51. }

复制代码

1. <p style="line-height: 30px; text-indent: 2em;"></p>
   

复制代码

此题主要还是考查我辈的基本功了，我就直接贴代码，最后打印出11，43；

厉害…………………………

菜鸟飞过，欣赏一下。

约瑟夫算法：

1. public static void main(String[] args) {
   
2.                 int n = 50, m = 3;
   
3.                 int index = 0;
   
4.                 for (int i = 2; i <= n; i++) {
   
5.                         index = (index + m) % i;
   
6.                 }
   
7.                 System.out.println(index + 1);
   
8. }

复制代码

其实这个我也不大懂，数学成绩不咋地啊

欣赏一下。

菜鸟路过看看！！！

1. 
   
2. 
   
3. #include <stdio.h>
   
4. 
   
5. int main(int argc, const char * argv[])
   
6. {
   
7. 
   
8.     // insert code here...
   
9.     int p[15]={0}; // 初始化数组
   
10.     int n=15; // 剩余人数;
    
11.     int i=1; // 报号
    
12.     int j=0; // 下标
    
13.     while(n>1){
    
14.         if(p[j]==0&&i==3){ // 判断报号是否为3,且没有出列的人
    
15.             p[j]=1;        // 将其出列
    
16.             i=1;           // 报号初始化为1
    
17.             n--;           // 剩余人数减1
    
18.         }else if(p[j]==0&&i!=3){ // 判断报号不为3,且没有出列的人
    
19.             i++;                 // 报号+1
    
20.         }
    
21.         if(++j==15){             // 数组下标+1,并判断是否越界
    
22.             j=0;                 // 下标越界,初始化为0
    
23.         }
    
24.     }
    
25.     for(i=0;i<15;i++){
    
26.         if(p[i]==0){
    
27.             printf("出卖耶稣的叛徒序号：%d\n",i);
    
28.         }
    
29.     }
    
30.     return 0;
    
31. }
    

复制代码

上面是我的方法，你看看怎么样

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

楼主的意思不是只剩一个人吗。。。

邵起 发表于 2014-11-2 09:09
楼主的意思不是只剩一个人吗。。。

谢谢指出问题，第二十二行改为下面的即可，最后输出11

1. while(flag>=2)

复制代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct LinkNode linkNode;
   
5. 
   
6. //创建一个结构体，用来表示每个节点
   
7. struct LinkNode {
   
8.     //每个节点的编号
   
9.     int id;
   
10.     //这个节点的下一个的地址
    
11.     linkNode *next;
    
12. };
    
13. 
    
14. 
    
15. int main()
    
16. {
    
17.     //初始化第一个节点。设置变量当前节点和下一个节点
    
18.     linkNode *head = NULL , *tempCurrent,*tempNext;
    
19.    
    
20.         //创建节点
    
21.         //创建第一个节点
    
22.         tempCurrent = (linkNode *)malloc(sizeof(linkNode));
    
23.         head = tempCurrent;
    
24.         head -> id = 1;
    
25.         //创建之后的节点
    
26.         for (int i = 2; i <= 50; i ++) {
    
27.             //分配节点大小
    
28.             tempNext = malloc(sizeof(linkNode));
    
29.             
    
30.             tempNext -> id = i;
    
31.             tempCurrent -> next = tempNext;
    
32.             tempCurrent = tempNext;
    
33.         }
    
34.         //循环链表
    
35.         tempCurrent -> next= head ;
    
36.    
    
37. 
    
38.    
    
39.     linkNode *replace = head,*temp = NULL;
    
40.     //查找要去除的点,直到还剩最后一个点
    
41.     while (replace -> next != replace) {
    
42.         
    
43.         //设置间隔数量，不是间隔数就直接跳过，直到找到间隔数的节点
    
44.         for (int j = 1; j < 3; j ++) {
    
45.             temp = replace;
    
46.             replace = replace -> next;
    
47.         }
    
48.         
    
49.         //去除满足要求的点
    
50.         temp -> next = replace -> next;
    
51.         
    
52.         printf("出局的是 %d\n",replace -> id);
    
53.         //释放节点内存
    
54.         free(replace);
    
55.         //临时变量向后移
    
56.         replace = temp -> next;
    
57.     }
    
58.    
    
59.     //找出最后剩下的点
    
60.     printf("最后还剩下的是 %d\n",replace -> id);
    
61.     return 0;
    
62. }

复制代码

C语言写的，望采纳

import java.util.ArrayList;
import java.util.List;
public class ZhuanQuan {

        public static void main(String[] args) {
                //创建数组型队列
                ArrayList<Integer>al=new ArrayList<Integer>();
                for(int i=1;i<=50;i++){
                        al.add(i);//添加元素
                }
                while(al.size()>1){       //剩最后一人时停止
                        for(int j=0;j<3;j++){                                 
                               int x=al.remove(0);//将点到的人取出
                               if(j%3!=2){   
                                        al.add(x); //不是3的倍数再加到队尾
                                }
                        }
                                                
                }
                System.out.println("最后一个人是"+al.get(al.size()-1));
        }

}

/*
根据你的需求 这里用到了一个关于数组的 古典游戏“猴子选大王”的算法
参选的人按1 2 3......n编号并按顺序围成一圈,由第K人（这里K可以根据个人要求指定）开始从1报数
报数到达P时跳出圈外，再由下一个人从1开始 如此循环 知道剩下最后一人 这人也就是（猴子选大王算法中的王）我们所需要的人
*/
import javax.swing.JOptionPane

public class PersonKing{
        public static void main(String[] args){
                String s;
                int n, k, p,n1;
               
                s=JOptionPane.showInputDialog("请输入人数的总数");
                n=Integer.parseInt(s);
                n1=n+1;
                s=JOptionPane.showInputDialog("请输入起始报数人的编号");
                k=Integer.parseInt(s);
                s=JOptionPane.showInputDialog("请输入出局数字: ");
                p=Integer.parseInt(s);
                int a[]=new int[n+1];
                a[0]=0;
                System.out.println("\t 出局人的编号： ");
                for(int i=1;i<a.length;i++)
                        a[i]=1;
                for(int i=1;i<=p;i++){
                        if(n==1)
                                break;
                        else if(i==p||i/3==0){
                                n--;
                                i=0;
                                a[k]=0;
                System.out.print(k+" ");

                        }
                        do{
                        k++;
                        k=k%n1;
                        }where(a[k]!=1);
                }       


                System.out.println("\n 最后剩余的人的编号为:"+k);
               
        }
}

请楼主仔细看16楼 中我想这个应该是最标准的算法了（猴子选大王算法）
里面你要求是50人 我这里都没规定死 我是基于算法本身，变量不写死。这个方法就可以单独做成类。方便以后调用。也就是说 以后遇到不是人数是50 第3人或3的倍数（也就是被3整除=0）出局的时候 可以套用。。这是个公式。。就跟真理是已经经过多代人验证过一样，与其说是帮你解决这问题 不如说是教你认识一种前人验证好了的方法，我们要记住以后遇到类似的问题 不用去研究新算法 改怎么实现，直接拿过来套用 笔着  葫芦画瓢，节省时间久是节省金钱

路过看看

50个人围成一圈，形成一个闭环，这个一个典型的链表结构，每次出圈，只要把出圈人的左右对接即可，链表最后剩下的那个人，就是你想要的。不多说上代码：

1. //先要有个用户，包含三个属性
   
2. package cn.csdn.test;
   
3. 
   
4. public class User {
   
5.     /**
   
6.      * 用户id
   
7.      */
   
8.         private int userId;
   
9.         /**
   
10.          * 下个用户
    
11.          */
    
12.         private User next;
    
13.         /**
    
14.          * 上个用户
    
15.          */
    
16.         private User pre;
    
17.        
    
18.         public User(int no) {
    
19.                 this.userId = no;
    
20.         }
    
21.         public int getUserId() {
    
22.                 return userId;
    
23.         }
    
24.         public void setUserId(int userId) {
    
25.                 this.userId = userId;
    
26.         }
    
27.         public User getNext() {
    
28.                 return next;
    
29.         }
    
30.         public void setNext(User next) {
    
31.                 this.next = next;
    
32.         }
    
33.         public User getPre() {
    
34.                 return pre;
    
35.         }
    
36.         public void setPre(User pre) {
    
37.                 this.pre = pre;
    
38.         }
    
39. }

复制代码

2.游戏开始

1. package cn.csdn.test;
   
2. import cn.csdn.test.User;
   
3. public class GamePlay {
   
4.         
   
5.         /**
   
6.          * 出圈数数
   
7.          */
   
8.         private static int OUTNUMBER = 3;
   
9.         /**
   
10.          * 玩游戏的人数
    
11.          */
    
12.         private static int USERCOUNT = 5;
    
13.         
    
14.         public static void main(String[] args) {
    
15. 
    
16.                 if(USERCOUNT <= 0 || OUTNUMBER <= 0) {
    
17.                         System.out.println("你逗我？");
    
18.                         System.exit(-1);
    
19.                 }
    
20.                
    
21.                 //1.将50个人围成一圈，构成单向链表结构
    
22.                 User firstUser = null,curUser = null,newUser = null;
    
23.                 for(int i=1; i<=USERCOUNT;i++){
    
24.                         newUser = new User(i);
    
25.                         if(firstUser == null){
    
26.                                 firstUser = newUser;
    
27.                                 curUser = newUser;
    
28.                         }else{
    
29.                                 newUser.setPre(curUser);
    
30.                                 curUser.setNext(newUser);
    
31.                                 curUser = newUser;
    
32.                         }
    
33.                 }
    
34.                 //形成闭环
    
35.                 curUser.setNext(firstUser);
    
36.                 firstUser.setPre(curUser);
    
37.                
    
38.                 //2.从头开始遍历链表，数到3的人出链表，再将出圈人的左右两人对接
    
39.                 User temp = firstUser;
    
40.                 int i = 1;
    
41.                 do{
    
42.                         if(temp != null && i % OUTNUMBER == 0){
    
43.                                 User pre = temp.getPre();
    
44.                                 User next = temp.getNext();
    
45.                                 if(next == pre) {
    
46.                                         temp = next;
    
47.                                         break;
    
48.                                 }
    
49.                                 pre.setNext(next);
    
50.                                 next.setPre(pre);
    
51.                                 temp = next;
    
52.                                 i=1;
    
53.                         }else{
    
54.                                 temp = temp.getNext();
    
55.                                 i++;
    
56.                         }
    
57.                 }while(true);
    
58.                 System.out.println("共有"+ USERCOUNT + "玩家,最后留在圈的人是  " + temp.getUserId());
    
59.         }
    
60. }

复制代码

yuanlingqi 发表于 2014-11-8 13:42
50个人围成一圈，形成一个闭环，这个一个典型的链表结构，每次出圈，只要把出圈人的左右对接即可，链表最后 ...

从1开始编号和数数，50人最后剩下的是11号