有1到100共100个数, 从1开始, 每隔1, 2, 3... 个数拿走一个数, 最后剩下几?(约瑟夫环)

最近找实习, 在做Test Assignment时遇到了这么道题, 就顺便记录下来:
说, 有1到100共100个数, 摆成一个圈. 从1开始, 每隔1, 2, 3, 4 ... 个数拿走一个数, 一直循环, 最后剩下几? 具体的讲就是一开始(隔0个数)把 1 拿走, 隔1个数(2)把3拿走, 再隔2个数(4, 5)把6拿走, 再隔3个数(7, 8, 9)把10拿走. 第一圈数到100之后接着从2开始数, 直到最后剩下1个数为止, 请问最后剩下几? 如果是1到n呢?

    public static int selectNumber(int n) {
        
        int result = -1;
        ArrayList<Integer> nums = new ArrayList<Integer>();
        int index = 0;     // this variable is used to remove numbers from list 
        int count = 0;     // count is used to count which numbers should be remove
        int pIndex = 0;  // this is used to record previous index
        
        // generate a list contains numbers from 1 to n
        for(int i = 1; i <= n; i++) {
            nums.add(i);
        }
        
        while(nums.size() > 1) {
            
            while(index < nums.size()) {
                nums.remove(index);     
                count++;
                pIndex = index;
                index += count;
            }
            
            index = count - (nums.size() - pIndex);
            
            while(index > nums.size() - 1) {
                index = index - nums.size();
            }
        }
        
        result = nums.get(0);
        return result;
    }
    
    public static void main(String[] args) {
        int surviver = selectNumber(100);
        System.out.println("The surviver is: " + surviver);
    }

以上就是我的解决方案, 最后留下的数是31

---

2016.06.04更新:

在我发布这篇博文之后热心网友指出这叫"约瑟夫环". 于是我就去网上搜了一下, 并找到了一个比较简洁的约瑟夫环代码(这个代码不是我原创, 是在别人代码的基础上修改得来):

    /**
     * 约瑟夫环:
     * n个数字摆成一个环, 从1开始数, 数到m或m的倍数的数字被删除, 然后继续, 直到剩下1个数字为止
     */
    public static int josephProbBasic(int n, int m) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i = 1; i <= n; i++) {
            list.add(i);
        }
        // 用于计数
        int count = 1;
        // 当list中只剩下1个数时, 结束循环
        for(int i = 0; list.size() > 1; i++) {
            // 如果数到list的结尾, 从0开始重新数
            if(i == list.size()) {
                i = 0;
            }
            // 在m的倍数时, 删除对应的数
            if(count % m == 0) {
                // 由于删除之后, list中被删除元素之后的元素都会依次向前移动一位, 因此也要把i向前移动一位
                list.remove(i--);
            }
            count++;
        }
        return list.get(0);
    }

但是这只是普通的约瑟夫环, 而我的问题要更麻烦一点. 于是乎, 我根据上面的思路重写了这个问题的代码:

    /**
     * 升级版约瑟夫环:
     * n个数字摆成一个环, 从1开始数, 每隔m个数字删除一个数字. m的初始值为0, 然后m++, 就是0, 1, 2, 3....
     *  这样不断删除, 直到剩下1个数字为止.
     * @param n
     * @return
     */
    public static int josephProbV2(int n) {
        ArrayList<Integer> list = new ArrayList<>();
        for(int i = 1; i <= n; i++) {
            list.add(i);
        }
        int count = 0;
        int m = 0;
        for(int i = 0; list.size() > 1; i++) {
            if(i == list.size()) {
                i = 0;
            }
            // 如果count数到m个数, 就删除对应的数字, 同时count从零开始重新数, m = m + 1
            if(count == m) {
                list.remove(i--);
                count = 0;
                m++;
            }else {
                count++;
            }
        }
        return list.get(0);
    }

这样感觉清爽多了.