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

這樣感覺清爽多了.