1. /*
   
2. *
   
3. *Test36--有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
   
4. *然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
   
5. *
   
6. *分析：使用集合来做,这100个人是一个圈，所以到最后一定是剩下一个人
   
7. *本题说是重新开始计数，那么是从最开始的第一人开始计数还是从被删除后那人的后一位接着
   
8. *计数，没有明确说明，本地给出两种解决方案用于这两种不同的情况
   
9. * */
   
10. public class Test36 {
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 //往集合中添加100个数
    
14.                 List<Integer> list = new ArrayList<Integer>();
    
15.                 for(int i=1;i<=100;i++)
    
16.                 {
    
17.                         list.add(i);
    
18.                 }
    
19.                
    
20.                 //这种方法说的是删除第14位后原本的15位变为1
    
21.                 del14_1(list);
    
22.                
    
23.                
    
24.                 //这种方法是开始计数的位置永远不变，当第14位被删除后重新从第一位开始计数
    
25.                 //del14_2(list);
    
26.                
    
27.                
    
28.         }
    
29. 
    
30.         private static void del14_2(List<Integer> list) {
    
31.        
    
32.                 int count = 0,number = 1;
    
33.                
    
34.                 //这个集合最后肯定只剩下一个人
    
35.                 while(list.size()>1)
    
36.                 {
    
37.                         //因为每次删除完第14位后都需要重新进行迭代
    
38.                         Iterator<Integer> it = list.iterator();
    
39.                         while(it.hasNext())
    
40.                         {
    
41.                                 count++;
    
42.                                 Integer i =        it.next();
    
43.                                 if(count%14==0)
    
44.                                 {
    
45.                                         it.remove();
    
46.                                         //删除掉第14位后计数器计数器清零
    
47.                                         System.out.println("第"+number+++"轮循环被删除的元素是"+i);
    
48.                                         count=0;
    
49.                                         //不是从第15位开始继续计数了，而是跳出循环重新开始迭代该集合
    
50.                                         break;
    
51.                                 }
    
52.                         }
    
53.                 }       
    
54.                 System.out.println("最后集合变为："+list);
    
55. 
    
56.         }
    
57. 
    
58.        
    
59.        
    
60.         private static void del14_1(List<Integer> list) {
    
61.                 //定义计数器，一个用来显示循环了多少轮，一个用来记录第14位
    
62.                 int count = 0,number = 1;
    
63.                
    
64.                 //这个集合最后肯定只剩下一个人
    
65.                 while(list.size()>1)
    
66.                 {
    
67.                         //因为每次删除完第14位后都需要重新进行迭代
    
68.                         Iterator<Integer> it = list.iterator();
    
69.                         while(it.hasNext())
    
70.                         {
    
71.                                 count++;
    
72.                                 Integer i =        it.next();
    
73.                                 if(count==14)
    
74.                                 {
    
75.                                         it.remove();
    
76.                                         //删除掉第14位后计数器从第15位开始计数
    
77.                                         System.out.println("第"+number+++"轮循环被删除的元素是"+i);
    
78.                                         count=0;
    
79.                                 }
    
80.                         }
    
81.                 }       
    
82.                 System.out.println("最后集合变为："+list);
    
83.         }
    
84. }
    

复制代码

1. /*
   
2. *
   
3. *Test36--有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
   
4. *然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
   
5. *
   
6. *分析：使用集合来做,这100个人是一个圈，所以到最后一定是剩下一个人
   
7. *本题说是重新开始计数，那么是从最开始的第一人开始计数还是从被删除后那人的后一位接着
   
8. *计数，没有明确说明，本地给出两种解决方案用于这两种不同的情况
   
9. * */
   
10. public class Test36 {
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 //往集合中添加100个数
    
14.                 List<Integer> list = new ArrayList<Integer>();
    
15.                 for(int i=1;i<=100;i++)
    
16.                 {
    
17.                         list.add(i);
    
18.                 }
    
19.                
    
20.                 //这种方法说的是删除第14位后原本的15位变为1
    
21.                 del14_1(list);
    
22.                
    
23.                
    
24.                 //这种方法是开始计数的位置永远不变，当第14位被删除后重新从第一位开始计数
    
25.                 //del14_2(list);
    
26.                
    
27.                
    
28.         }
    
29. 
    
30.         private static void del14_2(List<Integer> list) {
    
31.        
    
32.                 int count = 0,number = 1;
    
33.                
    
34.                 //这个集合最后肯定只剩下一个人
    
35.                 while(list.size()>1)
    
36.                 {
    
37.                         //因为每次删除完第14位后都需要重新进行迭代
    
38.                         Iterator<Integer> it = list.iterator();
    
39.                         while(it.hasNext())
    
40.                         {
    
41.                                 count++;
    
42.                                 Integer i =        it.next();
    
43.                                 if(count%14==0)
    
44.                                 {
    
45.                                         it.remove();
    
46.                                         //删除掉第14位后计数器计数器清零
    
47.                                         System.out.println("第"+number+++"轮循环被删除的元素是"+i);
    
48.                                         count=0;
    
49.                                         //不是从第15位开始继续计数了，而是跳出循环重新开始迭代该集合
    
50.                                         break;
    
51.                                 }
    
52.                         }
    
53.                 }       
    
54.                 System.out.println("最后集合变为："+list);
    
55. 
    
56.         }
    
57. 
    
58.        
    
59.        
    
60.         private static void del14_1(List<Integer> list) {
    
61.                 //定义计数器，一个用来显示循环了多少轮，一个用来记录第14位
    
62.                 int count = 0,number = 1;
    
63.                
    
64.                 //这个集合最后肯定只剩下一个人
    
65.                 while(list.size()>1)
    
66.                 {
    
67.                         //因为每次删除完第14位后都需要重新进行迭代
    
68.                         Iterator<Integer> it = list.iterator();
    
69.                         while(it.hasNext())
    
70.                         {
    
71.                                 count++;
    
72.                                 Integer i =        it.next();
    
73.                                 if(count==14)
    
74.                                 {
    
75.                                         it.remove();
    
76.                                         //删除掉第14位后计数器从第15位开始计数
    
77.                                         System.out.println("第"+number+++"轮循环被删除的元素是"+i);
    
78.                                         count=0;
    
79.                                 }
    
80.                         }
    
81.                 }       
    
82.                 System.out.println("最后集合变为："+list);
    
83.         }
    
84. }
    

复制代码