有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。就是这个，我如果设置一个死数进去没什么问题，如果在加上IO就....各种不对，帮忙看下~

1. import java.io.*;
   
2. import java.util.ArrayList;
   
3. import java.util.List;
   
4. import java.util.ListIterator;
   
5. 
   
6. 
   
7. 
   
8. public class Test {
   
9. 
   
10.         public static void main(String[] args) throws IOException {
    
11.                 System.out.println("请输入要多少个人");
    
12.                 DataInputStream bufr = new DataInputStream(System.in);
    
13.                 int num = bufr.read() ;
    
14.                
    
15.                 final int flag = 3;
    
16. 
    
17.                 List<Integer> mans = new ArrayList<Integer>();
    
18.                 for (int i = 0; i < num; i++) {
    
19. 
    
20.                         mans.add(i + 1);
    
21. 
    
22.                 }
    
23. 
    
24.                 System.out.println("有" + mans +  mans.size() + "个人围成一圈");
    
25.                 ListIterator<Integer> iter = null;
    
26. 
    
27.                 int k = 1;
    
28. 
    
29.                 do {
    
30.                         iter = mans.listIterator();
    
31.                         while (iter.hasNext()) {
    
32.                                 int i = iter.next();
    
33.                                 if (k++ % flag == 0) {
    
34. 
    
35.                                         System.out.println("编号" + i + "的人退出圈子");
    
36.                                         iter.remove();
    
37.                                         k = 1;
    
38. 
    
39.                                 }
    
40. 
    
41.                         }
    
42. 
    
43.                 } while (mans.size() > 1);
    
44.                
    
45.                 System.out.println("剩下编号为" + mans + "的" + mans.size() + "个人");
    
46. 
    
47.         }
    
48. }

复制代码

哪里错了

那个num接收的值就错了。
类型转换的问题吧，输入1的话赋的值是49，是字符‘1’的值。
我把第13行改成

1.                 int num = bufr.read()-49 ;

复制代码

之后试了一下，结果就对了。

这种错误在Eclipse里面debug一下就看出来了吧。

1. public static void main(String[] args) {
   
2.                 int luckly = getluckly(100);
   
3.                 System.out.println("剩下的人是第:" + luckly + "个人");
   
4.         }
   
5. 
   
6.         public static int getluckly(int num) {
   
7.                 List<Integer> list = new LinkedList<>();                 // 定义一个集合因为LinkedList查找快所以用它
   
8. 
   
9.                 for (int i = 1; i <= num; i++) {                                 // 遍历每个元素
   
10.                         list.add(i);                                                         // 把元素封装到list.add(i);中
    
11.                 }
    
12.                 int count = 1;                                                        // 定义一个计数的
    
13.                 for (int i = 0; list.size() != 1; i++) {                         // 遍历集合只要集合中的元素不为1,就不断的循环
    
14.                         if (i == list.size()) {                                         // 当i自增到集合中元素的个数是
    
15.                                 i = 0;                                                        // 就将i重新置为0
    
16.                         }
    
17.                         if (count % 3 == 0) {                                      // 只要查找到了3的倍数是就从集合中删掉
    
18.                                 list.remove(i--);                                      // 删除的时候要索引--
    
19.                         }
    
20.                         count++;                                          // 查数递增
    
21.                 }
    
22.                 return list.get(0);                                            // 最后集合中只要有一个元素就是哪个幸运的
    
23.         }

复制代码

我也写了个，感觉挺好理解。

package cn.itcast.day2;

import java.util.*;

/*题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），
凡报到3的人退出圈子，问最后留下的是原来第几号的那位。*/
public class WuYi2 {

        public static void main(String[] args) {
                System.out.println("请输入参加人数：");
               
                //引入扫描器
                Scanner input=new Scanner(System.in);
                int person=input.nextInt();
               
                //建个boolean类型数组，判断人进出的情况
                boolean[] flag=new boolean[person];
               
                for (int i = 0; i < flag.length; i++) {
                        //将所有都标记成圈内人
                        flag[i]=true;
                }
               
                //依次初始化参加人数、报号数和变化标记
                int count=person,number=0,index=0;
               
                //人数必须大于1，基数最少为2
                while(count>1){
                        //从第一个人开始报
                        if(flag[index]){
                                //报号数每次增1
                                number++;
                               
                                //当报号数为3时
                                if(number==3){
                                        //当前的人出去
                                        flag[index]=false;
                                       
                                        //报号数清零
                                        number=0;
                                       
                                        //人数减1
                                        count--;
                                }
                        }   
                        index++;
                       
                        //当索引为数组长度时，取不到人了，数组下标越界，Index归零
                        if(index==person){
                                index=0;
                        }
                }
               
                //遍历数组，此时只剩1人
                for (int j = 0; j < person; j++) {
                        if(flag[j]){
                                System.out.println("原始的数是："+(j+1));
                        }
                }       
        }
}