1. public class Test10 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 for(int i=1;i<=10000;i++){
   
5.                         if(i%14==0 && i>9900){
   
6.                                 System.out.println(i-9900);
   
7.                         }
   
8.                 }
   
9.                
   
10.        
    
11.         }
    
12. }难道这么暴力算出的答案还不对吗？

复制代码

import java.util.LinkedList;

public class Count {
        public static void main(String[] args) {

                LinkedList<Integer> i = new LinkedList<Integer>();

                for (int x = 1; x < 101; x++) {
                        i.add(x);
                }

                while (i.size() != 1) {
                        for (int x = 0; x < 13; x++) {
                                i.add(i.removeFirst());
                        }
                        i.removeFirst();
                }

                System.out.println(i);
               

        }
}

谢谢分享

我直接用数组做的，可参考。

1. package com.itheima;
   
2. /**
   
3. * 第10题：有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
   
4. * 然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
   
5. * @author zl
   
6. *思路：
   
7. *一，可以定义一个数组，数组的索引表示每个人的id，元素大小可以设为0和1，0表示数到14的出圈的人，1表示还在圈里；
   
8. *二，定义count，表示当前报的数，具有累加性，定义在循环外；num表示在圈里剩下的人数；
   
9. *三，定义嵌套循环，内循环表示遍历数组并进行判断剩余的人数；外循环一直执行直到剩余人数为1就跳出。
   
10. */
    
11. public class Test10_ArrayCount {
    
12. 
    
13.         public static void main(String[] args) {
    
14. 
    
15.                 int[] arr = new int[100];
    
16.                 for(int i=0; i<arr.length; i++) {
    
17.                         arr[i] = 1;
    
18.                 }       
    
19.                
    
20.                 //定义当前应该报的数
    
21.                 int count = 1;
    
22.                
    
23.                 //循环报数，报数一圈（遍历一次数组）为一次循环，得到剩余的人数和报数，并判断；
    
24.                 while(true) {
    
25.                         //定义圈里剩下的人数；由于出圈的人在仍在数组里，所以每次遍历前都需要先假定其没有出圈并进行判断；
    
26.                         int num = arr.length;
    
27.                        
    
28.                         for(int i=0; i<arr.length; i++) {
    
29.                                 //判断当前人数是否出圈，如果出圈则报数不改变而人数减1；如果在圈内，则先判断当前报数大小
    
30.                                 if(arr[i]==0) {
    
31.                                         //如果当前人早已经出圈，则num---
    
32.                                         num --;
    
33.                                 } else {
    
34.                                         //如果当前人没有出圈，则判断报数大小
    
35.                                         if(count !=14) {
    
36.                                                 //如果当前报数不等于14则下一个报数增1
    
37.                                                 count ++;
    
38.                                         } else {
    
39.                                                 //如果当前报数为14，则当前元素值设为0，即出圈；重设count =1；圈里的人数变为num-1
    
40.                                                 arr[i] = 0;
    
41.                                                 count =1;
    
42.                                                 num --;
    
43.                                         }
    
44.                                 }
    
45.                         }               
    
46. //                        System.out.println(num);
    
47.                        
    
48.                         //如果循环一圈后，圈内人数为1，则跳出循环
    
49.                         if(num==1) {
    
50.                                 break;
    
51.                         }
    
52.                 }
    
53.                
    
54.                 //遍历并选出元素为1的索引
    
55.                 for(int i=0; i<arr.length; i++) {
    
56.                         if(arr[i] == 1) {
    
57.                                 //数组的索引是从0开始的，因此需要加1才表示实际的人的次序。不能说第0个人吧！
    
58.                                 int left = i+1;
    
59.                                 System.out.println("最后剩下的是第"+ left+"人");
    
60.                         }
    
61.                 }
    
62.                
    
63.         }
    
64. }
    

复制代码

臭和尚 发表于 2014-10-23 12:19

嘿，哥们，能够对这个程序做点解释？这个简洁、高效的代码（我所见过的几种方法中最简洁最高效的），如果看不懂真是可惜啊！！！

学习下！

学习了，呵呵

1. public static void main(String[] args){
   
2.                
   
3.                 //创建链表集合 LinkedList
   
4.                 LinkedList<Integer> link=new LinkedList<Integer>();
   
5.                 for(int i=1;i<=100;i++){
   
6.                         plink.add(i);
   
7.                 }
   
8.                
   
9.                 int start=0,count=1;
   
10.                 int link_size=link.size();
    
11.                 while(link_size>1){
    
12.                         //循环移除链表集合元素的方式得到最后一个元素
    
13.                         System.out.println("第"+ count++ +"个退出的人的编号："+link.remove(start=(start+13)%link_size).intValue());
    
14.                         link_size=link.size();
    
15.                 }
    
16.                 //最后剩下的一个元素的order属性就是答案
    
17.                 System.out.println("\n"+"最后剩下的人的编号是："+link.peek().intValue());
    
18.                
    
19.         }

