编程练习题

编程练习题

第一周期

注：题目均来自于力扣（LeetCode）

1、实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

思路：利用二分搜索法

2、对于一个 正整数，如果它和除了它自身以外的所有 正因子 之和相等，我们称它为 「完美数」。
给定一个 整数 n， 如果是完美数，返回 true，否则返回 false

思路：可以发现这样一个规律，如24的因子为1，2，3，4，6，8，12，24，我们只需要找到1，2，3，4这四个数，就可以通过num/i的方式找出所有的因子，我称这四个因子为小因子，称num/i得到的因子为大因子，那么大因子和小因子的分割线正好是num**0.5，所以通过这个规律可以大幅度减小时间复杂度。
此外，还需要注意，这题有两个陷阱：（1）完美数的定义是在正整数范围内的，但这里给的是整数，因此需要排除负整数的情况；（2）正整数1，它并不是完美数。

3、小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。

思路：

class Solution {
    public int game(int[] guess, int[] answer) {
        int count = 0;
        for (int i = 0;i < guess.length;i++){
            if (answer[i] == guess[i]){
              count++;  
            }
        }    
        return count;
    }
}

第二周期

1、给你一个非负整数 num ，请你返回将它变成 0 所需要的步数。 如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。

思路：输入一个非负整数，首先判断是否为0，若为零则直接返回0，然后判断是否为偶数，若为偶数，则除以2，若为奇数则减去1，然后利用循环继续判断，直到该数变为一，然后统计它的步数。

2、给你一个仅由数字 6 和 9 组成的正整数 num。

你最多只能翻转一位数字，将 6 变成 9，或者把 9 变成 6 。

请返回你可以得到的最大数字。

思路：首先输入一个仅由数字6和9组成的正整数，然后对该整数进行逐位遍历，将找到的第一个6翻转成9。

3、请实现一个函数，输入一个整数（以二进制串形式），输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。

思路：我们对于一个二进制数含1的个数是可以逐个数出来的，如下：
如果n & 1 = 0, 则n的最后一位是0

如果n & 1 = 1, 则n的最后一位是1

这样就能统计出最后一位是否含有1。每次将n右移一位就可以更新得到新的最后一位，继续和1做与运算即可。

第三周期

1、斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给你 n ，请计算 F(n) 。

代码示例如下：

import java.util.Scanner;
public class LianXi6 {
    public static void main (String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        System.out.println(F(n));
    }
    public static int F(int n) {
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }else {
            return F(n - 1) + F(n - 2);
        }
    }
}

结果：

2、在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。返回重复了 N 次的那个元素。

思路：有一个数重复N次，而且所有数的个数为2N，因此，也就是说，要求的这个数占了一半。那么必然可得，一定会出现连续的三个数，其中有两个数相等，也就是所要求的数。举个例子，比如有数组[ 1, 2, 4, 5, 3, 3, 3, 3 ] ，那么将3打的最散的排列是 [1, 3, 2, 3, 4, 3, 5, 3] 。可以发现无论怎么排，一定会出现三个连续的数，其中存在两个相同的数。

3、判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

import java.util.Scanner;
public class LianXi6 {
    public static void main (String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Enter a number : ");
        int number = input.nextInt();
        //1.特殊情况当数字小于0时，当数字最后一位数为0，但该数字不等于0时
        if (number < 0 || (number % 10 == 0 && number != 0)){
            System.out.println(number + "不是回文数字");
            return;
        }
        //2.判断该数是否为回文数字
        int sum = 0;
        int x = number;
        while(x != 0) {
            sum = sum * 10 + x % 10;
            x /= 10; 
        }
        if (number == sum) {
            System.out.println(number + "是回文数字");
        }else {
            System.out.println(number + "不是回文数字");
        }
        
    }
}

结果：

第四周期

1、给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

class Solution {
    public int[] plusOne(int[] digits) {
        int carry = 1;
        for (int i = digits.length - 1; i >= 0; i--) {
            int num = digits[i] + carry;
            digits[i] = num % 10;
            carry = num / 10;
            if (carry == 0) {
                break;
            }
        }
        if (carry == 1) {
            int[] arr = new int[digits.length + 1];
            arr[0] = 1;
            return arr;
        }
        return digits;
    }
}

思考与拓展：要是两个长度不同的整数组成的非空数组所表示的非负整数相加的结果该怎样求得呢？

升级版代码如下：

import java.util.*;
public class LianXi10 {
    public static void main(String[] args) {
        LianXi10 s = new LianXi10();
        int[] arr1 = {1,2,3};
        int[] arr2 = {9,8,7};
        int[] arr3 = s.plus(arr1,arr2);
        System.out.println(Arrays.toString(arr3));
    }
    //1.判断两个数组的长度 ，然后给短的数组扩容
    public int[] plus(int[] digits1, int[] digits2) {
        if (digits1.length < digits2.length) {
            digits1 = kuoRong(digits1, digits2.length);
        } else if (digits1.length > digits2.length) {
            digits2 = kuoRong(digits2,digits1.length);
        }
        //2.判断十进制进位情况
        int carry = 0;
        for (int i = digits1.length - 1; i >= 0; i--) {
            int num = digits1[i] + digits2[i] + carry;  //两个整数同位数字相加，再加上后一位的进位，
            carry = num / 10;  //进位数等于num除以十
            digits1[i] = num % 10;  //进位完毕后剩余的数，对10取余即可得到。
        }
        /*3.若上面过程完毕后 carry 还是等于1，则证明进位超出目前的最大值 
            需要对数组进行扩容 角标0的位置存1 后面的位置存原数组的数字
         */
        if (carry == 1) {
            int[] digits3 = new int[digits1.length + 1];
            digits3[0] = 1;
            for (int i = 0; i < digits1.length; i++) {
                digits3[i + 1] = digits1[i];
            }
            return digits3;
        }
        return digits1;
    }
    // 对端的数组进行扩充的函数
    public int[] kuoRong(int[] arr, int newlen) {
        int[] newArr = new int[newlen]; //定义一个新数组 其长度为比较后较长数组的长度
        // 将原数组的元素从后往前 依次放入新数组中 多出来的部分初始化为0 
        //然后返回新数组的结果
        int i = arr.length - 1;
        int k = newArr.length - 1;
        while (i >= 0) {
            newArr[k--] = arr[i--];
        }
        return newArr;
    }
}

2、移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

代码如下：

//双指针法 K一直卡着第一个零
class Solution {
    public void moveZeroes(int[] nums) {
        int k = 0;
        int temp = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                temp = nums[i];
                nums[i] = nums[k];
                nums[k] = temp;
                k++;
            }
        }
    }
}

3、给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

代码如下：

class Solution {
    public int majorityElement(int[] nums) {
        int m = nums[0];
        int count = 1;
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] == m) {
        count++;
    } else {
        count--;
        if (count == 0) {
        m = nums[i];
        count = 1;
        }
        }
    }
    return m;
    }
}