1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. class Mytestclass {
   
6.        
   
7.        
   
8.        
   
9.         public void method(ArrayList al,int size,int y){
   
10.                 if(al.size()!=1){
    
11.                         for (int  x = 1; x <size+1; x++) {
    
12.                                 if((x+y)%14==0){
    
13.                                         if(x==size){
    
14.                                                 al.remove(x);
    
15.                                                 y=0;
    
16.                                                 method(al,al.size(),0);
    
17.                                                
    
18.                                         }
    
19.                                         else{
    
20.                                                 al.remove(x);
    
21.                                         }
    
22.                                 }
    
23.                                 else {
    
24.                                         if(x==size){
    
25.                                                 y=(x+y)%14;
    
26.                                                 method(al,al.size(),y);
    
27.                                                
    
28.                                         }
    
29.                                
    
30.                                 }
    
31.                        
    
32.                         }
    
33.                  
    
34.                 }
    
35.                        
    
36.         }
    
37.        
    
38. }
    
39.                
    
40.                
    
41.                        
    
42.        
    
43. public class Test10 {
    
44.        
    
45. 
    
46.         public static void main(String[] args) {
    
47.                 ArrayList<Integer> al=new ArrayList<Integer>();
    
48.                 for (int i = 1; i < 101; i++) {
    
49.                         al.add(i);
    
50.                 }
    
51.                
    
52.                 System.out.println(al);
    
53.                 Mytestclass mtc=new Mytestclass();
    
54.                 mtc.method(al,100,0);
    
55.                 System.out.println(al);
    
56.                
    
57. 
    
58.         }
    
59. 
    
60. }

复制代码

上面程序，是解决下面这个问题:
有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
我想问各位大神的是，我的代码哪里写错了，运行抛出角标越界异常，然后如果我的思路不正确，还请大神们给一个比较清楚思路的代码 谢谢啦

大神！！！！！！！

这是一首简单的小情歌，，，，

package cn.itcase.it;

import java.util.*;
public class  Test
{
        public static void main(String[] args)
        {
                ArrayList<Integer>  s=getSimple(100);
                System.out.println(s.get(0));

        }
        public static ArrayList<Integer> getSimple(int max)
        {
                //定义一个数组，装入1到指定的100的所有值
                ArrayList<Integer> arr=new ArrayList<Integer>();
                for(int x=1;x<=max;x++)
                {
                        arr.add(x);
                }
                //定义一个计数器
                int count=0;
                //开始循环，对集合进行遍历
                while(arr.size()>1)
                {
                        //遍历的时候count自加
                        for(ListIterator<Integer> li=arr.listIterator();li.hasNext();)
                        {
                                Integer i=li.next();
                                count++;
                                if(count==14)
                                {
                                        li.remove();
                                        count=0;
                                }
                        }
                        //判断当集合中只有一个元素时返回。
                }
                return arr;
        }
}

不知道对不？不懂在问我
package cxw.study.one;

import java.util.ArrayList;
import java.util.ListIterator;

public class Test2 {
        public static void main(String[] args) {
                ArrayList<Integer> list = new ArrayList<Integer>();
                for(int i = 1; i< 101; i++){
                        list.add(i);
                }
                System.out.println("过程：不知道对不对？");
                work(list);
                System.out.println("最后剩下第" + list.get(list.size()-1) + "个人！");
        }

        private static void work(ArrayList<Integer> list) {
                int count = 0; //计数器
                //list集合大小少于14就退出
                if(list.size() < 14){
                        return;
                }
                ListIterator<Integer> iter = list.listIterator();
                while(iter.hasNext()){
                        Integer num = iter.next();
                        System.out.print(num + " ");
                        count++;
                        if(count % 14 == 0){
                                System.out.println();
                                iter.remove();//移除iter.next()元素
                                work(list);//递归调用
                        }
                }
               
        }
}
运行：
过程：不知道对不对？
1 2 3 4 5 6 7 8 9 10 11 12 13 14
1 2 3 4 5 6 7 8 9 10 11 12 13 15
1 2 3 4 5 6 7 8 9 10 11 12 13 16
1 2 3 4 5 6 7 8 9 10 11 12 13 17
1 2 3 4 5 6 7 8 9 10 11 12 13 18
........
1 2 3 4 5 6 7 8 9 10 11 12 13 96
1 2 3 4 5 6 7 8 9 10 11 12 13 97
1 2 3 4 5 6 7 8 9 10 11 12 13 98
1 2 3 4 5 6 7 8 9 10 11 12 13 99
1 2 3 4 5 6 7 8 9 10 11 12 13 100
最后剩下第13个人！

不能用取模方式，而应该采用计数方式。

1. package cn.itcast.blackhorse.demo;
   
2. import java.util.ArrayList;
   
3. import java.util.Arrays;
   
4. import java.util.Iterator;
   
5. /* 要求：
   
6. *   有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
   
7. *           然后其他人重新开始，从1报数，到14退出。
   
8. *   问：最后剩下的是100人中的第几个人？
   
9. * 思路：
   
10. * 1、创建一个长度为101的int的数组，确认退出规则，1代表未报号，0代已经报号
    
11. * 2、对数组每一个元素进行赋值，除0角标不用赋值外，其他均赋值为1
    
12. * 3、设定一个计数器，使计数器初始为0，当计数器为14时进行重置
    
13. * 4、设定一个指针pointer，当pointer运算到数组最后一个元素时，再将定位置1角标
    
14. * 5、设定一个剩余人数，初始为100，当剩余人数为1时，返回该角标位置。
    
15. *
    
16. */
    
17. public class Question {
    
18.         public static void main(String[] args){
    
19.                 int[] arr=new int[101];
    
20.                 for (int i = 1; i<arr.length; i++) {
    
21.             arr[i]=1;
    
22.                 }                        
    
23.                 System.out.println(Arrays.toString(arr));
    
24.                 getlastNumber(arr);  //运行结果pointer=78
    
25.         }
    
26. 
    
27.         public static void getlastNumber(int[] arr) {
    
28.                 int num=100;
    
29.                 int count=0;
    
30.                 for (int pointer=1; pointer < arr.length; pointer++) {
    
31.                         if(arr[pointer]!=0){
    
32.                                 count++;
    
33.                                 if(count==14){
    
34.                                         arr[pointer]=0;
    
35.                                         count=0;
    
36.                                         num--;
    
37.                                 }
    
38.                                         if(num==1){
    
39.                                                 System.out.print(pointer);
    
40.                                                 return;
    
41.                                         }
    
42.                         }
    
43.                         if(pointer==arr.length-1)
    
44.                                 pointer=1;
    
45.                 }
    
46.         }
    
47. }
    
48. 
    

复制代码