n进制转换+2的n次幂

一、题目要求

1、任何一个正整数都可以用2的幂次方表示

2、任何一个正整数都可以用2的幂次方表示。

例如：

137=2^7+2^3+2^0<p>

同时约定幂次方用括号来表示，即ab 可表示为a（b）。

由此可知，137可表示为：

　　　　   2（7）+2（3）+2（0）<p>

进一步：7= 2²⁺²⁺²0 （21用2表示）

　　　　   3=2+2^0  <p>

所以最后137可表示为：

　　　　   2（2（2）+2+2（0））+2（2+2（0））+2（0）

样例输入 Sample Input:

73

样例输出 Sample Output:

 2(2(2)+2)+2(2+2(0))+2(0)

二、递归模型

1、转换n进制

$$F(tar)=\{\begin{array}{rcl}nBinary(tar)=tar& & 当转换目标<转换进制\\ & & \\ & & \\ & & \\ nBinary(tar/toBinary)& & 当转换目标>转换进制\\ result=tar\%toBinary& & \end{array}$$

2、转换成2的n次幂

$$F(tar)=\{\begin{array}{rcl}resultString+=0& & 目标数==0\\ & & \\ & & \\ & & \\ Result(position)& & position!=1\end{array}$$

三、代码实现以及测试代码

(一)、代码实现

1、转换n进制

package 第一题;

import java.util.Scanner;
import java.util.Stack;

public class Main {
    private static final String [] binaryVALUE = {"0","1","2","3","4","5","6","7","8","9",
        "A","B","C","D","E","F"};
    private static int toBinary;
    public static StringBuffer result = new StringBuffer();

    public void setToBinary(int toBinary) {
        this.toBinary = toBinary;
    }

    public static void main(String [] args) {
        Scanner scanner = new Scanner(System.in);
        toBinary = scanner.nextInt();
        int target = scanner.nextInt();
        System.out.print("递归方式：");
        System.out.println(nBinary_dg(target).reverse().toString());
        result.delete(0, result.length());
        System.out.print("非递归方式：");
        nBinary(target);
    }

    public static StringBuffer nBinary_dg(int target) {
        result.append(binaryVALUE[target % toBinary]);
        if(target < toBinary) {
            return result;
        }
        return nBinary_dg(target / toBinary);
    }

    public static void nBinary(int target) {
        int tar = target;
        Stack<String> binaryNum = new Stack<>();
        if(tar < toBinary) {
            System.out.println(tar);
        }
        while (tar >= toBinary) {
            binaryNum.add(binaryVALUE[(tar % toBinary)]);
            tar /= toBinary;
        }
        binaryNum.add(String.valueOf(tar));
        while (!binaryNum.empty()) {
            System.out.print(binaryNum.pop());
        }
    }
}

2、转换成2的n次幂

package 第二题;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        printResult(n);
    }

    public static ArrayList<Integer> get10To2(int n) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        // ArrayList.add()添加到列表尾部
        int count = 0;
        while (n != 0) {
            int temp = n % 2;
            // 记录为底数为“1”的位置
            if (temp == 1) list.add(count);
            n = n >> 1;
            count++;
        }
        return list;
    }

    public static void printResult(int n) {
        ArrayList<Integer> list = get10To2(n);
        // 递归出口n=0；输出0
        if (n == 0) System.out.print("0");
        for (int i = list.size() - 1; i >= 0; i--) {
            System.out.print("2");
            // 指数非1、0的，重新递归
            if (list.get(i) != 1) {
                System.out.print("(");
                printResult(list.get(i));
                System.out.print(")");
            }
            if (i != 0) {
                // list最后一个元素前，每次输出2时后面带上“+”
                System.out.print("+");
            }
        }
    }
}

(二)、测试代码

package 测试;

import java.util.Scanner;

public class Test {
    public static void main(String [] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("please input test's times:");
        int times = scanner.nextInt();
        System.out.println("第一题============================");
        test_one(times);
        System.out.println("第二题============================");
        test_two(times);
    }

    public static int test_one(int times) {
        if(times == 0) return 0;
        int toBinary = (int) (2 + Math.random() * 15);
        int tar = (int) (Math.random() * 2000);
        第一题.Main test = new 第一题.Main();
        test.setToBinary(toBinary);
        System.out.println("toBinary = " + toBinary + "    " + "tar = " + tar);
        System.out.print("递归方式：");
        System.out.println( 第一题.Main.nBinary_dg(tar).reverse().toString());
        第一题.Main.result.delete(0, 第一题.Main.result.length());
        System.out.print("非递归方式：");
        第一题.Main.nBinary(tar);
        System.out.println();
        return test_one(times - 1);
    }

    public static int test_two(int times) {
        if(times == 0) return 0;
        int tar = (int) (Math.random() * 20000);
        System.out.println("tar = " + tar);
        第二题.Main.printResult(tar);
        System.out.println();
        return test_two(times - 1);
    }
}

(三)、测试问题

第一题测试代码发现递归方式结果没有清零*

代码中增加清零语句避免出错

第二题测试未发现问题

四、递归调用过程

五、总结

递归的调用过程可以看成一个栈的入栈和出栈过程 ，进入递归即入栈，该层递归完成即出栈。因此递归的转换可以使用栈的方式来转换为非递归方式。