java笔试题+代码+解释

约定不等于承诺〃 2022-03-15 11:24 207阅读 0赞

**输出到100的质数（素数）除了1与自身不能被其他整除，需要剔除1与2，所以从3开始。**

public static void main(String[] args) {
            boolean bool;
            for (int i = 3; i <= 100; i += 2) {
                bool = true;
                for (int j = 3; j < i ; j++) {
                    if (i % j == 0) {
                        bool = false;
                        break;
                    }
                }
                if (bool){
                    System.out.println(i);
                }
            }
        }

**冒泡排序 稳定 最好O(N) 最坏O(N²)，自己理解的对不对，N²并不是两个嵌套循环就是相乘或者平方，而是内部数据移动位置的次数，来个明白人解释下，感谢。**

int[] arr = new int[]{996, 33, 78, 600,5, 8, 9};
            for (int i = 0 ; i <  arr.length ; i++) {
                for (int j = i + 1 ; j <  arr.length ; j++) {
                    System.out.println(" 比较次数"+ i +  "\t" + j);
                    int temp;
                    if (arr[i] > arr[j]){
                        temp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = temp;
                   }
            }
    }
    System.out.println(Arrays.toString(arr));

**Java数组中最大值与最小值，有内置函数。或者写排序取出第一个和最后一个元素。**

Integer[] arr = new Integer[]{1, 33, 78, 600,5, 8, 9};
    System.out.println(Collections.max(Arrays.asList(arr)));
    System.out.println(Collections.min(Arrays.asList(arr)));

**100-999的水仙花数，意思是个位十位百位数值的立方相加等于原数字，例如153拆分为1、5、3  
1的立方是1\*1\*1=1，5的立方是5\*5\*5=125，3的立方是3\*3\*3=27，那么就是1+125+27=153。**

public void test() {
    	int count = 999;
    	int x = 0;
    	int y = 0;
    	int z = 0;
    	for (int i = 100; i <= count; i++) {
    		x = i / 100;        //取百位
    		y = (i / 10) % 10;  //取十位
    		z = i % 10;         //取个位
    		int num = x*x*x + y*y*y + z*z*z;
    		if (i == num){
    			System.out.println(i);
    		}
    	}
    }

**最大公约数：如12能被1、2、3、4、6整除，16能被1,、2、4、8整除，那么12与16的公约数就是1、2、4，最大公约数是4。  
最小公倍数：如4的倍数有4、8、12……等等无限大，6的倍数有6、12、14、24,4与6的公有倍数为12、24那么最小的就是12。**  
名词解释：[https://baike.baidu.com/item/%E6%9C%80%E5%A4%A7%E5%85%AC%E7%BA%A6%E6%95%B0/869308?fr=aladdin][https_baike.baidu.com_item_E6_9C_80_E5_A4_A7_E5_85_AC_E7_BA_A6_E6_95_B0_869308_fr_aladdin]

/**
         * 思路 就是用大的数取余小的数，什么时候等于0了，那么就返回模数也就是 X % Y 的Y。
         * 如 24 % 12 等于0，最大公约数就是12，
         * 然后两个数相加 12 * 24 / 12 等于24，最小公倍数就是24.
         *
         * 在举例32与23
         * 过程32 % 23 = 9，23 % 9 = 5,9 % 5 = 4,5 % 4 = 1,4 % 1 = 0。这个时候返回 1 也就是32与23的最大公约数
         * 然后32 * 23 / 1 = 736，736 就是它们最小公倍数
         * @param a
         * @param b
         * @return
         */
        public static void main(String args[]) throws Exception {
            int m = 32;
            int n = 23;
            int c = gys(m,n);
            System.out.println(m*n/c);
            System.out.println(c);
        }
        public static int gys(int a ,int b){
            while (true){
                if((a = a % b ) == 0){
                    return b;
                }
                if((b = b % a ) == 0){
                    return a;
                }
            }
        }

**编程实现1000内的完数，0和1不是，一万以内的就4个6、28、496、8128，一万开外耗时太长没事建议别玩（上亿亿级别的运算）。  
概念，一个数的所有约数（自身除外）相加等于自身就是完数，例如6的约数是1、2、3、6。28是1、2、4、7、14、28，除去自身剩下的相加等于自身。**

for (int i = 1; i < 10000; i++) {
        int sum = 0;
        for (int j = 1;j < i ; j++){
            if (i % j == 0){
            sum += j;
            }
        }
        if (i == sum){
            System.out.println(sum);
        }
    }

**一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在   第10次落地时，共经过多少米？第10次反弹多高？需要注意第一次下落的100米也计算在内，并且每次反弹后落地是双距离。**

double s = 100; //总米数
    double t = 100; //当前高度
    for(int i=1;i<=10;i++){
        //这么写容易理解
        t = t/2;//当前高度 = 上次高度/2；
        s += t*2; //总米数= 当前米数 += 当前高度 * 一个来回，也就是2.
    }
    System.out.println(s);
    System.out.println(t);
    299.8046875
    0.09765625

**实现产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。  
这个怎么理解？我理解为一个长度为100的空数组，使用随机的方法向数组插入数据，要求插入的数据数组中不存在。老铁没毛病666.**

int[] array = new int[100];
    int j = 0;
    while (true) {
        boolean isAdd = true;
        int random = (int)(Math.random() * 101);
        for (int i = 0; i < array.length; i++) {
            if (array[i] == random){
                isAdd = false;
                break;
            }
        }
        if (isAdd) {
            array[j] = random;
            j++;
            if (j == 100){
                break;
            }
        }
    }
    Arrays.sort(array);
    System.out.println(Arrays.toString(array));

**将一个正整数分解质因数。例如：输入90,打印出90=2\*3\*3\*5。 （如果想输出1、2、3、5、7、9、11这样的数值就把i改成1）  
思路：找到这个数最小的约数，然后输出约数，在将这个数除约数，将得到的这个数在找到它的最小约数如此循环，最后退出的机制是当它除约数等于1的时候，也就是约数等于自身的时候退出。**

public static  void main(String[] args) {
        int value = 90;//输入的数值
        int i = 2;//约数 从2开始
        System.out.print(value + " = ");
        while (true){
            if (value % i == 0){
                value = value / i;
                if (value == 1){
                    System.out.print(i);
                    break;
                }else {
                    System.out.println(i + "*");
                }
                continue;
            }
            i++;
        }
    }

[https_baike.baidu.com_item_E6_9C_80_E5_A4_A7_E5_85_AC_E7_BA_A6_E6_95_B0_869308_fr_aladdin]: https://baike.baidu.com/item/%E6%9C%80%E5%A4%A7%E5%85%AC%E7%BA%A6%E6%95%B0/869308?fr=aladdin