这个算法怎么解！！！ 大家帮忙看看！！

Question

一个大于0的整数 N , 求 2 * N + 4*N + 8*N + 16*N 以此类推，当X*N 大于 5000的时候输出！ 然后从小到大以此输出 2*N 、 4*N 、 8*N 、 16*N X*N .... 不大于5000 输出完之后再倒着从大到小输出 X*n .... 16*N 、8*N 、4*N 、2*N 不能用循环 不能用本地变量！

Answer 1

public static void print(int n){

if((n = n << 1) <= 5000) {

System.out.print(n + " ");

print(n);

System.out.print(n + " ");

} else {
System.out.println();
}
}

Answer 2

既然不能用循环，楼主必须要想到这个其实是考察你递归式的运用

public static int TowPowWithN(int n) {

    int sum = TowPowWithN(n, 2, 0);
    return sum;
}

public static int TowPowWithN(int n, int x, int sum) {
    if (n == 0) {
        return 0;
    }
    int y = n * x;
    System.out.println(y);
    sum += y;
    if (y >= 5000) {
        return sum;
    } else {
        x *= 2;
        return TowPowWithN(n, x, sum);
    }

倒序打印我是没想出来 楼主可以自己想想了

Answer 3

这个..明显考递归的啦！

public class test{

static void test(int n){
n*=2;
if(n<=5000)
{
printf("%d,",n);
test(n);
printf("%d,",n);
}
else
{
printf("\n");
return;
}
}

static void main(int argc,String args[])
{

}

}

Answer 4

这个主要考察的是递归的理解 因为递归 有个入栈和出栈的过程哈！

public class Test{

static void test(int n){

n*=2;

if(n<=5000)

{

System.out.print(n);

test(n);

System.out.print(n);

}

else

{

System.out.println();

return;

}

}

static void main(String args[])

{

if(args.length<2)
System.out.println("输入n");
else
test(Integer.parseInt(args[1]));

}

}

如果正确，请选为最佳答案 谢谢

Answer 5

//要求是得到X以後先打印X的結果，再正序打印累加序列的話。需要在計算的時候得用減法，保證遞歸棧的順序正確。
                    int Count(int result, int X, int N, boolean isFirstEnter ){
                        if ( isFirstEnter ){
                            if ( result > 0 ){
                                X++;
                                result -= 2*X*N;
                                Count(result, X, N, isFirstEnter);
                                System.out.println(2*X*N);
                            }

                            else{//最終結果已經得到，d
                                System.out.println(X);
                            }

                            if ( result == 5000 ){//正序打印完畢，開始第二次遞歸，並進行倒序打印
                                Count(result, 1, N, false);
                            }
                        }
                        else{
                            if ( result > 0 ){
                                System.out.println(2*X*N);
                                X++;
                                result -= 2*X*N;
                                Count(result, X, N, isFirstEnter);
                            }
                        }
                    }

                    int invertedOrderPrint(int result, int X, int N){
                        if ( result - 2*X*N > 0 ){
                            X++;
                            result 
                            invertedOrderPrint()
                        }
                    }