杂七八糟的东西

dejavu1zz

发布于 2020-10-23 15:15:08

3410

发布于 2020-10-23 15:15:08

文章被收录于专栏：奇妙的算法世界

乱七八糟

Q：如何才能将一个double变量初始化为无穷大？ A：使用java的内置常数：Double.NEGATIVE_INFINITY和Double.POSITIVE_INFINITY

实现斐波那契数列

    public static void main(String[] args) {
        int f=0,g=1;
        for (int i = 0; i <= 15; i++) {
            System.out.print(f+" ");
            f = f + g;
            g = f - g;
        }
    }

每次用f储存当前值，用g存储前一个值

实现java的Integer.toBinaryString(String n)

        String s = "";
        for (int i = n; i > 0; i /= 2) {
            s = s + (i % 2);
        }
        System.out.println(s);

从左向右依次输出二进制位

使用递归实现两个数的乘法

public static int multiply(int a,int b){
	if(b==0) return 0;
	if(b%2==0) return multiply(a+a,b/2);
	return multiply(a+a,b/2)+a;
}

使用递归实现a的b次方

public static double power(double a,int b){
	if(b==0) return 1;
	if(b==1) return a;
	if(b%2==0) return power(a*a,b/2);
	return power(a*a,b/2)*a;
}

编写一段程序，创建一个NxN的布尔数组，当i和j互质时(互质是指两个数最大公约数为1)，a[i][j]为true,否则为false

import java.util.Scanner;

public class 互质 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        boolean[][] t = new boolean[a][b];
        for (int i = 0; i < a; i++) {
            for (int j = 0; j < b; j++) {
                if (gcd(i, j) != 1) {
                    t[i][j] = false;
                } else {
                    t[i][j] = true;
                }
            }
        }
    }

    public static long gcd(int a, int b) {
        if(b==0) return a;
        return gcd(b, a % b);
    }
}

如果将字符串s中的字符循环移动任意位置之后能够得到另一个字符串t，那么s就被称为t的回环变位，编写一个程序检查给定的两个字符串是否为回环变位

public static boolean circular(String s1,String s2){
	return s1.length()==s2.length()&&(s1+s1).indexOf(s2)>=0;
}

    public static boolean circular(String s1, String s2) {
        if(s1.length()!= s2.length()) return false;
        int length = s1.length();
        for (int i = 0; i < s1.length(); i++) {
            String left = s1.substring(0, i);
            String right = s1.substring(i, length);
            if ((right+left).equals(s2)) {
                return true;
            }
        }
        return false;
    }

使用递归的方式逆序输出字符串

    public static String tt(String s1) {
        int N = s1.length();
        if(N<=1) return s1;
        String a = s1.substring(0, N / 2);
        String b = s1.substring(N / 2, N);
        return tt(b) + tt(a);
    }

使用System.currentTimeMillis()可以获取当前系统的时间

对于大小为10000的数组排序，各排序算法性能：（测试数据来于leetcode912题）