LeetCode 数学

基础部分

204. 计数质数

简单

统计所有小于非负整数 n 的质数的数量。

示例:

输入: 10
输出: 4
解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

class Solution {
    public int countPrimes(int n) {
        if (n < 2) return 0;
        boolean[] dp = new boolean[n];
        int res = 0;
        for (int i = 2; i < n; i++)
            if (!dp[i]) {
                res++;
                for (int j = 2; i*j < n; j++){
                    dp[i*j] = true;
                }
            }
        return res;
    }
}

504. 七进制数

简单

给定一个整数，将其转化为7进制，并以字符串形式输出。

示例 1:

输入: 100
输出: "202"

示例 2:

输入: -7
输出: "-10"

注意: 输入范围是 [-1e7, 1e7] 。

class Solution {
    public String convertToBase7(int num) {
        if (num == 0) return "0";
        String sign = "";
        if (num < 0){
            num = - num;
            sign += "-";
        }
        StringBuilder ans = new StringBuilder();
        while (num > 0){
            int add = num % 7;
            ans.append(add);
            num /= 7;
        }
        return sign + String.valueOf(ans.reverse());
    }
}

405. 数字转换为十六进制数

简单

给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用 补码运算 方法。

注意:

1. 十六进制中所有字母(a-f)都必须是小写。
2. 十六进制字符串中不能包含多余的前导零。如果要转化的数为0，那么以单个字符'0'来表示；对于其他情况，十六进制字符串中的第一个字符将不会是0字符。
3. 给定的数确保在32位有符号整数范围内。
4. 不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。

示例 1：

输入:
26

输出:
"1a"

示例 2：

输入:
-1

输出:
"ffffffff"

class Solution {
    public String toHex(int num) {
        char[] digits = new char[16]; //字典
        for (int i = 0; i < 10; i++)
            digits[i] = (char) (i + (int)'0') ;
        for (int i = 10; i < 16; i++)
            digits[i] = (char) (i - 10 + (int)'a');
        int a = 15;
        StringBuilder sb = new StringBuilder();
        while (num != 0){
            int add = num & a;
            num = num >>> 4;
            sb.append(digits[add]);
        }
        return sb.length()==0 ? "0" : sb.reverse().toString();
    }
}

168. Excel表列名称

简单

给定一个正整数，返回它在 Excel 表中相对应的列名称。

例如，

    1 -> A
    2 -> B
    3 -> C
    ...
    26 -> Z
    27 -> AA
    28 -> AB 
    ...

示例 1:

输入: 1
输出: "A"

示例 2:

输入: 28
输出: "AB"

示例 3:

输入: 701
输出: "ZY"

class Solution {
    public String convertToTitle(int n) {
        char[] letters = new char[26];
        for (int i = 0; i < 26; i++)
            letters[i] = (char)(i+(int)'A');
        StringBuilder res = new StringBuilder();
        while (n != 0){
            n--; //※※※，从1开始算的，而不是从0开始，所以要减1
            int add = (n) % 26;
            n = n / 26;
            res.append(letters[add]);
        }
        return res.reverse().toString();
    }
}

172. 阶乘后的零

简单

给定一个整数 n，返回 n! 结果尾数中零的数量。

示例 1:

输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零。

示例 2:

输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零.

class Solution {
    public int trailingZeroes(int n) {
        int res = 0;
        while (n != 0){
            n /= 5; //每乘一个5加一个量级
            res += n;
        }
        return res;
    }
}

67. 二进制求和

简单

给你两个二进制字符串，返回它们的和（用二进制表示）。

输入为 非空 字符串且只包含数字 1 和 0。

示例 1:

输入: a = "11", b = "1"
输出: "100"

示例 2:

输入: a = "1010", b = "1011"
输出: "10101"

提示：

• 每个字符串仅由字符 '0' 或 '1' 组成。
• 1 <= a.length, b.length <= 10^4
• 字符串如果不是 "0" ，就都不含前导零。

class Solution {
    public String addBinary(String a, String b) {
        StringBuilder res = new StringBuilder();
        int la = a.length();
        int lb = b.length();
        int len = Math.max(la,lb), carry = 0;
        for (int i = 0; i < len; i++){
            carry += la-1-i < 0 ? 0 : (int)a.charAt(la-1-i)-'0';
            carry += lb-1-i < 0 ? 0 : (int)b.charAt(lb-1-i)-'0';
            res.append(carry%2);
            carry /= 2;
        }
        if (carry == 1) res.append(carry);
        return res.reverse().toString();
    }
}

//自带函数
return Integer.toBinaryString(Integer.parseInt(a, 2) + Integer.parseInt(b, 2));

415. 字符串相加

简单

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。

注意：

1. num1 和num2 的长度都小于 5100.
2. num1 和num2 都只包含数字 0-9.
3. num1 和num2 都不包含任何前导零。
4. 你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式。

