开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第6天(点击查看活动详情)

今天周六呢，在家刷了算法题目，把题目发出来给大家看看，欢迎讨论呢？

阶乘后的零

给定一个整数 n ，返回 n! 结果中尾随零的数量。 提示 n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1

示例 1：

输入：n = 3 输出：0

解释：3! = 6 ，不含尾随 0

示例 2：

输入：n = 5 输出：1

解释：5! = 120 ，有一个尾随 0

示例 3：

输入：n = 0

输出：0

提示：

0 <= n <= 104

进阶：你可以设计并实现对数时间复杂度的算法来解决此问题吗？

Java参考代码

class Solution {
    public int trailingZeroes(int n) {
        int count = 0;
        while (n >= 5) {
            count += n / 5;
            n /= 5;
        }
        return count;
    }
}

阶乘后的零

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符 数值

I 1

V 5

X 10

L 50

C 100

D 500

M 1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。

X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 

C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

给你一个整数，将其转为罗马数字。

 

示例 1:

输入: num = 3

输出: "III"

示例 2:

输入: num = 4

输出: "IV"

示例 3:

输入: num = 9

输出: "IX"

示例 4:

输入: num = 58

输出: "LVIII"

解释: L = 50, V = 5, III = 3.

示例 5:

输入: num = 1994

输出: "MCMXCIV"

解释: M = 1000, CM = 900, XC = 90, IV = 4.

 

提示：

1 <= num <= 3999

Java参考代码

class Solution {
    public String intToRoman(int num) {
        int f = 1000;
        int f2 = 1000;
        char[] sym = new char[] { 'M', 'D', 'C', 'L', 'X', 'V', 'I' };
        int fsi = 0;
        int[] s = new int[] { 2, 5 };
        int si = 0;
        int[] s2 = new int[] { 10, 1 };
        int si2 = 0;
        StringBuilder roman = new StringBuilder();
        while (num > 0) {
            int d = (int) Math.floor(num / f);
            int r = num % f;
            int d2 = (int) Math.floor(num / f2);
            int r2 = num % f2;
            if (d > 0) {
                if (d == 4) {
                    roman.append(sym[fsi]);
                    roman.append(sym[fsi - 1]);
                    num = r;
                } else if (d2 == 9) {
                    roman.append(sym[fsi + 1]);
                    roman.append(sym[fsi - 1]);
                    num = r2;
                } else {
                    for (int i = 0; i < d; i++) {
                        roman.append(sym[fsi]);
                    }
                    num = r;
                }
            }
            f = f / s[si];
            si++;
            si %= 2;
            f2 = f2 / s2[si2];
            si2++;
            si2 %= 2;
            fsi++;
        }
        return roman.toString();
    }
}

分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。 回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab" 输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a" 输出：[["a"]]

提示：

1 <= s.length <= 16 s 仅由小写英文字母组成

Java参考代码

class Solution {
    public List<List<String>> partition(String s) {
        boolean[][] dp = new boolean[s.length()][s.length()];
        for (int len = 1; len <= s.length(); len++) {
            for (int i = 0; i <= s.length() - len; i++) {
                if (len == 1)
                    dp[i][i] = true;
                else if (s.charAt(i) == s.charAt(i + len - 1) && (len == 2 || dp[i + 1][i + len - 2])) {
                    dp[i][i + len - 1] = true;
                }
            }
        }
        return solution(s, 0, dp);
    }
    public List<List<String>> solution(String s, int start, boolean[][] dp) {
        ArrayList<List<String>> list = new ArrayList<>();
        if (start == s.length()) {
            List<String> li = new ArrayList<>();
            list.add(li);
            return list;
        }
        for (int i = start; i < s.length(); i++) {
            if (dp[start][i]) {
                String first = s.substring(start, i + 1);
                for (List<String> li : solution(s, i + 1, dp)) {
                    li.add(0, first);
                    list.add(li);
                }
            }
        }
        return list;
    }
}