1.1 基础编程模型

一.欧几里得算法:

public static int gcd(int p, int q) {
        if (q == 0) return p;
        int r = p % q;
        return gcd(q, r);
    }

解释:比如求16和12的最大公约数，16(p)÷12(q)=1余4(r), 12(p)÷4(q)=3余0(r)。所以只要判断r为0即返回除数p，用递归实现。

二.java除数和取余原理

表达式a/b的商会向0取整，如-14/3和14/3的商都是-4.
a%b的定义是(a/b)*b+a%b恒等于a，即a%b=a-(a/b)*b
如-14%3=(-14)-(-14/3)*3=-2;14/-3=2。

三.java中的简单进制操作

System.out.println(Integer.toBinaryString(16));//十进制转二进制
System.out.println(Integer.toOctalString(16));//十进制转八进制
System.out.println(Integer.toHexString(16));十进制转十六进制
System.out.println(Integer.valueOf("10",16).toString());//十六进制转十进制
System.out.println(Integer.valueOf("20",8).toString());//八进制转十进制
System.out.println(Integer.valueOf("10000",2).toString());//二进制转十进制

四.java中的位逻辑运算符

1.与(&)

System.out.println(Integer.toBinaryString(129));//10000001
System.out.println(Integer.toBinaryString(128));//10000000
System.out.println(Integer.toBinaryString(129&128));//10000000

2.或(|)
有1即为1

3.异或(^)
相同为0不同为1

4.非(~)
0–>1,1–>0

五.在java中一个静态方法可以将另一个静态方法作为参数吗

不行，但问得好，因为很多语言都可以。

六.将正整数N转换为二进制的简单方法

public static String toBinary(int N){
        String s="";
        for(int n=N;n>0;n/=2){
            s=n%2+s;
        }
        return s;
    }

七.编写一段代码，打印出M行N列二维数组的转置

public static void transposition(){
        int array[][]= {{1,2,3},{4,5,6}};
        int M=array.length;//行
        int N=array[0].length;//列
        for(int i=0;i<N;i++){
            for(int j=0;j<M;j++){
                System.out.print(array[j][i]+"    ");
            }
            System.out.println("");
        }
    }

八.求不大于log₂N(N为整数)的最大整数,不能使用math库

public static int maxLog2N(int N){
        if(N<=0) return 0;
        int i=0;
        for(int n=1;n<=N;n*=2){
            i++;
        }
        return i-1;
    }

九.编写一个递归的静态方法计算ln(N!)的值

public static double logeN(int N) {
        if (N == 1) return Math.log(N);
        else return Math.log(N)+logeN(N - 1);
    }

解释:比如说输入4，那么会按以下几部走:
ln(4)+logeN(3)---->ln(4)+ln(3)+logeN(2)---->ln(4)+ln(3)+ln(2)+logeN(1)

十.编写一个简单的矩阵库

public class Matrix {
    //向量点乘
    public static double dot(double[] x, double[] y) {
        double result = 0.0;
        if (x.length != y.length) {
            return 0;
        }
        for (int i = 0; i < x.length; i++) {
            result += x[i] * y[i];
        }
        return result;
    }

    //转置矩阵
    public static double[][] transpose(double[][] a) {
        double[][] result = new double[a[0].length][a.length];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                result[j][i] = a[i][j];
            }
        }
        return result;
    }

    //向量和矩阵之积[n*m].[m*1]=[n*1]
    public static double[] mult(double[][] a, double[] b) {
        double[] result = new double[a.length];
        for (int i = 0; i < result.length; i++) {
            result[i] = dot(a[i], b);
        }
        return result;
    }

    //向量和矩阵之积[1*n][n*m]=[1*m]
    public static double[] mult(double[] a, double[][] b) {
        double[] result = new double[b[0].length];
        //又要获取b的列,转置
        double[][] transpose = transpose(b);
        for (int i = 0; i < result.length; i++) {
            result[i] = dot(a,b[i]);
        }
        return result;
    }

    //矩阵和矩阵之乘积
    public static double[][] mult(double[][] a, double[][] b) {
        if (a == null || b == null) return null;
        if (a[0].length != b.length) return null;
        double[][] result = new double[a.length][b[0].length];
        //java中好像没有直接取一列的方法,所以用乘转置的方法吧
        double[][] transpose = transpose(b);
        for (int i = 0; i < result.length; i++) {
            for (int j = 0; j < result[0].length; j++) {
                result[i][j] = dot(a[i], transpose[j]);
            }
        }
        return result;
    }
}