求一道程序题，用java实现

[hanhan1720]

问题：
有n个盘子，从上到下依次为1，2，3。。。n层叠。把第1个盘子移到第n个盘子的下面，然后扔掉第2个盘子。然后把第3个盘子移到最下面，扔掉第4个盘子。如此进行下去，问最后剩下第几号盘子。

[groovy2007]

约瑟夫问题
将n表示成二进制，然后将最高位的1移到末尾，即得
比如有5个盘子，5写成二进制是101,将高位的1移到末尾，得011，也就是3
推导过程见《具体数学》

[hanhan1720]

麻烦用程序如何实现阿，能不能给个代码

[少林寺烹饪速成班]

个人觉得应该用递归法吧。。

[Jacketcat]

递归和while循环应该都可以实现吧

[tpshowcom]

对于这倒题，在输入n的时候可以输入固定的2，因为每次扔掉的都是第二个盘子，这样就符合这个题目的条件了,这个题是变相的约瑟夫问题，真正的约瑟夫问题m和n都是不固定的。

如果输入m=5,n=2,输出结果如下：
-------------------------------
程序说明如下：
有n个盘子，从上到下依次为1，2，3...n层叠。把第1个盘子移到第n个盘子的下面，然后扔掉第2个盘子。然后把第3个盘子移到最下面，扔掉第4个盘子...如此进行下去,直到剩下最有一个盘子，对已给定的盘子数m,求出扔出盘子的顺序以及最后剩下的盘子的序号
请输入盘子的个数：
5
请输入扔出第几个盘子：
2
按扔出盘子的次序输出序号：
2 4 1 5 3
最后剩下的盘子的序号为：
3
---------------------------------

import java.util.Scanner;
public class RingTest{
    public static void main(String[] args){
        System.out.println("程序说明如下：");
        System.out.println("有n个盘子，从上到下依次为1，2，3...n层叠。" +
        		"把第1个盘子移到第n个盘子的下面，然后扔掉第2个盘子。然后把第3个盘子移到最下面，扔掉第4个盘子..." +
        		"如此进行下去,直到剩下最有一个盘子，对已给定的盘子数m,求出扔出盘子的顺序以及最后剩下的盘子的序号");
        //提示输入盘子的个数
        System.out.println("请输入盘子的个数：");
        Scanner sca=new Scanner(System.in);
        int m=sca.nextInt();
        //提示输入要扔掉第几个盘子，这道题是固定的，n=2
        System.out.println("请输入扔出第几个盘子：");        
        int n=sca.nextInt();
        System.out.println("按扔出盘子的次序输出序号：");        
        //创建有m个值的数组
        int[] a=new int[m];
        int[] b=new int[m];
        //初始长度，以后出圈一个，长度就减一
        int len=m;
        //给数组赋值
        for(int i=0;i<a.length;i++)
            a[i]=i+1;
        //i为元素下表，j代表当前要报的数
        int i=0;
        int j=1;
        int k=0;
        while(len>0){
            if(a[i%m]>0){
                if(j%n==0){//找到要扔出的盘子，并把盘子的个数减一
                    System.out.print(a[i%m]+"  ");
                    b[k] = a[i%m];
                    k++;
                    a[i%m]=-1;
                    j=1;
                    i++;
                    len--;
                }else{
                    i++;
                    j++;
                }
            }else{//遇到空位了，就跳到下一位，但j不加一，也就是这个位置没有报数
            	 i++;
            }
        }
        //最后剩下的盘子序号
        System.out.println("");
        System.out.println("最后剩下的盘子的序号为：");
        System.out.println(b[k-1]);
       
    }
} 

[rainsilence]

import java.util.LinkedList;

public class Test {
	
	private LinkedList<Integer> list = new LinkedList<Integer>();
	
	public Test(int max) {
		for (int index = 1; index <= max; index++) {
			list.add(index);
		}
	}
	
	private void addLast() {
		list.addLast(list.removeFirst());
		list.removeFirst();
	}
	
	private Integer execute() {
		
		while(list.size() > 1) {
			addLast();
		}
		return list.get(0);
	}
	
	public static void main(String args[]) {
		System.out.println(new Test(6).execute());
	}
}

[andy2u]

6楼正解，不错啊，简洁明了，厉害

[foxright]

菜鸟路过中。

[DSZ911]

转换为二进制处理
public class Jussefu {

public static void main(String[] args) {
Jussefu jsf=new Jussefu();
jsf.finddisk(14);
}


public void finddisk(int n){
int m=n;
int[] t={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
for(int i=0;i<16;i++){
if(m%2==0){
t[15-i]=0;
}
else t[15-i]=1;
m=m/2;

}
for(int j=0;j<16;j++){
System.out.print(t[j]);
}
System.out.println();

for(int j=0;j<16;j++){
if(t[j]==1){
for(int k=j;k<15;k++){
t[k]=t[k+1];
}
t[15]=1;
break;
}

}
for(int j=0;j<16;j++){
System.out.print(t[j]);
}

}
}

[hua_zhixing_]

用队列

[yuanlaifenglin]

记号。。。。

[i地平线]

package Lession_Two;
import java.util.List;
import java.util.ArrayList;
public class PanZi {
List<String> ar=new ArrayList<String>();
private int j=0;

public void array(int n){
for(int i=1;i<=n;i++){
ar.add(i+"");
}
for(int i=0;i<=ar.size()-1;i++){
if((2*j+1)>ar.size()-1){
break;
}
String str=ar.get(2*j);
ar.add(str);
ar.remove(2*j);
ar.remove(2*j+1);
}
for(String s : ar){
System.out.println("剩余的盘子编号为：ar["+(100-n)+"]="+s);
n--;
}
}

public static void main(String[] args) {
PanZi pz=new PanZi();
pz.array(100);
}

}

[i地平线]

貌似不是递归或者什么约瑟夫问题：
下标一直在动：
比如：1，2，3，4，5 五个盘子

//先1和2
1，2，3，4，5
2，3，4，5，1
2,4,5,1

//在3 和 4
2,4,5,1 //未动时 的剩余盘子排列
2,4,1,5
2，4，1

//在5和6
越界！
the answer is 2,4,1

[littlecardan]

正在学习了。

[跑跑鱼]

学习了。
经典的汉诺塔问题有人说最好不用递归,据说这样占内存，最后可能卡死，请问是真的吗？

[hanhan1720]

多谢各位指点，很受启发！

[欢乐极客]

[hjjk123]

好好学习算法了要.............

[hanhan1720]

多谢各位，分不多。还请见谅！