有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？这道题你们的结果是多少？代码我写完了，我的结果是剩下的是100人中的第75个人。

我和好多人的答案都是92

可以贴出代码让潜伏的大神们修改一下

杨佳名 发表于 2014-10-9 16:06
可以贴出代码让潜伏的大神们修改一下

这道题我是看完 韩顺平的 这个视频做出来的： 循序渐进学 java 从入门到精通 第11讲-约瑟夫问题.avi

1. package com.itheima;
   
2. 
   
3. 
   
4. /**
   
5. * 第十题：有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
   
6. * 修改时间：2014-10-9 上午01:23:57
   
7. */
   
8. public class Test10 {
   
9.        
   
10.         public static void main(String[] args) {
    
11.                
    
12.                 CycLink cycLink = new CycLink();        //1.定义链表对象
    
13.                 cycLink.setLen(100);                                //2.设置总人数
    
14.                 cycLink.setK(0);                                        //3.设置从哪个人开始数
    
15.                 cycLink.setM(14);                                        //4.设置数到第14的这个人退出
    
16.                 cycLink.createLine();                                //5.创建链表
    
17. //                cycLink.show();                                                //6.打印链表
    
18.                 cycLink.play();                                                //7.找出剩下的最后一个人是谁
    
19.         }
    
20. }
    
21. 
    
22. 
    
23. /**
    
24. * 定义Person类
    
25. * 修改时间：2014-10-9 上午04:15:03
    
26. */
    
27. class Person{
    
28.         public int no;                                                        //1.人的编号
    
29.         public Person nextPerson = null;                //2.下一个人
    
30.         public Person previousPerson = null;        //3.上一个人
    
31.         //构造函数
    
32.         public Person(int no){
    
33.                 this.no = no;
    
34.         }
    
35. }
    
36. 
    
37. /**
    
38. * 环形链表
    
39. * 修改时间：2014-10-9 上午03:19:43
    
40. */
    
41. class CycLink{
    
42.        
    
43.         Person firstPerson = null;                //1.先定义一个指向链表第一个人的引用
    
44.         Person temp = null;
    
45.         int len = 0;                                        //2.表示有几个人
    
46.         int k = 0;                                                //3.从第几个人开始数
    
47.         int m = 0;                                                //4.设置数第m下的人退出
    
48.        
    
49.         //设置数第m下的人退出
    
50.         public void setM(int m){
    
51.                 this.m = m;
    
52.         }
    
53.        
    
54.         //设置从第几个人开始数
    
55.         public void setK(int k){
    
56.                 this.k = k;
    
57.         }
    
58.        
    
59.         //设置链表大小
    
60.         public void setLen(int len){
    
61.                 this.len = len;
    
62.         }
    
63.        
    
64.         //5.初始化环形链表
    
65.         public void createLine(){
    
66.                
    
67.                 for(int i=1;i<=len;i++){
    
68.                         if(i==1){
    
69.                                 //1.创建第一个人
    
70.                                 Person person = new Person(i);
    
71.                                 this.firstPerson = person;
    
72.                                 this.temp = person;
    
73.                         }else {
    
74.                                 //2.创建最后一个人
    
75.                                 if(i==len){
    
76.                                         Person person = new Person(i);
    
77.                                         person.previousPerson = temp;
    
78.                                         temp.nextPerson = person;
    
79.                                         temp = person;               
    
80.                                         //指定最后一个人的下一个是第一个
    
81.                                         temp.nextPerson = this.firstPerson;
    
82.                                         temp.nextPerson.previousPerson = person;
    
83.                                 }else {
    
84.                                         //创建完第二个的时候指定上一个的对象是谁，也指定上一个的下一个对象是谁
    
85.                                         Person person = new Person(i);
    
86.                                         person.previousPerson = temp;
    
87.                                         temp.nextPerson = person;
    
88.                                         temp = person;
    
89.                                 }
    
90.                         }
    
91.                 }
    
92.         }
    
93.        
    
94.        
    
95.         //6.游戏开始
    
96.         public void play(){
    
97.                
    
98.                         Person temp = this.firstPerson;
    
99.                         //1.先找到开始数数的人
    
100.                         for(int i=1;i<k;i++){
     
101.                                 System.out.println(temp.nextPerson.no+"开始数");
     
102.                                 temp = temp.nextPerson;
     
103.                         }
     
104.                         while(this.len != 1){
     
105.                                 //2.找到数第m下的人
     
106.                                 for(int i=1;i<m;i++){
     
107.                                         temp = temp.nextPerson;
     
108.                                 }
     
109.                                 //3.将数到m的人，退出;将数到第m下的人上一个人的nextPerson指定为 数到第m下的人的nextPersono
     
110.                                 temp.previousPerson.nextPerson = temp.nextPerson;
     
111.                                 System.out.println(temp.no+"退出");
     
112.                                 //4.temp就变成下一轮开始数数的人
     
113.                                 temp = temp.nextPerson;
     
114.                                 //5.然后减少一个人玩游戏，
     
115.                                 this.len--;
     
116.                         }
     
117.                 //6.现在temp就是退出的那个人，它的nextPerson就是最后一个人
     
118.                 System.out.println("剩下的是100人中的第"+temp.no+"个人");
     
119.                
     
120.         }
     
121.        
     
122.         //7.打印链表
     
123.         public void show(){
     
124.                 Person temp = this.firstPerson;
     
125.                 do{
     
126.                         System.out.println(temp.no);
     
127.                         temp = temp.nextPerson;
     
128.                 }while(temp != this.firstPerson);
     
129.         }
     
130.        
     
131. }
     

