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

其实这题还是比较简单的啦,主要还是思路问题,我的思路是当14个人退出后从15个人开始重新数,当然此时的第15人在这个圈中是14,因为他取代了原来退出的14的那个人的位置!       思路:我们可以定义两个变量,一个用于记录报数的人是第几个人,另一个记录报数的总次数
       步骤:  A:定义count 记录次数,当count%14==0的时候,说明有人该退出了
                 B:定义一个循环用于记录那个人在报数,当这个报数的人报到最后一个人的时候,又从第一个人开始报数
                 C:一直重复上面的步骤,直到只有一个人的时候就输出这个人就行了.
语言表达能力比较差,直接上代码吧!
    ArrayList<Integer> list=new ArrayList<>();
                for (int i = 1; i <= 100; i++) {
                        list.add(i);
                }
                int count=0;//记录报数的次数
                for (int j = 1; j <= list.size(); j++) {//j就表示是第几个人在报数
                        count++;
                        if (count%14==0) {
                                int a=list.get(j-1);
                                list.remove(j-1);
                                j--;
                        }
                        if (j>=list.size()&&list.size()!=1) {//当只有一个人的时候就不需要再回去了
                                j=0;//因为是围成一个圈所以当每个人都报数完后回到第一个人报数,因为这里放在循环的末尾,结束后j会马上自增一次
                        }
                        syso输出这个身下的数就行了

package 练习;  import java.util.ArrayList; public class Test2 {         public static void main(String[] args) {                 ArrayList<Integer> list = new ArrayList<>();                  for (int i = 1; i < 101; i++) {                         list.add(i);                 }                 int count=0;                 while(true){                         if(list.size()>1){                                 for (int i = 0; i < list.size(); i++) {                                         count++;                                         if(count==14){                                                 list.remove(i);                                                 count=0;                                                 i--;                                         }                                 }                         }else{                                 break;                         }                 }                 System.out.println(list);         } }

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

这个代码，基本接近API 的链表源码了吧。。。。我这个菜鸟只能望洋兴叹了

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

这个代码，基本接近API 的链表源码了吧。。。。我这个菜鸟只能望洋兴叹了

臭和尚 发表于 2014-10-23 12:18
class Test{
        public static void main(String[] args){
        int N = 100;

循环里面的 s = (s+m)%i; 代表什么呢

臭和尚 发表于 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));

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

学习了。。。

代码呢,写出来啊

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

新人路过，努力学习中

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

题目就不怎么清楚

/*
* 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

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

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;
                }
        }
}

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

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.         }

复制代码

学习了，呵呵