class Solution {
    public String addStrings(String num1, String num2) {
        int la = num1.length(), lb = num2.length();
        int len = la > lb ? la : lb, carry = 0;
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < len; i++){
            carry += la-1-i < 0 ? 0 : (int)num1.charAt(la-1-i) - '0';
            carry += lb-1-i < 0 ? 0 : (int)num2.charAt(lb-1-i) - '0';
            res.append(carry%10);
            carry /= 10;
        }
        if (carry > 0) res.append(carry);
        return res.reverse().toString();
    }
}

462. 最少移动次数使数组元素相等 II

中等

给定一个非空整数数组，找到使所有数组元素相等所需的最小移动数，其中每次移动可将选定的一个元素加1或减1。 您可以假设数组的长度最多为10000。

例如:

输入:
[1,2,3]

输出:
2

说明：
只有两个动作是必要的（记得每一步仅可使其中一个元素加1或减1）： 

[1,2,3]  =>  [2,2,3]  =>  [2,2,2]

class Solution { //全排序，4ms
    public int minMoves2(int[] nums) {
        Arrays.sort(nums); //可以减治，找中位数，懒得写了
        int res = 0;
        int mid = nums[nums.length/2];
        for (int num : nums){
            res += Math.abs(mid-num);
        }
        return res;
    }
}

class Solution { //快排，更慢了，73ms
    public int minMoves2(int[] nums) {
        if (nums.length < 2) return 0;
        int res = 0;
        int mid = helper(nums,0,nums.length-1,nums.length/2);
        for (int num : nums)
            res += Math.abs(mid-num);
        return res;
    }

    private int helper(int[] nums, int l, int r, int correct){
        if (l == r) return nums[r];
        int first = nums[l];
        int i = l;
        int j = r + 1;
        while (i < j){
            do{
                i++;
            }while (i < r && nums[i] < first);
            do{
                j--;
            }while (l < j && nums[j] > first);
            if (i >= j) break;
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
        int tmp = nums[l];
        nums[l] = nums[j];
        nums[j] = tmp;
        if (j == correct) return nums[j];
        else if (j < correct) return helper(nums, j+1, r, correct);
        else return helper(nums, l, j-1, correct);
    }
}

169. 多数元素

简单

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:

输入: [3,2,3]
输出: 3

示例 2:

输入: [2,2,1,1,1,2,2]
输出: 2

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

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

367. 有效的完全平方数

简单

给定一个正整数 num，编写一个函数，如果 num 是一个完全平方数，则返回 True，否则返回 False。

说明：不要使用任何内置的库函数，如 sqrt。

示例 1：

输入：16
输出：True

示例 2：

输入：14
输出：False

class Solution {
    public boolean isPerfectSquare(int num) {
        long a = 0;
        for (int i = 1; i < num+1; i++){
            a = i * i;
            if (a >= num) break;
        }
        return a == num;
    }
}

326. 3的幂

简单

给定一个整数，写一个函数来判断它是否是 3 的幂次方。

示例 1:

输入: 27
输出: true

示例 2:

输入: 0
输出: false

示例 3:

输入: 9
输出: true

示例 4:

输入: 45
输出: false

进阶：
你能不使用循环或者递归来完成本题吗？

class Solution {
    public boolean isPowerOfThree(int n) {
        while (n > 1) {
            if (n%3 != 0) break;
            n /= 3;
        }
        return n == 1;
    }
}

238. 除自身以外数组的乘积

中等

给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

示例:

输入: [1,2,3,4]
输出: [24,12,8,6]

提示：题目数据保证数组之中任意元素的全部前缀元素和后缀（甚至是整个数组）的乘积都在 32 位整数范围内。

说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。

进阶：
你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int len = nums.length;
        int[] l = new int[len];
        int[] r = new int[len];
        l[0] = 1;
        for (int i = 1; i < len; i++) l[i] = l[i-1] * nums[i-1];
        r[len-1] = 1;
        for (int i = len-2; i >= 0; i--) r[i] = r[i+1] * nums[i+1];
        for (int i = 0; i < len; i++) l[i] *= r[i];
        return l;
    }
}

628. 三个数的最大乘积

简单

给定一个整型数组，在数组中找出由三个数组成的最大乘积，并输出这个乘积。

示例 1:

输入: [1,2,3]
输出: 6

示例 2:

输入: [1,2,3,4]
输出: 24

注意:

1. 给定的整型数组长度范围是[3,104]，数组中所有的元素范围是[-1000, 1000]。
2. 输入的数组中任意三个数的乘积不会超出32位有符号整数的范围。

class Solution {
    public int maximumProduct(int[] nums) {
        Arrays.sort(nums);
        int len = nums.length;
        int a = nums[len-1] * nums[len-2] * nums[len-3];
        int b = nums[0] * nums[1] * nums[len-1];
        return a > b ? a : b;
    }
}

频率排序

892，829，887，233，869，805，458，2，1121，423，483，469，149，365，640，535，782，1012，754，885，7，593，9，753，400