复制代码

http://bbs.itheima.com/forum.php ... p;page=2#pid1018015

ye361571404 发表于 2014-10-9 17:09
这道题我是看完 韩顺平的 这个视频做出来的： 循序渐进学 java 从入门到精通 第11讲-约瑟夫问题.avi

请问“其他人重新开始”是从那个人开始啊，是原来的1,？？还是接下来要开始报数的15啊？

十万一千 发表于 2014-10-9 17:13
http://bbs.itheima.com/forum.php?mod=viewthread&tid=147049&page=2#pid1018015

请问“其他人重新开始”是从那个人开始啊，是原来的1,？？还是接下来要开始报数的15啊？

贾浩田 发表于 2014-10-18 17:26
请问“其他人重新开始”是从那个人开始啊，是原来的1,？？还是接下来要开始报数的15啊？ ...

接下来开始报数的15

结果为92吧。

1. import java.util.*;
   
2. class test110
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 //定义一个arraylist集合存储元素
   
7.                 ArrayList<Integer> al = new ArrayList<Integer>();
   
8. 
   
9.                         //向集合中添加100个元素（1-100数字）
   
10.                         for(int i=1;i<=100;i++)
    
11.                         {
    
12.                                 al.add(i);
    
13.                         }
    
14.                 method_1(al);
    
15.         }
    
16. 
    
17.         public static void method_1(ArrayList<Integer> al)
    
18.         {
    
19.                 //此处定义一个集合，是为了方便后面删除元素用。
    
20.                 ArrayList<Integer> buf = new ArrayList<Integer>();
    
21.                
    
22.                 //定义一个计数器，记录大家的报数。
    
23.                 int count=0;
    
24. 
    
25.                 //一直循环报数（1-100转完一圈再继续转的意思），删除元素，直到只剩下一个元素
    
26.                 while(true)
    
27.                 {
    
28.                         //判断元素是否为1
    
29.                         if(al.size()>1)
    
30.                         {
    
31.                                 //100个人内部1-14循环报数
    
32.                                 for(int index=0;index<al.size();index++)
    
33.                                 {
    
34.                                         //进入循环一次，计数器+1
    
35.                                         count++;
    
36. 
    
37.                                         //判断判断报的数是否为14的倍数，这里对1-14循环报数稍微做了下转换，应该不难理解
    
38.                                         if(count%14==0)
    
39.                                         {
    
40.                                                 //如果该角标的报数为14的倍数，则将该元素添加到上面定义好的buf集合。
    
41.                                                 buf.add(al.get(index));       
    
42.                                         }
    
43.                                 }
    
44. 
    
45.                                 //一次性删除al集合中包含的buf集合中的元素。
    
46.                                 al.removeAll(buf);
    
47.                                 //清空buf集合
    
48.                                 buf.clear();
    
49.                         }
    
50.                         else
    
51.                                 break;
    
52.                 }
    
53. 
    
54.                 System.out.println(al);
    
55.         }
    
56. }
    

复制代码

贾浩田 发表于 2014-10-18 17:28
请问“其他人重新开始”是从那个人开始啊，是原来的1,？？还是接下来要开始报数的15啊？ ...