复制代码

我怎么感觉这题会用递归呢？

package com.yuxi.day20;
import java.util.ArrayList;
public class Test2 {

        /**
         *         需求:2、 有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
         * 然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
         *
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                //建立一个集合分别把握1-100的数字存入
                ArrayList<Integer> al =new ArrayList<Integer>();
                for(int i=0;i<100;i++)
                {
                        al.add(i+1);
                }
                method(al);
                System.out.println(al.get(0));
        }
        public static void method(ArrayList<Integer> arr)
        {
                //报的数字开始值为1
                int number=1;
                while(true)
                {
                        //确定集合中至少有一元素
                        if(arr.size()>1)
                        {
                                //循环遍历当number等入14的时候,删除集合相对应的为元素
                                for(int i=0;i<arr.size();i++,number++)
                                {
                                        //当报到14的数就删除集合对应的元素
                                        if(number==14)
                                        {
                                                //对number重新置0
                                                number%=14;
                                                arr.remove(i);
                                                //删除后要使集合指向减1
                                                i--;
                                        }
                                }
                        }
                        //当最集合中只有一个元素的时候就是最后留下的那个人
                        else break;
                }
        }
}

package com.yuxi.day20;
import java.util.ArrayList;
public class Test2 {

        /**
         *         需求:2、 有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
         * 然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
         *
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                //建立一个集合分别把握1-100的数字存入
                ArrayList<Integer> al =new ArrayList<Integer>();
                for(int i=0;i<100;i++)
                {
                        al.add(i+1);
                }
                method(al);
                System.out.println(al.get(0));
        }
        public static void method(ArrayList<Integer> arr)
        {
                //报的数字开始值为1
                int number=1;
                while(true)
                {
                        //确定集合中至少有一元素
                        if(arr.size()>1)
                        {
                                //循环遍历当number等入14的时候,删除集合相对应的为元素
                                for(int i=0;i<arr.size();i++,number++)
                                {
                                        //当报到14的数就删除集合对应的元素
                                        if(number==14)
                                        {
                                                //对number重新置0
                                                number%=14;
                                                arr.remove(i);
                                                //删除后要使集合指向减1
                                                i--;
                                        }
                                }
                        }
                        //当最集合中只有一个元素的时候就是最后留下的那个人
                        else break;
                }
        }
}

臭和尚 发表于 2014-10-23 12:19

代码是对的。完全看不懂。。

/*
* 10、 有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。
* 然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
*/
public class Test10 {

        public static void main(String[] args) {
                ArrayList<Integer> al = new ArrayList<Integer>();
                // 循环存储 1-100
                for (Integer i = 1; i <= 100; i++) {
                        al.add(i);
                }
                // 计数器
                int num = 0;
                // 外层循环 当集合长度为1时 结束循环
                for (; !(al.size() == 1);) {
                        // 内层循环 遍历集合
                        for (int i = 0; i < al.size(); i++) {
                                // 每循环一次计数器 +1
                                num++;
                                // 判断 当计数器为14的倍数时
                                if (num % 14 == 0) {
                                        // 删除这个元素
                                        al.remove(i);
                                        // 因为删除了1个元素，所以这个删去元素的索引上，是这个删去元素的后一个
                                        // 让索引减一 重新遍历该索引上的元素
                                        i--;
                                }
                        }
                }
                System.out.println(al.toString());
        }
}

题目就不怎么清楚

我刚做完 不客气  幸运数字
-

新人路过，努力学习中

啊啊发生的公司的分公司答复

代码呢,写出来啊

学习了。。。

臭和尚 发表于 2014-10-23 12:19

好牛 o.O
                int k = 100;
               
                LinkedList list = new LinkedList<Integer>();
                for(int i=1;i<=k;i++)
                        list.add(i);
               
                Iterator it = list.iterator();
               
                while(list.size()!=1) {
                        for(int i=0;i<14;i++) {
                                if(!it.hasNext())
                                        it = list.iterator();
                                it.next();                       
                        }
                        it.remove();               
                }
                System.out.println(list.get(0));

这是我的代码，我想过用数组的，但是不知道怎么解决，你这个好简洁啊