Thinking in Java 第四章练习（吸血鬼数字）_用java编写,接受一个整数参数,并显示从第一个元素开始总共由该参数指定个数所构成-优快云博客

练习一：产生25个int类型的随机数。对于每一个随机值，使用 if-else语句来将其分类为大于、小于或等于紧随它而随机生成的值。

public class RandomInt {

    public static void main(String[] args) {
        Random random =new Random();
        int[] arr=new int[25];
        for(int i=0;i<25;i++){
            arr[i]=random.nextInt(50);
        }
        for(int j=0;j<arr.length-1;j++){
            //25个数比较24次
            if(arr[j]<arr[j+1]){
                System.out.println("数："+arr[j]+" < "+"数"+arr[j+1]);
            }
            else if(arr[j]>arr[j+1]){
                System.out.println("数："+arr[j]+" > "+"数"+arr[j+1]);
            }
            else{
                System.out.println("数："+arr[j]+" = "+"数"+arr[j+1]);
            }
        }
    }
}

练习二：写一个程序，使用两个嵌套的for循环和取余操作符（%）来探测和打印素数（只能被其自身和1整除，而不能被其它数字整除的整数）。

public class PrintPrime {

    public static void main(String[] args) {
        for(int i=1;i<=100;i++){
            boolean Isprime=false;
            for(int j=2;j<i;j++){
                if(i%j==0){
                    Isprime=false;
                    break;//不是素数就要终止
                }
                else{
                    Isprime=true;
                }
            }
            if(Isprime){
                System.out.print(i+" ");
            }
        }
    }
}

练习三：不要用Integer.toBinaryString()方法，而是用三元操作符和按位操作符来显示二进制的1和0。
方法一：创建数组的方法

public class TobinaryString {

    public static void main(String[] args) {
        int num=1999;
        System.out.println(Integer.toBinaryString(num));
        printBinaryString(num);
    }
    public static void printBinaryString(int num){
        int arr[]=new int[32];
        for(int i=0;i<32;i++){
            arr[i]=(num>>i)&1;
        }
        for(int i=31;i>=0;i--){
            System.out.print(arr[i]);
        }
        System.out.println();
    }
}

方法二：不创建数组

    public static void printBinaryString2(int num){
        for(int i=31;i>=0;i--){
            System.out.print((num>>i)&1);
        }

练习三：一个斐波那契数列是由数字1、1、2、3、5、8、13、21、34等等组成的，其中每一个数字（从第三个数字起）都是前两个数字的和。创建一个方法，接收一个整数参数，并显示从第一个元素开始总共由该参数指定的个数所构成的所有斐波那契数字。例如，如果运行java Fibonacci 5(其中Fibonacci是类名)，那么输出就应该是1、1、2、3、5。

public class Fib {
    public static void main(String[] args) {
        int num=5;
        System.out.println(FibNum(num));
        int[] arr=Fibonacci(num);
        System.out.println(Arrays.toString(arr));
    }
    public static int FibNum(int num){
        if(num==1||num==2){
            return 1;
        }
        else{
            return FibNum(num-2)+FibNum(num-1);
        }
    }
    public static int[] Fibonacci(int num){
        int arr[]=new int[num];
        for(int i=0;i<num;i++){
            arr[i]=FibNum(i+1);
        }
        return arr;
    }
}

5
[1, 1, 2, 3, 5]

练习四吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这对数字各含乘积的一半位数的数字，其中从最初的数字中选取的数字可以任意排序。以两个0结尾的数字是不允许的，例如，下列数字都是“吸血鬼”数字：

1260 = 21 * 60
1827 = 21 * 87
2187 = 27 * 81
写一个程序，找出4位数的所有吸血鬼数字。

这道题有这么一个算法，我们将这个四位数看成，1000a+100b+10c+d
这里以1260为例子，此时a=1,b=2,c=6,d=0
1260=2160可以看成1260=（10b+a）（10c+d）
当1260-21-60=999a+90b，可以被9整除
同理也使用于其他的吸血鬼数字，所以我们可以初步筛选，这个吸血鬼数字减去两个乘积的数可以被9整除。
因此就可以写代码了

public class VampireNum {
    //1260 = 21 * 60
    public static void main(String[] args) {
        int[] startnum=new int[4];
        int[] productnum=new int[4];
        int count=0;
        for(int i=10;i<100;i++){
            for(int j=i;j<100;j++){
                int product=i*j; //1260
                if(product%100==0||(product-i-j)%9!=0){
                    continue;
                }
                count++;
                startnum[0]=i/10;//2
                startnum[1]=i%10;//1
                startnum[2]=j/10;//6
                startnum[3]=j%10;//0

                productnum[0]=product/1000;//1
                productnum[1]=product%1000/100;//2
                productnum[2]=product%100/10;//6
                productnum[3]=product%10;//0
                int num=0;
                for(int x=0;x<productnum.length;x++){
                    for(int y=0;y<startnum.length;y++){
                        if(productnum[x]==startnum[y]){
                            num++;
                            productnum[x]=-1;
                            startnum[y]=-2;
                            if(num==4){
                                System.out.println("i="+i+" j="+j+" product="+product);
                            }
                        }
                    }
                }
            }
        }
        System.out.println("count= "+count);
    }
}

输出结果：

i=15 j=93 product=1395
i=21 j=60 product=1260
i=21 j=87 product=1827
i=27 j=81 product=2187
i=30 j=51 product=1530
i=35 j=41 product=1435
i=80 j=86 product=6880
count= 297