http://bbs.itheima.com/forum.php ... p;page=5#pid1025567
你看下这个页面吧。。。   退出一个人以后，当然是从退出的那个人的后一个人开始重新报数啦，从1开始报。

我怎么觉得最后一个移除的元素肯定是14的整数被啊，应该是98（14x7）啊

十万一千 发表于 2014-10-18 21:36
http://bbs.itheima.com/forum.php?mod=viewthread&tid=147049&page=5#pid1025567
你看下这个页面吧。。 ...

谢谢，请问最后说“最后剩下的是100人中的第几个人？”这句话是什么意思啊，在问什么啊？我有点没读懂题意？什么叫最后剩下的啊，最后一个被移除的元素应该是a98啊，总共移除了7个元素，那最后一个人应该是第100-7=93的那个啊？怎么会是92呢？

贾浩田 发表于 2014-10-18 22:54
谢谢，请问最后说“最后剩下的是100人中的第几个人？”这句话是什么意思啊，在问什么啊？我有点没读懂题 ...

最后剩余的当然是从来也没有自己报14的那个人啊 如果有100个人围成一个圈，那么经过不断报数后，总共移除了100-1个人了。最后在100个人中第几个人是指初始状态下这个人的编号。

十万一千 发表于 2014-10-18 23:20
最后剩余的当然是从来也没有自己报14的那个人啊 如果有100个人围成一个圈，那么经过不断报数后，总共移除 ...

哦 意思是说所有人围城一个圈啊？那就是说要连续不断的持续报数喽？那看来有点深度

class Test{
        public static void main(String[] args){
        int N = 100;
        int s = 0;
        int m = 14;
        for(int i=2; i<=N; i++) {
        s = (s+m)%i;
        }
        System.out.println("最终会留下的人的编号为:" + (s+1));
}
}

1. class Test{
   
2.         public static void main(String[] args){
   
3.         int N = 100;
   
4.         int s = 0;
   
5.         int m = 14;
   
6.         for(int i=2; i<=N; i++) {
   
7.         s = (s+m)%i;
   
8.         }
   
9.         System.out.println("最终会留下的人的编号为:" + (s+1));
   
10. }
    
11. }
    

复制代码

贾浩田 发表于 2014-10-18 17:26
请问“其他人重新开始”是从那个人开始啊，是原来的1,？？还是接下来要开始报数的15啊？ ...

同问啊！！！“其他人重新开始”到底是从哪里重新开始（下一个？从头？）  题目根本没有说明白啊！！
------从下一个开始是92，从头开始是2.。。。。。。

先瞅瞅，继续学习中

顶顶顶顶顶

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /*
   
7. *10、 有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
   
8. *然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
   
9. *
   
10. * 思路：
    
11. *         集合元素的角标从0开始 要删除第14个人就是删除13角标
    
12. *         删除之后其他人继续重新报数那么就是在原来角标上+13 —— +14的话 删除的是报15的人
    
13. *  由于当集合的长度<14时会循环报数 故做%size操作
    
14. *
    
15. */
    
16. 
    
17. public class Test10 {
    
18.         public static void main(String[] args) {
    
19.                 List<Integer> list = new ArrayList<Integer>();
    
20.                 //添加100人到集合
    
21.                 for (int i = 1; i < 101; i++) {
    
22.                         list.add(i);
    
23.                 }
    
24.                 System.out.println(list);
    
25.                 //删除所有报14的人
    
26.                 remove(list);
    
27.         }
    
28. 
    
29.         private static void remove(List<Integer> list) {
    
30.                 // TODO Auto-generated method stub
    
31.                 //确定集合长度
    
32.                 int size = list.size();
    
33.                 //设置被删除的角标 因为集合角标从0开始 所以第一次删除13
    
34.                 //如果集合的长度<要删除的角标数 要做取余操作
    
35.                 int index = 13%size;
    
36.                 while(size>1){
    
37.                         //长度大于1 删除指定位置的元素
    
38.                         list.remove(list.get(index));
    
39.                         //删除一个元素集合长度-1
    
40.                         size--;
    
41.                         //重新确定角标
    
42.                         index = (index+13)%size;
    
43.                 }
    
44.                 //集合只剩下一个元素
    
45.                 System.out.println("100人中剩下的是第-"+list.get(0)+"-个人");
    
46.         }
    
47. }
    

复制代码

兄弟我写了一个  看我的是不是另类  有这么写的么